src/rrd_graph.c

   1 /****************************************************************************
   2  * RRDtool 1.2.12  Copyright by Tobi Oetiker, 1997-2005
   3  ****************************************************************************
   4  * rrd__graph.c  produce graphs from data in rrdfiles
   5  ****************************************************************************/
   6
   7
   8 #include <sys/stat.h>
   9
  10 #include "rrd_tool.h"
  11
  12 #if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__)
  13 #include <io.h>
  14 #include <fcntl.h>
  15 #endif
  16
  17 #ifdef HAVE_TIME_H
  18 #include <time.h>
  19 #endif
  20
  21 #ifdef HAVE_LOCALE_H
  22 #include <locale.h>
  23 #endif
  24
  25 #include "rrd_graph.h"
  26
  27 /* some constant definitions */
  28
  29
  30
  31 #ifndef RRD_DEFAULT_FONT
  32 /* there is special code later to pick Cour.ttf when running on windows */
  33 #define RRD_DEFAULT_FONT "DejaVuSansMono-Roman.ttf"
  34 #endif
  35
  36 text_prop_t text_prop[] = {
  37      { 8.0, RRD_DEFAULT_FONT }, /* default */
  38      { 9.0, RRD_DEFAULT_FONT }, /* title */
  39      { 7.0,  RRD_DEFAULT_FONT }, /* axis */
  40      { 8.0, RRD_DEFAULT_FONT }, /* unit */
  41      { 8.0, RRD_DEFAULT_FONT }  /* legend */
  42 };
  43
  44 xlab_t xlab[] = {
  45     {0,                 0,   TMT_SECOND,30, TMT_MINUTE,5,  TMT_MINUTE,5,         0,"%H:%M"},
  46     {2,                 0,   TMT_MINUTE,1,  TMT_MINUTE,5,  TMT_MINUTE,5,         0,"%H:%M"},
  47     {5,                 0,   TMT_MINUTE,2,  TMT_MINUTE,10, TMT_MINUTE,10,        0,"%H:%M"},
  48     {10,                0,   TMT_MINUTE,5,  TMT_MINUTE,20, TMT_MINUTE,20,        0,"%H:%M"},
  49     {30,                0,   TMT_MINUTE,10, TMT_HOUR,1,    TMT_HOUR,1,           0,"%H:%M"},
  50     {60,                0,   TMT_MINUTE,30, TMT_HOUR,2,    TMT_HOUR,2,           0,"%H:%M"},
  51     {180,               0,   TMT_HOUR,1,    TMT_HOUR,6,    TMT_HOUR,6,           0,"%H:%M"},
  52     {180,       1*24*3600,   TMT_HOUR,1,    TMT_HOUR,6,    TMT_HOUR,6,           0,"%a %H:%M"},
  53     /*{300,             0,   TMT_HOUR,3,    TMT_HOUR,12,   TMT_HOUR,12,    12*3600,"%a %p"},  this looks silly*/
  54     {600,               0,   TMT_HOUR,6,    TMT_DAY,1,     TMT_DAY,1,      24*3600,"%a"},
  55     {600,       1*24*3600,   TMT_HOUR,6,    TMT_DAY,1,     TMT_DAY,1,      24*3600,"%a %d"},
  56     {1800,              0,   TMT_HOUR,12,   TMT_DAY,1,     TMT_DAY,2,      24*3600,"%a"},
  57     {1800,      1*24*3600,   TMT_HOUR,12,   TMT_DAY,1,     TMT_DAY,2,      24*3600,"%a %d"},
  58     {3600,              0,   TMT_DAY,1,     TMT_WEEK,1,    TMT_WEEK,1,    7*24*3600,"Week %V"},
  59     {3*3600,            0,   TMT_WEEK,1,    TMT_MONTH,1,   TMT_WEEK,2,    7*24*3600,"Week %V"},
  60     {6*3600,            0,   TMT_MONTH,1,   TMT_MONTH,1,   TMT_MONTH,1, 30*24*3600,"%b"},
  61     {48*3600,           0,   TMT_MONTH,1,   TMT_MONTH,3,   TMT_MONTH,3, 30*24*3600,"%b"},
  62     {10*24*3600,        0,   TMT_YEAR,1,  TMT_YEAR,1,    TMT_YEAR,1, 365*24*3600,"%y"},
  63     {-1,0,TMT_MONTH,0,TMT_MONTH,0,TMT_MONTH,0,0,""}
  64 };
  65
  66 /* sensible logarithmic y label intervals ...
  67    the first element of each row defines the possible starting points on the
  68    y axis ... the other specify the */
  69
  70 double yloglab[][12]= {{ 1e9, 1,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0 },
  71                        {  1e3, 1,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0 },
  72                        {  1e1, 1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0 },
  73                        /* {  1e1, 1,  5,  0,  0,  0,  0,  0,  0,  0,  0,  0 }, */
  74                        {  1e1, 1,  2.5,  5,  7.5,  0,  0,  0,  0,  0,  0,  0 },
  75                        {  1e1, 1,  2,  4,  6,  8,  0,  0,  0,  0,  0,  0 },
  76                        {  1e1, 1,  2,  3,  4,  5,  6,  7,  8,  9,  0,  0 },
  77                        {  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0 }};
  78
  79 /* sensible y label intervals ...*/
  80
  81 ylab_t ylab[]= {
  82     {0.1, {1,2, 5,10}},
  83     {0.2, {1,5,10,20}},
  84     {0.5, {1,2, 4,10}},
  85     {1.0,   {1,2, 5,10}},
  86     {2.0,   {1,5,10,20}},
  87     {5.0,   {1,2, 4,10}},
  88     {10.0,  {1,2, 5,10}},
  89     {20.0,  {1,5,10,20}},
  90     {50.0,  {1,2, 4,10}},
  91     {100.0, {1,2, 5,10}},
  92     {200.0, {1,5,10,20}},
  93     {500.0, {1,2, 4,10}},
  94     {0.0,   {0,0,0,0}}};
  95
  96
  97 gfx_color_t graph_col[] =   /* default colors */
  98 {    0xFFFFFFFF,   /* canvas     */
  99      0xF0F0F0FF,   /* background */
 100      0xD0D0D0FF,   /* shade A    */
 101      0xA0A0A0FF,   /* shade B    */
 102      0x90909080,   /* grid       */
 103      0xE0505080,   /* major grid */
 104      0x000000FF,   /* font       */
 105      0x802020FF,   /* arrow      */
 106      0x202020FF,   /* axis       */
 107      0x000000FF    /* frame      */
 108 };
 109
 110
 111 /* #define DEBUG */
 112
 113 #ifdef DEBUG
 114 # define DPRINT(x)    (void)(printf x, printf("\n"))
 115 #else
 116 # define DPRINT(x)
 117 #endif
 118
 119
 120 /* initialize with xtr(im,0); */
 121 int
 122 xtr(image_desc_t *im,time_t mytime){
 123     static double pixie;
 124     if (mytime==0){
 125         pixie = (double) im->xsize / (double)(im->end - im->start);
 126         return im->xorigin;
 127     }
 128     return (int)((double)im->xorigin
 129                  + pixie * ( mytime - im->start ) );
 130 }
 131
 132 /* translate data values into y coordinates */
 133 double
 134 ytr(image_desc_t *im, double value){
 135     static double pixie;
 136     double yval;
 137     if (isnan(value)){
 138       if(!im->logarithmic)
 139         pixie = (double) im->ysize / (im->maxval - im->minval);
 140       else
 141         pixie = (double) im->ysize / (log10(im->maxval) - log10(im->minval));
 142       yval = im->yorigin;
 143     } else if(!im->logarithmic) {
 144       yval = im->yorigin - pixie * (value - im->minval);
 145     } else {
 146       if (value < im->minval) {
 147         yval = im->yorigin;
 148       } else {
 149         yval = im->yorigin - pixie * (log10(value) - log10(im->minval));
 150       }
 151     }
 152     /* make sure we don't return anything too unreasonable. GD lib can
 153        get terribly slow when drawing lines outside its scope. This is
 154        especially problematic in connection with the rigid option */
 155     if (! im->rigid) {
 156       /* keep yval as-is */
 157     } else if (yval > im->yorigin) {
 158       yval = im->yorigin +0.00001;
 159     } else if (yval < im->yorigin - im->ysize){
 160       yval = im->yorigin - im->ysize - 0.00001;
 161     }
 162     return yval;
 163 }
 164
 165
 166
 167 /* conversion function for symbolic entry names */
 168
 169
 170 #define conv_if(VV,VVV) \
 171    if (strcmp(#VV, string) == 0) return VVV ;
 172
 173 enum gf_en gf_conv(char *string){
 174
 175     conv_if(PRINT,GF_PRINT)
 176     conv_if(GPRINT,GF_GPRINT)
 177     conv_if(COMMENT,GF_COMMENT)
 178     conv_if(HRULE,GF_HRULE)
 179     conv_if(VRULE,GF_VRULE)
 180     conv_if(LINE,GF_LINE)
 181     conv_if(AREA,GF_AREA)
 182     conv_if(STACK,GF_STACK)
 183     conv_if(TICK,GF_TICK)
 184     conv_if(DEF,GF_DEF)
 185     conv_if(CDEF,GF_CDEF)
 186     conv_if(VDEF,GF_VDEF)
 187 #ifdef WITH_PIECHART
 188     conv_if(PART,GF_PART)
 189 #endif
 190     conv_if(XPORT,GF_XPORT)
 191     conv_if(SHIFT,GF_SHIFT)
 192
 193     return (-1);
 194 }
 195
 196 enum gfx_if_en if_conv(char *string){
 197
 198     conv_if(PNG,IF_PNG)
 199     conv_if(SVG,IF_SVG)
 200     conv_if(EPS,IF_EPS)
 201     conv_if(PDF,IF_PDF)
 202
 203     return (-1);
 204 }
 205
 206 enum tmt_en tmt_conv(char *string){
 207
 208     conv_if(SECOND,TMT_SECOND)
 209     conv_if(MINUTE,TMT_MINUTE)
 210     conv_if(HOUR,TMT_HOUR)
 211     conv_if(DAY,TMT_DAY)
 212     conv_if(WEEK,TMT_WEEK)
 213     conv_if(MONTH,TMT_MONTH)
 214     conv_if(YEAR,TMT_YEAR)
 215     return (-1);
 216 }
 217
 218 enum grc_en grc_conv(char *string){
 219
 220     conv_if(BACK,GRC_BACK)
 221     conv_if(CANVAS,GRC_CANVAS)
 222     conv_if(SHADEA,GRC_SHADEA)
 223     conv_if(SHADEB,GRC_SHADEB)
 224     conv_if(GRID,GRC_GRID)
 225     conv_if(MGRID,GRC_MGRID)
 226     conv_if(FONT,GRC_FONT)
 227     conv_if(ARROW,GRC_ARROW)
 228     conv_if(AXIS,GRC_AXIS)
 229     conv_if(FRAME,GRC_FRAME)
 230
 231     return -1;
 232 }
 233
 234 enum text_prop_en text_prop_conv(char *string){
 235
 236     conv_if(DEFAULT,TEXT_PROP_DEFAULT)
 237     conv_if(TITLE,TEXT_PROP_TITLE)
 238     conv_if(AXIS,TEXT_PROP_AXIS)
 239     conv_if(UNIT,TEXT_PROP_UNIT)
 240     conv_if(LEGEND,TEXT_PROP_LEGEND)
 241     return -1;
 242 }
 243
 244
 245 #undef conv_if
 246
 247 int
 248 im_free(image_desc_t *im)
 249 {
 250     unsigned long       i,ii;
 251
 252     if (im == NULL) return 0;
 253     for(i=0;i<(unsigned)im->gdes_c;i++){
 254       if (im->gdes[i].data_first){
 255         /* careful here, because a single pointer can occur several times */
 256           free (im->gdes[i].data);
 257           if (im->gdes[i].ds_namv){
 258               for (ii=0;ii<im->gdes[i].ds_cnt;ii++)
 259                   free(im->gdes[i].ds_namv[ii]);
 260               free(im->gdes[i].ds_namv);
 261           }
 262       }
 263       free (im->gdes[i].p_data);
 264       free (im->gdes[i].rpnp);
 265     }
 266     free(im->gdes);
 267     gfx_destroy(im->canvas);
 268     return 0;
 269 }
 270
 271 /* find SI magnitude symbol for the given number*/
 272 void
 273 auto_scale(
 274            image_desc_t *im,   /* image description */
 275            double *value,
 276            char **symb_ptr,
 277            double *magfact
 278            )
 279 {
 280
 281     char *symbol[] = {"a", /* 10e-18 Atto */
 282                       "f", /* 10e-15 Femto */
 283                       "p", /* 10e-12 Pico */
 284                       "n", /* 10e-9  Nano */
 285                       "u", /* 10e-6  Micro */
 286                       "m", /* 10e-3  Milli */
 287                       " ", /* Base */
 288                       "k", /* 10e3   Kilo */
 289                       "M", /* 10e6   Mega */
 290                       "G", /* 10e9   Giga */
 291                       "T", /* 10e12  Tera */
 292                       "P", /* 10e15  Peta */
 293                       "E"};/* 10e18  Exa */
 294
 295     int symbcenter = 6;
 296     int sindex;
 297
 298     if (*value == 0.0 || isnan(*value) ) {
 299         sindex = 0;
 300         *magfact = 1.0;
 301     } else {
 302         sindex = floor(log(fabs(*value))/log((double)im->base));
 303         *magfact = pow((double)im->base, (double)sindex);
 304         (*value) /= (*magfact);
 305     }
 306     if ( sindex <= symbcenter && sindex >= -symbcenter) {
 307         (*symb_ptr) = symbol[sindex+symbcenter];
 308     }
 309     else {
 310         (*symb_ptr) = "?";
 311     }
 312 }
 313
 314
 315 /* find SI magnitude symbol for the numbers on the y-axis*/
 316 void
 317 si_unit(
 318     image_desc_t *im   /* image description */
 319 )
 320 {
 321
 322     char symbol[] = {'a', /* 10e-18 Atto */
 323                      'f', /* 10e-15 Femto */
 324                      'p', /* 10e-12 Pico */
 325                      'n', /* 10e-9  Nano */
 326                      'u', /* 10e-6  Micro */
 327                      'm', /* 10e-3  Milli */
 328                      ' ', /* Base */
 329                      'k', /* 10e3   Kilo */
 330                      'M', /* 10e6   Mega */
 331                      'G', /* 10e9   Giga */
 332                      'T', /* 10e12  Tera */
 333                      'P', /* 10e15  Peta */
 334                      'E'};/* 10e18  Exa */
 335
 336     int   symbcenter = 6;
 337     double digits,viewdigits=0;
 338
 339     digits = floor( log( max( fabs(im->minval),fabs(im->maxval)))/log((double)im->base));
 340
 341     if (im->unitsexponent != 9999) {
 342         /* unitsexponent = 9, 6, 3, 0, -3, -6, -9, etc */
 343         viewdigits = floor(im->unitsexponent / 3);
 344     } else {
 345         viewdigits = digits;
 346     }
 347
 348     im->magfact = pow((double)im->base , digits);
 349
 350 #ifdef DEBUG
 351     printf("digits %6.3f  im->magfact %6.3f\n",digits,im->magfact);
 352 #endif
 353
 354     im->viewfactor = im->magfact / pow((double)im->base , viewdigits);
 355
 356     if ( ((viewdigits+symbcenter) < sizeof(symbol)) &&
 357                     ((viewdigits+symbcenter) >= 0) )
 358         im->symbol = symbol[(int)viewdigits+symbcenter];
 359     else
 360         im->symbol = '?';
 361  }
 362
 363 /*  move min and max values around to become sensible */
 364
 365 void
 366 expand_range(image_desc_t *im)
 367 {
 368     double sensiblevalues[] ={1000.0,900.0,800.0,750.0,700.0,
 369                               600.0,500.0,400.0,300.0,250.0,
 370                               200.0,125.0,100.0,90.0,80.0,
 371                               75.0,70.0,60.0,50.0,40.0,30.0,
 372                               25.0,20.0,10.0,9.0,8.0,
 373                               7.0,6.0,5.0,4.0,3.5,3.0,
 374                               2.5,2.0,1.8,1.5,1.2,1.0,
 375                               0.8,0.7,0.6,0.5,0.4,0.3,0.2,0.1,0.0,-1};
 376
 377     double scaled_min,scaled_max;
 378     double adj;
 379     int i;
 380
 381
 382
 383 #ifdef DEBUG
 384     printf("Min: %6.2f Max: %6.2f MagFactor: %6.2f\n",
 385            im->minval,im->maxval,im->magfact);
 386 #endif
 387
 388     if (isnan(im->ygridstep)){
 389         if(im->extra_flags & ALTAUTOSCALE) {
 390             /* measure the amplitude of the function. Make sure that
 391                graph boundaries are slightly higher then max/min vals
 392                so we can see amplitude on the graph */
 393               double delt, fact;
 394
 395               delt = im->maxval - im->minval;
 396               adj = delt * 0.1;
 397               fact = 2.0 * pow(10.0,
 398                     floor(log10(max(fabs(im->minval), fabs(im->maxval))/im->magfact)) - 2);
 399               if (delt < fact) {
 400                 adj = (fact - delt) * 0.55;
 401 #ifdef DEBUG
 402               printf("Min: %6.2f Max: %6.2f delt: %6.2f fact: %6.2f adj: %6.2f\n", im->minval, im->maxval, delt, fact, adj);
 403 #endif
 404               }
 405               im->minval -= adj;
 406               im->maxval += adj;
 407         }
 408         else if(im->extra_flags & ALTAUTOSCALE_MAX) {
 409             /* measure the amplitude of the function. Make sure that
 410                graph boundaries are slightly higher than max vals
 411                so we can see amplitude on the graph */
 412               adj = (im->maxval - im->minval) * 0.1;
 413               im->maxval += adj;
 414         }
 415         else {
 416             scaled_min = im->minval / im->magfact;
 417             scaled_max = im->maxval / im->magfact;
 418
 419             for (i=1; sensiblevalues[i] > 0; i++){
 420                 if (sensiblevalues[i-1]>=scaled_min &&
 421                     sensiblevalues[i]<=scaled_min)
 422                     im->minval = sensiblevalues[i]*(im->magfact);
 423
 424                 if (-sensiblevalues[i-1]<=scaled_min &&
 425                 -sensiblevalues[i]>=scaled_min)
 426                     im->minval = -sensiblevalues[i-1]*(im->magfact);
 427
 428                 if (sensiblevalues[i-1] >= scaled_max &&
 429                     sensiblevalues[i] <= scaled_max)
 430                     im->maxval = sensiblevalues[i-1]*(im->magfact);
 431
 432                 if (-sensiblevalues[i-1]<=scaled_max &&
 433                     -sensiblevalues[i] >=scaled_max)
 434                     im->maxval = -sensiblevalues[i]*(im->magfact);
 435             }
 436         }
 437     } else {
 438         /* adjust min and max to the grid definition if there is one */
 439         im->minval = (double)im->ylabfact * im->ygridstep *
 440             floor(im->minval / ((double)im->ylabfact * im->ygridstep));
 441         im->maxval = (double)im->ylabfact * im->ygridstep *
 442             ceil(im->maxval /( (double)im->ylabfact * im->ygridstep));
 443     }
 444
 445 #ifdef DEBUG
 446     fprintf(stderr,"SCALED Min: %6.2f Max: %6.2f Factor: %6.2f\n",
 447            im->minval,im->maxval,im->magfact);
 448 #endif
 449 }
 450
 451 void
 452 apply_gridfit(image_desc_t *im)
 453 {
 454   if (isnan(im->minval) || isnan(im->maxval))
 455     return;
 456   ytr(im,DNAN);
 457   if (im->logarithmic) {
 458     double ya, yb, ypix, ypixfrac;
 459     double log10_range = log10(im->maxval) - log10(im->minval);
 460     ya = pow((double)10, floor(log10(im->minval)));
 461     while (ya < im->minval)
 462       ya *= 10;
 463     if (ya > im->maxval)
 464       return; /* don't have y=10^x gridline */
 465     yb = ya * 10;
 466     if (yb <= im->maxval) {
 467       /* we have at least 2 y=10^x gridlines.
 468          Make sure distance between them in pixels
 469          are an integer by expanding im->maxval */
 470       double y_pixel_delta = ytr(im, ya) - ytr(im, yb);
 471       double factor = y_pixel_delta / floor(y_pixel_delta);
 472       double new_log10_range = factor * log10_range;
 473       double new_ymax_log10 = log10(im->minval) + new_log10_range;
 474       im->maxval = pow(10, new_ymax_log10);
 475       ytr(im,DNAN); /* reset precalc */
 476       log10_range = log10(im->maxval) - log10(im->minval);
 477     }
 478     /* make sure first y=10^x gridline is located on
 479        integer pixel position by moving scale slightly
 480        downwards (sub-pixel movement) */
 481     ypix = ytr(im, ya) + im->ysize; /* add im->ysize so it always is positive */
 482     ypixfrac = ypix - floor(ypix);
 483     if (ypixfrac > 0 && ypixfrac < 1) {
 484       double yfrac = ypixfrac / im->ysize;
 485       im->minval = pow(10, log10(im->minval) - yfrac * log10_range);
 486       im->maxval = pow(10, log10(im->maxval) - yfrac * log10_range);
 487       ytr(im,DNAN); /* reset precalc */
 488     }
 489   } else {
 490     /* Make sure we have an integer pixel distance between
 491        each minor gridline */
 492     double ypos1 = ytr(im, im->minval);
 493     double ypos2 = ytr(im, im->minval + im->ygrid_scale.gridstep);
 494     double y_pixel_delta = ypos1 - ypos2;
 495     double factor = y_pixel_delta / floor(y_pixel_delta);
 496     double new_range = factor * (im->maxval - im->minval);
 497     double gridstep = im->ygrid_scale.gridstep;
 498     double minor_y, minor_y_px, minor_y_px_frac;
 499     im->maxval = im->minval + new_range;
 500     ytr(im,DNAN); /* reset precalc */
 501     /* make sure first minor gridline is on integer pixel y coord */
 502     minor_y = gridstep * floor(im->minval / gridstep);
 503     while (minor_y < im->minval)
 504       minor_y += gridstep;
 505     minor_y_px = ytr(im, minor_y) + im->ysize; /* ensure > 0 by adding ysize */
 506     minor_y_px_frac = minor_y_px - floor(minor_y_px);
 507     if (minor_y_px_frac > 0 && minor_y_px_frac < 1) {
 508       double yfrac = minor_y_px_frac / im->ysize;
 509       double range = im->maxval - im->minval;
 510       im->minval = im->minval - yfrac * range;
 511       im->maxval = im->maxval - yfrac * range;
 512       ytr(im,DNAN); /* reset precalc */
 513     }
 514     calc_horizontal_grid(im); /* recalc with changed im->maxval */
 515   }
 516 }
 517
 518 /* reduce data reimplementation by Alex */
 519
 520 void
 521 reduce_data(
 522     enum cf_en     cf,         /* which consolidation function ?*/
 523     unsigned long  cur_step,   /* step the data currently is in */
 524     time_t         *start,     /* start, end and step as requested ... */
 525     time_t         *end,       /* ... by the application will be   ... */
 526     unsigned long  *step,      /* ... adjusted to represent reality    */
 527     unsigned long  *ds_cnt,    /* number of data sources in file */
 528     rrd_value_t    **data)     /* two dimensional array containing the data */
 529 {
 530     int i,reduce_factor = ceil((double)(*step) / (double)cur_step);
 531     unsigned long col,dst_row,row_cnt,start_offset,end_offset,skiprows=0;
 532     rrd_value_t    *srcptr,*dstptr;
 533
 534     (*step) = cur_step*reduce_factor; /* set new step size for reduced data */
 535     dstptr = *data;
 536     srcptr = *data;
 537     row_cnt = ((*end)-(*start))/cur_step;
 538
 539 #ifdef DEBUG
 540 #define DEBUG_REDUCE
 541 #endif
 542 #ifdef DEBUG_REDUCE
 543 printf("Reducing %lu rows with factor %i time %lu to %lu, step %lu\n",
 544                         row_cnt,reduce_factor,*start,*end,cur_step);
 545 for (col=0;col<row_cnt;col++) {
 546     printf("time %10lu: ",*start+(col+1)*cur_step);
 547     for (i=0;i<*ds_cnt;i++)
 548         printf(" %8.2e",srcptr[*ds_cnt*col+i]);
 549     printf("\n");
 550 }
 551 #endif
 552
 553     /* We have to combine [reduce_factor] rows of the source
 554     ** into one row for the destination.  Doing this we also
 555     ** need to take care to combine the correct rows.  First
 556     ** alter the start and end time so that they are multiples
 557     ** of the new step time.  We cannot reduce the amount of
 558     ** time so we have to move the end towards the future and
 559     ** the start towards the past.
 560     */
 561     end_offset = (*end) % (*step);
 562     start_offset = (*start) % (*step);
 563
 564     /* If there is a start offset (which cannot be more than
 565     ** one destination row), skip the appropriate number of
 566     ** source rows and one destination row.  The appropriate
 567     ** number is what we do know (start_offset/cur_step) of
 568     ** the new interval (*step/cur_step aka reduce_factor).
 569     */
 570 #ifdef DEBUG_REDUCE
 571 printf("start_offset: %lu  end_offset: %lu\n",start_offset,end_offset);
 572 printf("row_cnt before:  %lu\n",row_cnt);
 573 #endif
 574     if (start_offset) {
 575         (*start) = (*start)-start_offset;
 576         skiprows=reduce_factor-start_offset/cur_step;
 577         srcptr+=skiprows* *ds_cnt;
 578         for (col=0;col<(*ds_cnt);col++) *dstptr++ = DNAN;
 579         row_cnt-=skiprows;
 580     }
 581 #ifdef DEBUG_REDUCE
 582 printf("row_cnt between: %lu\n",row_cnt);
 583 #endif
 584
 585     /* At the end we have some rows that are not going to be
 586     ** used, the amount is end_offset/cur_step
 587     */
 588     if (end_offset) {
 589         (*end) = (*end)-end_offset+(*step);
 590         skiprows = end_offset/cur_step;
 591         row_cnt-=skiprows;
 592     }
 593 #ifdef DEBUG_REDUCE
 594 printf("row_cnt after:   %lu\n",row_cnt);
 595 #endif
 596
 597 /* Sanity check: row_cnt should be multiple of reduce_factor */
 598 /* if this gets triggered, something is REALLY WRONG ... we die immediately */
 599
 600     if (row_cnt%reduce_factor) {
 601         printf("SANITY CHECK: %lu rows cannot be reduced by %i \n",
 602                                 row_cnt,reduce_factor);
 603         printf("BUG in reduce_data()\n");
 604         exit(1);
 605     }
 606
 607     /* Now combine reduce_factor intervals at a time
 608     ** into one interval for the destination.
 609     */
 610
 611     for (dst_row=0;(long int)row_cnt>=reduce_factor;dst_row++) {
 612         for (col=0;col<(*ds_cnt);col++) {
 613             rrd_value_t newval=DNAN;
 614             unsigned long validval=0;
 615
 616             for (i=0;i<reduce_factor;i++) {
 617                 if (isnan(srcptr[i*(*ds_cnt)+col])) {
 618                     continue;
 619                 }
 620                 validval++;
 621                 if (isnan(newval)) newval = srcptr[i*(*ds_cnt)+col];
 622                 else {
 623                     switch (cf) {
 624                         case CF_HWPREDICT:
 625                         case CF_DEVSEASONAL:
 626                         case CF_DEVPREDICT:
 627                         case CF_SEASONAL:
 628                         case CF_AVERAGE:
 629                             newval += srcptr[i*(*ds_cnt)+col];
 630                             break;
 631                         case CF_MINIMUM:
 632                             newval = min (newval,srcptr[i*(*ds_cnt)+col]);
 633                             break;
 634                         case CF_FAILURES:
 635                         /* an interval contains a failure if any subintervals contained a failure */
 636                         case CF_MAXIMUM:
 637                             newval = max (newval,srcptr[i*(*ds_cnt)+col]);
 638                             break;
 639                         case CF_LAST:
 640                             newval = srcptr[i*(*ds_cnt)+col];
 641                             break;
 642                     }
 643                 }
 644             }
 645             if (validval == 0){newval = DNAN;} else{
 646                 switch (cf) {
 647                     case CF_HWPREDICT:
 648             case CF_DEVSEASONAL:
 649                     case CF_DEVPREDICT:
 650                     case CF_SEASONAL:
 651                     case CF_AVERAGE:
 652                        newval /= validval;
 653                         break;
 654                     case CF_MINIMUM:
 655                     case CF_FAILURES:
 656                     case CF_MAXIMUM:
 657                     case CF_LAST:
 658                         break;
 659                 }
 660             }
 661             *dstptr++=newval;
 662         }
 663         srcptr+=(*ds_cnt)*reduce_factor;
 664         row_cnt-=reduce_factor;
 665     }
 666     /* If we had to alter the endtime, we didn't have enough
 667     ** source rows to fill the last row. Fill it with NaN.
 668     */
 669     if (end_offset) for (col=0;col<(*ds_cnt);col++) *dstptr++ = DNAN;
 670 #ifdef DEBUG_REDUCE
 671     row_cnt = ((*end)-(*start))/ *step;
 672     srcptr = *data;
 673     printf("Done reducing. Currently %lu rows, time %lu to %lu, step %lu\n",
 674                                 row_cnt,*start,*end,*step);
 675 for (col=0;col<row_cnt;col++) {
 676     printf("time %10lu: ",*start+(col+1)*(*step));
 677     for (i=0;i<*ds_cnt;i++)
 678         printf(" %8.2e",srcptr[*ds_cnt*col+i]);
 679     printf("\n");
 680 }
 681 #endif
 682 }
 683
 684
 685 /* get the data required for the graphs from the
 686    relevant rrds ... */
 687
 688 int
 689 data_fetch(image_desc_t *im )
 690 {
 691     int i,ii;
 692     int         skip;
 693
 694     /* pull the data from the rrd files ... */
 695     for (i=0;i< (int)im->gdes_c;i++){
 696         /* only GF_DEF elements fetch data */
 697         if (im->gdes[i].gf != GF_DEF)
 698             continue;
 699
 700         skip=0;
 701         /* do we have it already ?*/
 702         for (ii=0;ii<i;ii++) {
 703             if (im->gdes[ii].gf != GF_DEF)
 704                 continue;
 705             if ((strcmp(im->gdes[i].rrd, im->gdes[ii].rrd) == 0)
 706                         && (im->gdes[i].cf    == im->gdes[ii].cf)
 707                         && (im->gdes[i].cf_reduce == im->gdes[ii].cf_reduce)
 708                         && (im->gdes[i].start_orig == im->gdes[ii].start_orig)
 709                         && (im->gdes[i].end_orig   == im->gdes[ii].end_orig)
 710                         && (im->gdes[i].step_orig  == im->gdes[ii].step_orig)) {
 711                 /* OK, the data is already there.
 712                 ** Just copy the header portion
 713                 */
 714                 im->gdes[i].start = im->gdes[ii].start;
 715                 im->gdes[i].end = im->gdes[ii].end;
 716                 im->gdes[i].step = im->gdes[ii].step;
 717                 im->gdes[i].ds_cnt = im->gdes[ii].ds_cnt;
 718                 im->gdes[i].ds_namv = im->gdes[ii].ds_namv;
 719                 im->gdes[i].data = im->gdes[ii].data;
 720                 im->gdes[i].data_first = 0;
 721                 skip=1;
 722             }
 723             if (skip)
 724                 break;
 725         }
 726         if (! skip) {
 727             unsigned long  ft_step = im->gdes[i].step ;
 728
 729             if((rrd_fetch_fn(im->gdes[i].rrd,
 730                              im->gdes[i].cf,
 731                              &im->gdes[i].start,
 732                              &im->gdes[i].end,
 733                              &ft_step,
 734                              &im->gdes[i].ds_cnt,
 735                              &im->gdes[i].ds_namv,
 736                              &im->gdes[i].data)) == -1){
 737                 return -1;
 738             }
 739             im->gdes[i].data_first = 1;
 740             im->gdes[i].step = im->step;
 741
 742             if (ft_step < im->gdes[i].step) {
 743                 reduce_data(im->gdes[i].cf_reduce,
 744                             ft_step,
 745                             &im->gdes[i].start,
 746                             &im->gdes[i].end,
 747                             &im->gdes[i].step,
 748                             &im->gdes[i].ds_cnt,
 749                             &im->gdes[i].data);
 750             } else {
 751                 im->gdes[i].step = ft_step;
 752             }
 753         }
 754
 755         /* lets see if the required data source is really there */
 756         for(ii=0;ii<(int)im->gdes[i].ds_cnt;ii++){
 757             if(strcmp(im->gdes[i].ds_namv[ii],im->gdes[i].ds_nam) == 0){
 758                 im->gdes[i].ds=ii; }
 759         }
 760         if (im->gdes[i].ds== -1){
 761             rrd_set_error("No DS called '%s' in '%s'",
 762                           im->gdes[i].ds_nam,im->gdes[i].rrd);
 763             return -1;
 764         }
 765
 766     }
 767     return 0;
 768 }
 769
 770 /* evaluate the expressions in the CDEF functions */
 771
 772 /*************************************************************
 773  * CDEF stuff
 774  *************************************************************/
 775
 776 long
 777 find_var_wrapper(void *arg1, char *key)
 778 {
 779    return find_var((image_desc_t *) arg1, key);
 780 }
 781
 782 /* find gdes containing var*/
 783 long
 784 find_var(image_desc_t *im, char *key){
 785     long ii;
 786     for(ii=0;ii<im->gdes_c-1;ii++){
 787         if((im->gdes[ii].gf == GF_DEF
 788             || im->gdes[ii].gf == GF_VDEF
 789             || im->gdes[ii].gf == GF_CDEF)
 790            && (strcmp(im->gdes[ii].vname,key) == 0)){
 791             return ii;
 792         }
 793     }
 794     return -1;
 795 }
 796
 797 /* find the largest common denominator for all the numbers
 798    in the 0 terminated num array */
 799 long
 800 lcd(long *num){
 801     long rest;
 802     int i;
 803     for (i=0;num[i+1]!=0;i++){
 804         do {
 805             rest=num[i] % num[i+1];
 806             num[i]=num[i+1]; num[i+1]=rest;
 807         } while (rest!=0);
 808         num[i+1] = num[i];
 809     }
 810 /*    return i==0?num[i]:num[i-1]; */
 811       return num[i];
 812 }
 813
 814 /* run the rpn calculator on all the VDEF and CDEF arguments */
 815 int
 816 data_calc( image_desc_t *im){
 817
 818     int       gdi;
 819     int       dataidx;
 820     long      *steparray, rpi;
 821     int       stepcnt;
 822     time_t    now;
 823     rpnstack_t rpnstack;
 824
 825     rpnstack_init(&rpnstack);
 826
 827     for (gdi=0;gdi<im->gdes_c;gdi++){
 828         /* Look for GF_VDEF and GF_CDEF in the same loop,
 829          * so CDEFs can use VDEFs and vice versa
 830          */
 831         switch (im->gdes[gdi].gf) {
 832             case GF_XPORT:
 833               break;
 834             case GF_SHIFT: {
 835                 graph_desc_t    *vdp = &im->gdes[im->gdes[gdi].vidx];
 836
 837                 /* remove current shift */
 838                 vdp->start -= vdp->shift;
 839                 vdp->end -= vdp->shift;
 840
 841                 /* vdef */
 842                 if (im->gdes[gdi].shidx >= 0)
 843                         vdp->shift = im->gdes[im->gdes[gdi].shidx].vf.val;
 844                 /* constant */
 845                 else
 846                         vdp->shift = im->gdes[gdi].shval;
 847
 848                 /* normalize shift to multiple of consolidated step */
 849                 vdp->shift = (vdp->shift / (long)vdp->step) * (long)vdp->step;
 850
 851                 /* apply shift */
 852                 vdp->start += vdp->shift;
 853                 vdp->end += vdp->shift;
 854                 break;
 855             }
 856             case GF_VDEF:
 857                 /* A VDEF has no DS.  This also signals other parts
 858                  * of rrdtool that this is a VDEF value, not a CDEF.
 859                  */
 860                 im->gdes[gdi].ds_cnt = 0;
 861                 if (vdef_calc(im,gdi)) {
 862                     rrd_set_error("Error processing VDEF '%s'"
 863                         ,im->gdes[gdi].vname
 864                         );
 865                     rpnstack_free(&rpnstack);
 866                     return -1;
 867                 }
 868                 break;
 869             case GF_CDEF:
 870                 im->gdes[gdi].ds_cnt = 1;
 871                 im->gdes[gdi].ds = 0;
 872                 im->gdes[gdi].data_first = 1;
 873                 im->gdes[gdi].start = 0;
 874                 im->gdes[gdi].end = 0;
 875                 steparray=NULL;
 876                 stepcnt = 0;
 877                 dataidx=-1;
 878
 879                 /* Find the variables in the expression.
 880                  * - VDEF variables are substituted by their values
 881                  *   and the opcode is changed into OP_NUMBER.
 882                  * - CDEF variables are analized for their step size,
 883                  *   the lowest common denominator of all the step
 884                  *   sizes of the data sources involved is calculated
 885                  *   and the resulting number is the step size for the
 886                  *   resulting data source.
 887                  */
 888                 for(rpi=0;im->gdes[gdi].rpnp[rpi].op != OP_END;rpi++){
 889                     if(im->gdes[gdi].rpnp[rpi].op == OP_VARIABLE  ||
 890                         im->gdes[gdi].rpnp[rpi].op == OP_PREV_OTHER){
 891                         long ptr = im->gdes[gdi].rpnp[rpi].ptr;
 892                         if (im->gdes[ptr].ds_cnt == 0) { /* this is a VDEF data source */
 893 #if 0
 894                             printf("DEBUG: inside CDEF '%s' processing VDEF '%s'\n",
 895                                im->gdes[gdi].vname,
 896                                im->gdes[ptr].vname);
 897                             printf("DEBUG: value from vdef is %f\n",im->gdes[ptr].vf.val);
 898 #endif
 899                             im->gdes[gdi].rpnp[rpi].val = im->gdes[ptr].vf.val;
 900                             im->gdes[gdi].rpnp[rpi].op  = OP_NUMBER;
 901                         } else { /* normal variables and PREF(variables) */
 902
 903                             /* add one entry to the array that keeps track of the step sizes of the
 904                              * data sources going into the CDEF. */
 905                             if ((steparray =
 906                                  rrd_realloc(steparray,
 907                                                          (++stepcnt+1)*sizeof(*steparray)))==NULL){
 908                                  rrd_set_error("realloc steparray");
 909                                  rpnstack_free(&rpnstack);
 910                                  return -1;
 911                             };
 912
 913                             steparray[stepcnt-1] = im->gdes[ptr].step;
 914
 915                             /* adjust start and end of cdef (gdi) so
 916                              * that it runs from the latest start point
 917                              * to the earliest endpoint of any of the
 918                              * rras involved (ptr)
 919                              */
 920
 921                             if(im->gdes[gdi].start < im->gdes[ptr].start)
 922                                 im->gdes[gdi].start = im->gdes[ptr].start;
 923
 924                             if(im->gdes[gdi].end == 0 ||
 925                                         im->gdes[gdi].end > im->gdes[ptr].end)
 926                                 im->gdes[gdi].end = im->gdes[ptr].end;
 927
 928                             /* store pointer to the first element of
 929                              * the rra providing data for variable,
 930                              * further save step size and data source
 931                              * count of this rra
 932                              */
 933                             im->gdes[gdi].rpnp[rpi].data   = im->gdes[ptr].data + im->gdes[ptr].ds;
 934                             im->gdes[gdi].rpnp[rpi].step   = im->gdes[ptr].step;
 935                             im->gdes[gdi].rpnp[rpi].ds_cnt = im->gdes[ptr].ds_cnt;
 936
 937                             /* backoff the *.data ptr; this is done so
 938                              * rpncalc() function doesn't have to treat
 939                              * the first case differently
 940                              */
 941                         } /* if ds_cnt != 0 */
 942                     } /* if OP_VARIABLE */
 943                 } /* loop through all rpi */
 944
 945                 /* move the data pointers to the correct period */
 946                 for(rpi=0;im->gdes[gdi].rpnp[rpi].op != OP_END;rpi++){
 947                     if(im->gdes[gdi].rpnp[rpi].op == OP_VARIABLE ||
 948                         im->gdes[gdi].rpnp[rpi].op == OP_PREV_OTHER){
 949                         long ptr  = im->gdes[gdi].rpnp[rpi].ptr;
 950                         long diff = im->gdes[gdi].start - im->gdes[ptr].start;
 951
 952                         if(diff > 0)
 953                             im->gdes[gdi].rpnp[rpi].data += (diff / im->gdes[ptr].step) * im->gdes[ptr].ds_cnt;
 954                      }
 955                 }
 956
 957                 if(steparray == NULL){
 958                     rrd_set_error("rpn expressions without DEF"
 959                                 " or CDEF variables are not supported");
 960                     rpnstack_free(&rpnstack);
 961                     return -1;
 962                 }
 963                 steparray[stepcnt]=0;
 964                 /* Now find the resulting step.  All steps in all
 965                  * used RRAs have to be visited
 966                  */
 967                 im->gdes[gdi].step = lcd(steparray);
 968                 free(steparray);
 969                 if((im->gdes[gdi].data = malloc((
 970                                 (im->gdes[gdi].end-im->gdes[gdi].start)
 971                                     / im->gdes[gdi].step)
 972                                     * sizeof(double)))==NULL){
 973                     rrd_set_error("malloc im->gdes[gdi].data");
 974                     rpnstack_free(&rpnstack);
 975                     return -1;
 976                 }
 977
 978                 /* Step through the new cdef results array and
 979                  * calculate the values
 980                  */
 981                 for (now = im->gdes[gdi].start + im->gdes[gdi].step;
 982                                 now<=im->gdes[gdi].end;
 983                                 now += im->gdes[gdi].step)
 984                 {
 985                     rpnp_t  *rpnp = im -> gdes[gdi].rpnp;
 986
 987                     /* 3rd arg of rpn_calc is for OP_VARIABLE lookups;
 988                      * in this case we are advancing by timesteps;
 989                      * we use the fact that time_t is a synonym for long
 990                      */
 991                     if (rpn_calc(rpnp,&rpnstack,(long) now,
 992                                 im->gdes[gdi].data,++dataidx) == -1) {
 993                         /* rpn_calc sets the error string */
 994                         rpnstack_free(&rpnstack);
 995                         return -1;
 996                     }
 997                 } /* enumerate over time steps within a CDEF */
 998                 break;
 999             default:
1000                 continue;
1001         }
1002     } /* enumerate over CDEFs */
1003     rpnstack_free(&rpnstack);
1004     return 0;
1005 }
1006
1007 /* massage data so, that we get one value for each x coordinate in the graph */
1008 int
1009 data_proc( image_desc_t *im ){
1010     long i,ii;
1011     double pixstep = (double)(im->end-im->start)
1012         /(double)im->xsize; /* how much time
1013                                passes in one pixel */
1014     double paintval;
1015     double minval=DNAN,maxval=DNAN;
1016
1017     unsigned long gr_time;
1018
1019     /* memory for the processed data */
1020     for(i=0;i<im->gdes_c;i++) {
1021         if((im->gdes[i].gf==GF_LINE) ||
1022                 (im->gdes[i].gf==GF_AREA) ||
1023                 (im->gdes[i].gf==GF_TICK)) {
1024             if((im->gdes[i].p_data = malloc((im->xsize +1)
1025                                         * sizeof(rrd_value_t)))==NULL){
1026                 rrd_set_error("malloc data_proc");
1027                 return -1;
1028             }
1029         }
1030     }
1031
1032     for (i=0;i<im->xsize;i++) { /* for each pixel */
1033         long vidx;
1034         gr_time = im->start+pixstep*i; /* time of the current step */
1035         paintval=0.0;
1036
1037         for (ii=0;ii<im->gdes_c;ii++) {
1038             double value;
1039             switch (im->gdes[ii].gf) {
1040                 case GF_LINE:
1041                 case GF_AREA:
1042                 case GF_TICK:
1043                     if (!im->gdes[ii].stack)
1044                         paintval = 0.0;
1045                     value = im->gdes[ii].yrule;
1046                     if (isnan(value) || (im->gdes[ii].gf == GF_TICK)) {
1047                         /* The time of the data doesn't necessarily match
1048                         ** the time of the graph. Beware.
1049                         */
1050                         vidx = im->gdes[ii].vidx;
1051                         if (im->gdes[vidx].gf == GF_VDEF) {
1052                             value = im->gdes[vidx].vf.val;
1053                         } else if (((long int)gr_time >= (long int)im->gdes[vidx].start) &&
1054                                    ((long int)gr_time <= (long int)im->gdes[vidx].end) ) {
1055                             value = im->gdes[vidx].data[
1056                                 (unsigned long) floor(
1057                                     (double)(gr_time - im->gdes[vidx].start)
1058                                                 / im->gdes[vidx].step)
1059                                 * im->gdes[vidx].ds_cnt
1060                                 + im->gdes[vidx].ds
1061                             ];
1062                         } else {
1063                             value = DNAN;
1064                         }
1065                     };
1066
1067                     if (! isnan(value)) {
1068                         paintval += value;
1069                         im->gdes[ii].p_data[i] = paintval;
1070                         /* GF_TICK: the data values are not
1071                         ** relevant for min and max
1072                         */
1073                         if (finite(paintval) && im->gdes[ii].gf != GF_TICK ) {
1074                             if (isnan(minval) || paintval <  minval)
1075                                 minval = paintval;
1076                             if (isnan(maxval) || paintval >  maxval)
1077                                 maxval = paintval;
1078                         }
1079                     } else {
1080                         im->gdes[ii].p_data[i] = DNAN;
1081                     }
1082                     break;
1083                 case GF_STACK:
1084                     rrd_set_error("STACK should already be turned into LINE or AREA here");
1085                     return -1;
1086                     break;
1087                 default:
1088                     break;
1089             }
1090         }
1091     }
1092
1093     /* if min or max have not been asigned a value this is because
1094        there was no data in the graph ... this is not good ...
1095        lets set these to dummy values then ... */
1096
1097     if (isnan(minval)) minval = 0.0;
1098     if (isnan(maxval)) maxval = 1.0;
1099
1100     /* adjust min and max values */
1101     if (isnan(im->minval)
1102         /* don't adjust low-end with log scale */
1103         || ((!im->logarithmic && !im->rigid) && im->minval > minval)
1104         )
1105         im->minval = minval;
1106     if (isnan(im->maxval)
1107         || (!im->rigid && im->maxval < maxval)
1108         ) {
1109         if (im->logarithmic)
1110             im->maxval = maxval * 1.1;
1111         else
1112             im->maxval = maxval;
1113     }
1114     /* make sure min is smaller than max */
1115     if (im->minval > im->maxval) {
1116             im->minval = 0.99 * im->maxval;
1117     }
1118
1119     /* make sure min and max are not equal */
1120     if (im->minval == im->maxval) {
1121         im->maxval *= 1.01;
1122         if (! im->logarithmic) {
1123             im->minval *= 0.99;
1124         }
1125         /* make sure min and max are not both zero */
1126         if (im->maxval == 0.0) {
1127             im->maxval = 1.0;
1128         }
1129     }
1130     return 0;
1131 }
1132
1133
1134
1135 /* identify the point where the first gridline, label ... gets placed */
1136
1137 time_t
1138 find_first_time(
1139     time_t   start, /* what is the initial time */
1140     enum tmt_en baseint,  /* what is the basic interval */
1141     long     basestep /* how many if these do we jump a time */
1142     )
1143 {
1144     struct tm tm;
1145     localtime_r(&start, &tm);
1146     switch(baseint){
1147     case TMT_SECOND:
1148         tm.tm_sec -= tm.tm_sec % basestep; break;
1149     case TMT_MINUTE:
1150         tm.tm_sec=0;
1151         tm.tm_min -= tm.tm_min % basestep;
1152         break;
1153     case TMT_HOUR:
1154         tm.tm_sec=0;
1155         tm.tm_min = 0;
1156         tm.tm_hour -= tm.tm_hour % basestep; break;
1157     case TMT_DAY:
1158         /* we do NOT look at the basestep for this ... */
1159         tm.tm_sec=0;
1160         tm.tm_min = 0;
1161         tm.tm_hour = 0; break;
1162     case TMT_WEEK:
1163         /* we do NOT look at the basestep for this ... */
1164         tm.tm_sec=0;
1165         tm.tm_min = 0;
1166         tm.tm_hour = 0;
1167         tm.tm_mday -= tm.tm_wday -1;    /* -1 because we want the monday */
1168         if (tm.tm_wday==0) tm.tm_mday -= 7; /* we want the *previous* monday */
1169         break;
1170     case TMT_MONTH:
1171         tm.tm_sec=0;
1172         tm.tm_min = 0;
1173         tm.tm_hour = 0;
1174         tm.tm_mday = 1;
1175         tm.tm_mon -= tm.tm_mon % basestep; break;
1176
1177     case TMT_YEAR:
1178         tm.tm_sec=0;
1179         tm.tm_min = 0;
1180         tm.tm_hour = 0;
1181         tm.tm_mday = 1;
1182         tm.tm_mon = 0;
1183         tm.tm_year -= (tm.tm_year+1900) % basestep;
1184
1185     }
1186     return mktime(&tm);
1187 }
1188 /* identify the point where the next gridline, label ... gets placed */
1189 time_t
1190 find_next_time(
1191     time_t   current, /* what is the initial time */
1192     enum tmt_en baseint,  /* what is the basic interval */
1193     long     basestep /* how many if these do we jump a time */
1194     )
1195 {
1196     struct tm tm;
1197     time_t madetime;
1198     localtime_r(&current, &tm);
1199     do {
1200         switch(baseint){
1201         case TMT_SECOND:
1202             tm.tm_sec += basestep; break;
1203         case TMT_MINUTE:
1204             tm.tm_min += basestep; break;
1205         case TMT_HOUR:
1206             tm.tm_hour += basestep; break;
1207         case TMT_DAY:
1208             tm.tm_mday += basestep; break;
1209         case TMT_WEEK:
1210             tm.tm_mday += 7*basestep; break;
1211         case TMT_MONTH:
1212             tm.tm_mon += basestep; break;
1213         case TMT_YEAR:
1214             tm.tm_year += basestep;
1215         }
1216         madetime = mktime(&tm);
1217     } while (madetime == -1); /* this is necessary to skip impssible times
1218                                  like the daylight saving time skips */
1219     return madetime;
1220
1221 }
1222
1223
1224 /* calculate values required for PRINT and GPRINT functions */
1225
1226 int
1227 print_calc(image_desc_t *im, char ***prdata)
1228 {
1229     long i,ii,validsteps;
1230     double printval;
1231     time_t printtime;
1232     int graphelement = 0;
1233     long vidx;
1234     int max_ii;
1235     double magfact = -1;
1236     char *si_symb = "";
1237     char *percent_s;
1238     int prlines = 1;
1239     if (im->imginfo) prlines++;
1240     for(i=0;i<im->gdes_c;i++){
1241         switch(im->gdes[i].gf){
1242         case GF_PRINT:
1243             prlines++;
1244             if(((*prdata) = rrd_realloc((*prdata),prlines*sizeof(char *)))==NULL){
1245                 rrd_set_error("realloc prdata");
1246                 return 0;
1247             }
1248         case GF_GPRINT:
1249             /* PRINT and GPRINT can now print VDEF generated values.
1250              * There's no need to do any calculations on them as these
1251              * calculations were already made.
1252              */
1253             vidx = im->gdes[i].vidx;
1254             if (im->gdes[vidx].gf==GF_VDEF) { /* simply use vals */
1255                 printval = im->gdes[vidx].vf.val;
1256                 printtime = im->gdes[vidx].vf.when;
1257             } else { /* need to calculate max,min,avg etcetera */
1258                 max_ii =((im->gdes[vidx].end
1259                         - im->gdes[vidx].start)
1260                         / im->gdes[vidx].step
1261                         * im->gdes[vidx].ds_cnt);
1262                 printval = DNAN;
1263                 validsteps = 0;
1264                 for(    ii=im->gdes[vidx].ds;
1265                         ii < max_ii;
1266                         ii+=im->gdes[vidx].ds_cnt){
1267                     if (! finite(im->gdes[vidx].data[ii]))
1268                         continue;
1269                     if (isnan(printval)){
1270                         printval = im->gdes[vidx].data[ii];
1271                         validsteps++;
1272                         continue;
1273                     }
1274
1275                     switch (im->gdes[i].cf){
1276                         case CF_HWPREDICT:
1277                         case CF_DEVPREDICT:
1278                         case CF_DEVSEASONAL:
1279                         case CF_SEASONAL:
1280                         case CF_AVERAGE:
1281                             validsteps++;
1282                             printval += im->gdes[vidx].data[ii];
1283                             break;
1284                         case CF_MINIMUM:
1285                             printval = min( printval, im->gdes[vidx].data[ii]);
1286                             break;
1287                         case CF_FAILURES:
1288                         case CF_MAXIMUM:
1289                             printval = max( printval, im->gdes[vidx].data[ii]);
1290                             break;
1291                         case CF_LAST:
1292                             printval = im->gdes[vidx].data[ii];
1293                     }
1294                 }
1295                 if (im->gdes[i].cf==CF_AVERAGE || im->gdes[i].cf > CF_LAST) {
1296                     if (validsteps > 1) {
1297                         printval = (printval / validsteps);
1298                     }
1299                 }
1300             } /* prepare printval */
1301
1302             if (!strcmp(im->gdes[i].format,"%c")) { /* VDEF time print */
1303                 char ctime_buf[128]; /* PS: for ctime_r, must be >= 26 chars */
1304                 int iii=0;
1305                 ctime_r(&printtime,ctime_buf);
1306                 while(isprint(ctime_buf[iii])){iii++;}
1307                 ctime_buf[iii]='\0';
1308                 if (im->gdes[i].gf == GF_PRINT){
1309                     (*prdata)[prlines-2] = malloc((FMT_LEG_LEN+2)*sizeof(char));
1310                     sprintf((*prdata)[prlines-2],"%s (%lu)",ctime_buf,printtime);
1311                     (*prdata)[prlines-1] = NULL;
1312                 } else {
1313                     sprintf(im->gdes[i].legend,"%s (%lu)",ctime_buf,printtime);
1314                     graphelement = 1;
1315                 }
1316             } else {
1317             if ((percent_s = strstr(im->gdes[i].format,"%S")) != NULL) {
1318                 /* Magfact is set to -1 upon entry to print_calc.  If it
1319                  * is still less than 0, then we need to run auto_scale.
1320                  * Otherwise, put the value into the correct units.  If
1321                  * the value is 0, then do not set the symbol or magnification
1322                  * so next the calculation will be performed again. */
1323                 if (magfact < 0.0) {
1324                     auto_scale(im,&printval,&si_symb,&magfact);
1325                     if (printval == 0.0)
1326                         magfact = -1.0;
1327                 } else {
1328                     printval /= magfact;
1329                 }
1330                 *(++percent_s) = 's';
1331             } else if (strstr(im->gdes[i].format,"%s") != NULL) {
1332                 auto_scale(im,&printval,&si_symb,&magfact);
1333             }
1334
1335             if (im->gdes[i].gf == GF_PRINT){
1336                 (*prdata)[prlines-2] = malloc((FMT_LEG_LEN+2)*sizeof(char));
1337                 (*prdata)[prlines-1] = NULL;
1338                 if (bad_format(im->gdes[i].format)) {
1339                         rrd_set_error("bad format for PRINT in '%s'", im->gdes[i].format);
1340                         return -1;
1341                 }
1342 #ifdef HAVE_SNPRINTF
1343                 snprintf((*prdata)[prlines-2],FMT_LEG_LEN,im->gdes[i].format,printval,si_symb);
1344 #else
1345                 sprintf((*prdata)[prlines-2],im->gdes[i].format,printval,si_symb);
1346 #endif
1347             } else {
1348                 /* GF_GPRINT */
1349
1350                 if (bad_format(im->gdes[i].format)) {
1351                         rrd_set_error("bad format for GPRINT in '%s'", im->gdes[i].format);
1352                         return -1;
1353                 }
1354 #ifdef HAVE_SNPRINTF
1355                 snprintf(im->gdes[i].legend,FMT_LEG_LEN-2,im->gdes[i].format,printval,si_symb);
1356 #else
1357                 sprintf(im->gdes[i].legend,im->gdes[i].format,printval,si_symb);
1358 #endif
1359                 graphelement = 1;
1360             }
1361             }
1362             break;
1363         case GF_LINE:
1364         case GF_AREA:
1365         case GF_TICK:
1366         case GF_HRULE:
1367         case GF_VRULE:
1368             graphelement = 1;
1369             break;
1370         case GF_COMMENT:
1371         case GF_DEF:
1372         case GF_CDEF:
1373         case GF_VDEF:
1374 #ifdef WITH_PIECHART
1375         case GF_PART:
1376 #endif
1377         case GF_SHIFT:
1378         case GF_XPORT:
1379             break;
1380         case GF_STACK:
1381             rrd_set_error("STACK should already be turned into LINE or AREA here");
1382             return -1;
1383             break;
1384         }
1385     }
1386     return graphelement;
1387 }
1388
1389
1390 /* place legends with color spots */
1391 int
1392 leg_place(image_desc_t *im)
1393 {
1394     /* graph labels */
1395     int   interleg = im->text_prop[TEXT_PROP_LEGEND].size*2.0;
1396     int   border = im->text_prop[TEXT_PROP_LEGEND].size*2.0;
1397     int   fill=0, fill_last;
1398     int   leg_c = 0;
1399     int   leg_x = border, leg_y = im->yimg;
1400     int   leg_cc;
1401     int   glue = 0;
1402     int   i,ii, mark = 0;
1403     char  prt_fctn; /*special printfunctions */
1404     int  *legspace;
1405
1406   if( !(im->extra_flags & NOLEGEND) & !(im->extra_flags & ONLY_GRAPH) ) {
1407     if ((legspace = malloc(im->gdes_c*sizeof(int)))==NULL){
1408        rrd_set_error("malloc for legspace");
1409        return -1;
1410     }
1411
1412     for(i=0;i<im->gdes_c;i++){
1413         fill_last = fill;
1414
1415         /* hid legends for rules which are not displayed */
1416
1417         if(!(im->extra_flags & FORCE_RULES_LEGEND)) {
1418                 if (im->gdes[i].gf == GF_HRULE &&
1419                     (im->gdes[i].yrule < im->minval || im->gdes[i].yrule > im->maxval))
1420                     im->gdes[i].legend[0] = '\0';
1421
1422                 if (im->gdes[i].gf == GF_VRULE &&
1423                     (im->gdes[i].xrule < im->start || im->gdes[i].xrule > im->end))
1424                     im->gdes[i].legend[0] = '\0';
1425         }
1426
1427         leg_cc = strlen(im->gdes[i].legend);
1428
1429         /* is there a controle code ant the end of the legend string ? */
1430         /* and it is not a tab \\t */
1431         if (leg_cc >= 2 && im->gdes[i].legend[leg_cc-2] == '\\' && im->gdes[i].legend[leg_cc-1] != 't') {
1432             prt_fctn = im->gdes[i].legend[leg_cc-1];
1433             leg_cc -= 2;
1434             im->gdes[i].legend[leg_cc] = '\0';
1435         } else {
1436             prt_fctn = '\0';
1437         }
1438         /* remove exess space */
1439         while (prt_fctn=='g' &&
1440                leg_cc > 0 &&
1441                im->gdes[i].legend[leg_cc-1]==' '){
1442            leg_cc--;
1443            im->gdes[i].legend[leg_cc]='\0';
1444         }
1445         if (leg_cc != 0 ){
1446            legspace[i]=(prt_fctn=='g' ? 0 : interleg);
1447
1448            if (fill > 0){
1449                /* no interleg space if string ends in \g */
1450                fill += legspace[i];
1451             }
1452            fill += gfx_get_text_width(im->canvas, fill+border,
1453                                       im->text_prop[TEXT_PROP_LEGEND].font,
1454                                       im->text_prop[TEXT_PROP_LEGEND].size,
1455                                       im->tabwidth,
1456                                       im->gdes[i].legend, 0);
1457             leg_c++;
1458         } else {
1459            legspace[i]=0;
1460         }
1461         /* who said there was a special tag ... ?*/
1462         if (prt_fctn=='g') {
1463            prt_fctn = '\0';
1464         }
1465         if (prt_fctn == '\0') {
1466             if (i == im->gdes_c -1 ) prt_fctn ='l';
1467
1468             /* is it time to place the legends ? */
1469             if (fill > im->ximg - 2*border){
1470                 if (leg_c > 1) {
1471                     /* go back one */
1472                     i--;
1473                     fill = fill_last;
1474                     leg_c--;
1475                     prt_fctn = 'j';
1476                 } else {
1477                     prt_fctn = 'l';
1478                 }
1479
1480             }
1481         }
1482
1483
1484         if (prt_fctn != '\0'){
1485             leg_x = border;
1486             if (leg_c >= 2 && prt_fctn == 'j') {
1487                 glue = (im->ximg - fill - 2* border) / (leg_c-1);
1488             } else {
1489                 glue = 0;
1490             }
1491             if (prt_fctn =='c') leg_x =  (im->ximg - fill) / 2.0;
1492             if (prt_fctn =='r') leg_x =  im->ximg - fill - border;
1493
1494             for(ii=mark;ii<=i;ii++){
1495                 if(im->gdes[ii].legend[0]=='\0')
1496                     continue; /* skip empty legends */
1497                 im->gdes[ii].leg_x = leg_x;
1498                 im->gdes[ii].leg_y = leg_y;
1499                 leg_x +=
1500                  gfx_get_text_width(im->canvas, leg_x,
1501                                       im->text_prop[TEXT_PROP_LEGEND].font,
1502                                       im->text_prop[TEXT_PROP_LEGEND].size,
1503                                       im->tabwidth,
1504                                       im->gdes[ii].legend, 0)
1505                    + legspace[ii]
1506                    + glue;
1507             }
1508             leg_y += im->text_prop[TEXT_PROP_LEGEND].size*1.8;
1509             if (prt_fctn == 's') leg_y -=  im->text_prop[TEXT_PROP_LEGEND].size;
1510             fill = 0;
1511             leg_c = 0;
1512             mark = ii;
1513         }
1514     }
1515     im->yimg = leg_y;
1516     free(legspace);
1517   }
1518   return 0;
1519 }
1520
1521 /* create a grid on the graph. it determines what to do
1522    from the values of xsize, start and end */
1523
1524 /* the xaxis labels are determined from the number of seconds per pixel
1525    in the requested graph */
1526
1527
1528
1529 int
1530 calc_horizontal_grid(image_desc_t   *im)
1531 {
1532     double   range;
1533     double   scaledrange;
1534     int      pixel,i;
1535     int      gridind=0;
1536     int      decimals, fractionals;
1537
1538     im->ygrid_scale.labfact=2;
1539     range =  im->maxval - im->minval;
1540     scaledrange = range / im->magfact;
1541
1542         /* does the scale of this graph make it impossible to put lines
1543            on it? If so, give up. */
1544         if (isnan(scaledrange)) {
1545                 return 0;
1546         }
1547
1548     /* find grid spaceing */
1549     pixel=1;
1550     if(isnan(im->ygridstep)){
1551         if(im->extra_flags & ALTYGRID) {
1552             /* find the value with max number of digits. Get number of digits */
1553             decimals = ceil(log10(max(fabs(im->maxval), fabs(im->minval))*im->viewfactor/im->magfact));
1554             if(decimals <= 0) /* everything is small. make place for zero */
1555                 decimals = 1;
1556
1557             im->ygrid_scale.gridstep = pow((double)10, floor(log10(range*im->viewfactor/im->magfact)))/im->viewfactor*im->magfact;
1558
1559             if(im->ygrid_scale.gridstep == 0) /* range is one -> 0.1 is reasonable scale */
1560                 im->ygrid_scale.gridstep = 0.1;
1561             /* should have at least 5 lines but no more then 15 */
1562             if(range/im->ygrid_scale.gridstep < 5)
1563                 im->ygrid_scale.gridstep /= 10;
1564             if(range/im->ygrid_scale.gridstep > 15)
1565                 im->ygrid_scale.gridstep *= 10;
1566             if(range/im->ygrid_scale.gridstep > 5) {
1567                 im->ygrid_scale.labfact = 1;
1568                 if(range/im->ygrid_scale.gridstep > 8)
1569                     im->ygrid_scale.labfact = 2;
1570             }
1571             else {
1572                 im->ygrid_scale.gridstep /= 5;
1573                 im->ygrid_scale.labfact = 5;
1574             }
1575             fractionals = floor(log10(im->ygrid_scale.gridstep*(double)im->ygrid_scale.labfact*im->viewfactor/im->magfact));
1576             if(fractionals < 0) { /* small amplitude. */
1577                 int len = decimals - fractionals + 1;
1578                 if (im->unitslength < len+2) im->unitslength = len+2;
1579                 sprintf(im->ygrid_scale.labfmt, "%%%d.%df%s", len, -fractionals,(im->symbol != ' ' ? " %c" : ""));
1580             } else {
1581                 int len = decimals + 1;
1582                 if (im->unitslength < len+2) im->unitslength = len+2;
1583                 sprintf(im->ygrid_scale.labfmt, "%%%d.0f%s", len, ( im->symbol != ' ' ? " %c" : "" ));
1584             }
1585         }
1586         else {
1587             for(i=0;ylab[i].grid > 0;i++){
1588                 pixel = im->ysize / (scaledrange / ylab[i].grid);
1589                 gridind = i;
1590                 if (pixel > 7)
1591                     break;
1592             }
1593
1594             for(i=0; i<4;i++) {
1595                if (pixel * ylab[gridind].lfac[i] >=  2.5 * im->text_prop[TEXT_PROP_AXIS].size) {
1596                   im->ygrid_scale.labfact =  ylab[gridind].lfac[i];
1597                   break;
1598                }
1599             }
1600
1601             im->ygrid_scale.gridstep = ylab[gridind].grid * im->magfact;
1602         }
1603     } else {
1604         im->ygrid_scale.gridstep = im->ygridstep;
1605         im->ygrid_scale.labfact = im->ylabfact;
1606     }
1607     return 1;
1608 }
1609
1610 int draw_horizontal_grid(image_desc_t *im)
1611 {
1612     int      i;
1613     double   scaledstep;
1614     char     graph_label[100];
1615     double X0=im->xorigin;
1616     double X1=im->xorigin+im->xsize;
1617
1618     int sgrid = (int)( im->minval / im->ygrid_scale.gridstep - 1);
1619     int egrid = (int)( im->maxval / im->ygrid_scale.gridstep + 1);
1620     double MaxY;
1621     scaledstep = im->ygrid_scale.gridstep/(double)im->magfact*(double)im->viewfactor;
1622     MaxY = scaledstep*(double)egrid;
1623     for (i = sgrid; i <= egrid; i++){
1624        double Y0=ytr(im,im->ygrid_scale.gridstep*i);
1625        if ( Y0 >= im->yorigin-im->ysize
1626                  && Y0 <= im->yorigin){
1627             if(i % im->ygrid_scale.labfact == 0){
1628                 if (im->symbol == ' ') {
1629                     if(im->extra_flags & ALTYGRID) {
1630                         sprintf(graph_label,im->ygrid_scale.labfmt,scaledstep*(double)i);
1631                     } else {
1632                         if(MaxY < 10) {
1633                            sprintf(graph_label,"%4.1f",scaledstep*(double)i);
1634                         } else {
1635                            sprintf(graph_label,"%4.0f",scaledstep*(double)i);
1636                         }
1637                     }
1638                 }else {
1639                     char sisym = ( i == 0  ? ' ' : im->symbol);
1640                     if(im->extra_flags & ALTYGRID) {
1641                         sprintf(graph_label,im->ygrid_scale.labfmt,scaledstep*(double)i,sisym);
1642                     } else {
1643                         if(MaxY < 10){
1644                           sprintf(graph_label,"%4.1f %c",scaledstep*(double)i, sisym);
1645                         } else {
1646                           sprintf(graph_label,"%4.0f %c",scaledstep*(double)i, sisym);
1647                         }
1648                     }
1649                 }
1650
1651                gfx_new_text ( im->canvas,
1652                               X0-im->text_prop[TEXT_PROP_AXIS].size, Y0,
1653                               im->graph_col[GRC_FONT],
1654                               im->text_prop[TEXT_PROP_AXIS].font,
1655                               im->text_prop[TEXT_PROP_AXIS].size,
1656                               im->tabwidth, 0.0, GFX_H_RIGHT, GFX_V_CENTER,
1657                               graph_label );
1658                gfx_new_dashed_line ( im->canvas,
1659                               X0-2,Y0,
1660                               X1+2,Y0,
1661                               MGRIDWIDTH, im->graph_col[GRC_MGRID],
1662                               im->grid_dash_on, im->grid_dash_off);
1663
1664             } else if (!(im->extra_flags & NOMINOR)) {
1665                gfx_new_dashed_line ( im->canvas,
1666                               X0-1,Y0,
1667                               X1+1,Y0,
1668                               GRIDWIDTH, im->graph_col[GRC_GRID],
1669                               im->grid_dash_on, im->grid_dash_off);
1670
1671             }
1672         }
1673     }
1674     return 1;
1675 }
1676
1677 /* logaritmic horizontal grid */
1678 int
1679 horizontal_log_grid(image_desc_t   *im)
1680 {
1681     double   pixpex;
1682     int      ii,i;
1683     int      minoridx=0, majoridx=0;
1684     char     graph_label[100];
1685     double   X0,X1,Y0;
1686     double   value, pixperstep, minstep;
1687
1688     /* find grid spaceing */
1689     pixpex= (double)im->ysize / (log10(im->maxval) - log10(im->minval));
1690
1691         if (isnan(pixpex)) {
1692                 return 0;
1693         }
1694
1695     for(i=0;yloglab[i][0] > 0;i++){
1696         minstep = log10(yloglab[i][0]);
1697         for(ii=1;yloglab[i][ii+1] > 0;ii++){
1698             if(yloglab[i][ii+2]==0){
1699                 minstep = log10(yloglab[i][ii+1])-log10(yloglab[i][ii]);
1700                 break;
1701             }
1702         }
1703         pixperstep = pixpex * minstep;
1704         if(pixperstep > 5){minoridx = i;}
1705        if(pixperstep > 2 *  im->text_prop[TEXT_PROP_LEGEND].size){majoridx = i;}
1706     }
1707
1708    X0=im->xorigin;
1709    X1=im->xorigin+im->xsize;
1710     /* paint minor grid */
1711     for (value = pow((double)10, log10(im->minval)
1712                           - fmod(log10(im->minval),log10(yloglab[minoridx][0])));
1713          value  <= im->maxval;
1714          value *= yloglab[minoridx][0]){
1715         if (value < im->minval) continue;
1716         i=0;
1717         while(yloglab[minoridx][++i] > 0){
1718            Y0 = ytr(im,value * yloglab[minoridx][i]);
1719            if (Y0 <= im->yorigin - im->ysize) break;
1720            gfx_new_dashed_line ( im->canvas,
1721                           X0-1,Y0,
1722                           X1+1,Y0,
1723                           GRIDWIDTH, im->graph_col[GRC_GRID],
1724                           im->grid_dash_on, im->grid_dash_off);
1725         }
1726     }
1727
1728     /* paint major grid and labels*/
1729     for (value = pow((double)10, log10(im->minval)
1730                           - fmod(log10(im->minval),log10(yloglab[majoridx][0])));
1731          value <= im->maxval;
1732          value *= yloglab[majoridx][0]){
1733         if (value < im->minval) continue;
1734         i=0;
1735         while(yloglab[majoridx][++i] > 0){
1736            Y0 = ytr(im,value * yloglab[majoridx][i]);
1737            if (Y0 <= im->yorigin - im->ysize) break;
1738            gfx_new_dashed_line ( im->canvas,
1739                           X0-2,Y0,
1740                           X1+2,Y0,
1741                           MGRIDWIDTH, im->graph_col[GRC_MGRID],
1742                           im->grid_dash_on, im->grid_dash_off);
1743
1744            sprintf(graph_label,"%3.0e",value * yloglab[majoridx][i]);
1745            gfx_new_text ( im->canvas,
1746                           X0-im->text_prop[TEXT_PROP_AXIS].size, Y0,
1747                           im->graph_col[GRC_FONT],
1748                           im->text_prop[TEXT_PROP_AXIS].font,
1749                           im->text_prop[TEXT_PROP_AXIS].size,
1750                           im->tabwidth,0.0, GFX_H_RIGHT, GFX_V_CENTER,
1751                           graph_label );
1752         }
1753     }
1754         return 1;
1755 }
1756
1757
1758 void
1759 vertical_grid(
1760     image_desc_t   *im )
1761 {
1762     int xlab_sel;               /* which sort of label and grid ? */
1763     time_t ti, tilab, timajor;
1764     long factor;
1765     char graph_label[100];
1766     double X0,Y0,Y1; /* points for filled graph and more*/
1767     struct tm tm;
1768
1769     /* the type of time grid is determined by finding
1770        the number of seconds per pixel in the graph */
1771
1772
1773     if(im->xlab_user.minsec == -1){
1774         factor=(im->end - im->start)/im->xsize;
1775         xlab_sel=0;
1776         while ( xlab[xlab_sel+1].minsec != -1
1777                 && xlab[xlab_sel+1].minsec <= factor) { xlab_sel++; }   /* pick the last one */
1778         while ( xlab[xlab_sel-1].minsec == xlab[xlab_sel].minsec
1779                 && xlab[xlab_sel].length > (im->end - im->start)) { xlab_sel--; }       /* go back to the smallest size */
1780         im->xlab_user.gridtm = xlab[xlab_sel].gridtm;
1781         im->xlab_user.gridst = xlab[xlab_sel].gridst;
1782         im->xlab_user.mgridtm = xlab[xlab_sel].mgridtm;
1783         im->xlab_user.mgridst = xlab[xlab_sel].mgridst;
1784         im->xlab_user.labtm = xlab[xlab_sel].labtm;
1785         im->xlab_user.labst = xlab[xlab_sel].labst;
1786         im->xlab_user.precis = xlab[xlab_sel].precis;
1787         im->xlab_user.stst = xlab[xlab_sel].stst;
1788     }
1789
1790     /* y coords are the same for every line ... */
1791     Y0 = im->yorigin;
1792     Y1 = im->yorigin-im->ysize;
1793
1794
1795     /* paint the minor grid */
1796     if (!(im->extra_flags & NOMINOR))
1797     {
1798         for(ti = find_first_time(im->start,
1799                                 im->xlab_user.gridtm,
1800                                 im->xlab_user.gridst),
1801             timajor = find_first_time(im->start,
1802                                 im->xlab_user.mgridtm,
1803                                 im->xlab_user.mgridst);
1804             ti < im->end;
1805             ti = find_next_time(ti,im->xlab_user.gridtm,im->xlab_user.gridst)
1806             ){
1807             /* are we inside the graph ? */
1808             if (ti < im->start || ti > im->end) continue;
1809             while (timajor < ti) {
1810                 timajor = find_next_time(timajor,
1811                         im->xlab_user.mgridtm, im->xlab_user.mgridst);
1812             }
1813             if (ti == timajor) continue; /* skip as falls on major grid line */
1814            X0 = xtr(im,ti);
1815            gfx_new_dashed_line(im->canvas,X0,Y0+1, X0,Y1-1,GRIDWIDTH,
1816                im->graph_col[GRC_GRID],
1817                im->grid_dash_on, im->grid_dash_off);
1818
1819         }
1820     }
1821
1822     /* paint the major grid */
1823     for(ti = find_first_time(im->start,
1824                             im->xlab_user.mgridtm,
1825                             im->xlab_user.mgridst);
1826         ti < im->end;
1827         ti = find_next_time(ti,im->xlab_user.mgridtm,im->xlab_user.mgridst)
1828         ){
1829         /* are we inside the graph ? */
1830         if (ti < im->start || ti > im->end) continue;
1831        X0 = xtr(im,ti);
1832        gfx_new_dashed_line(im->canvas,X0,Y0+3, X0,Y1-2,MGRIDWIDTH,
1833            im->graph_col[GRC_MGRID],
1834            im->grid_dash_on, im->grid_dash_off);
1835
1836     }
1837     /* paint the labels below the graph */
1838     for(ti = find_first_time(im->start - im->xlab_user.precis/2,
1839                             im->xlab_user.labtm,
1840                             im->xlab_user.labst);
1841         ti <= im->end - im->xlab_user.precis/2;
1842         ti = find_next_time(ti,im->xlab_user.labtm,im->xlab_user.labst)
1843         ){
1844         tilab= ti + im->xlab_user.precis/2; /* correct time for the label */
1845         /* are we inside the graph ? */
1846         if (tilab < im->start || tilab > im->end) continue;
1847
1848 #if HAVE_STRFTIME
1849         localtime_r(&tilab, &tm);
1850         strftime(graph_label,99,im->xlab_user.stst, &tm);
1851 #else
1852 # error "your libc has no strftime I guess we'll abort the exercise here."
1853 #endif
1854        gfx_new_text ( im->canvas,
1855                       xtr(im,tilab), Y0+im->text_prop[TEXT_PROP_AXIS].size*1.4+5,
1856                       im->graph_col[GRC_FONT],
1857                       im->text_prop[TEXT_PROP_AXIS].font,
1858                       im->text_prop[TEXT_PROP_AXIS].size,
1859                       im->tabwidth, 0.0, GFX_H_CENTER, GFX_V_BOTTOM,
1860                       graph_label );
1861
1862     }
1863
1864 }
1865
1866
1867 void
1868 axis_paint(
1869    image_desc_t   *im
1870            )
1871 {
1872     /* draw x and y axis */
1873     /* gfx_new_line ( im->canvas, im->xorigin+im->xsize,im->yorigin,
1874                       im->xorigin+im->xsize,im->yorigin-im->ysize,
1875                       GRIDWIDTH, im->graph_col[GRC_AXIS]);
1876
1877        gfx_new_line ( im->canvas, im->xorigin,im->yorigin-im->ysize,
1878                          im->xorigin+im->xsize,im->yorigin-im->ysize,
1879                          GRIDWIDTH, im->graph_col[GRC_AXIS]); */
1880
1881        gfx_new_line ( im->canvas, im->xorigin-4,im->yorigin,
1882                          im->xorigin+im->xsize+4,im->yorigin,
1883                          MGRIDWIDTH, im->graph_col[GRC_AXIS]);
1884
1885        gfx_new_line ( im->canvas, im->xorigin,im->yorigin+4,
1886                          im->xorigin,im->yorigin-im->ysize-4,
1887                          MGRIDWIDTH, im->graph_col[GRC_AXIS]);
1888
1889
1890     /* arrow for X and Y axis direction */
1891     gfx_new_area ( im->canvas,
1892                    im->xorigin+im->xsize+2,  im->yorigin-2,
1893                    im->xorigin+im->xsize+2,  im->yorigin+3,
1894                    im->xorigin+im->xsize+7,  im->yorigin+0.5, /* LINEOFFSET */
1895                    im->graph_col[GRC_ARROW]);
1896
1897     gfx_new_area ( im->canvas,
1898                    im->xorigin-2,  im->yorigin-im->ysize-2,
1899                    im->xorigin+3,  im->yorigin-im->ysize-2,
1900                    im->xorigin+0.5,    im->yorigin-im->ysize-7, /* LINEOFFSET */
1901                    im->graph_col[GRC_ARROW]);
1902
1903 }
1904
1905 void
1906 grid_paint(image_desc_t   *im)
1907 {
1908     long i;
1909     int res=0;
1910     double X0,Y0; /* points for filled graph and more*/
1911     gfx_node_t *node;
1912
1913     /* draw 3d border */
1914     node = gfx_new_area (im->canvas, 0,im->yimg,
1915                                  2,im->yimg-2,
1916                                  2,2,im->graph_col[GRC_SHADEA]);
1917     gfx_add_point( node , im->ximg - 2, 2 );
1918     gfx_add_point( node , im->ximg, 0 );
1919     gfx_add_point( node , 0,0 );
1920 /*    gfx_add_point( node , 0,im->yimg ); */
1921
1922     node =  gfx_new_area (im->canvas, 2,im->yimg-2,
1923                                   im->ximg-2,im->yimg-2,
1924                                   im->ximg - 2, 2,
1925                                  im->graph_col[GRC_SHADEB]);
1926     gfx_add_point( node ,   im->ximg,0);
1927     gfx_add_point( node ,   im->ximg,im->yimg);
1928     gfx_add_point( node ,   0,im->yimg);
1929 /*    gfx_add_point( node , 0,im->yimg ); */
1930
1931
1932     if (im->draw_x_grid == 1 )
1933       vertical_grid(im);
1934
1935     if (im->draw_y_grid == 1){
1936         if(im->logarithmic){
1937                 res = horizontal_log_grid(im);
1938         } else {
1939                 res = draw_horizontal_grid(im);
1940         }
1941
1942         /* dont draw horizontal grid if there is no min and max val */
1943         if (! res ) {
1944           char *nodata = "No Data found";
1945            gfx_new_text(im->canvas,im->ximg/2, (2*im->yorigin-im->ysize) / 2,
1946                         im->graph_col[GRC_FONT],
1947                         im->text_prop[TEXT_PROP_AXIS].font,
1948                         im->text_prop[TEXT_PROP_AXIS].size,
1949                         im->tabwidth, 0.0, GFX_H_CENTER, GFX_V_CENTER,
1950                         nodata );
1951         }
1952     }
1953
1954     /* yaxis unit description */
1955     gfx_new_text( im->canvas,
1956                   10, (im->yorigin - im->ysize/2),
1957                   im->graph_col[GRC_FONT],
1958                   im->text_prop[TEXT_PROP_UNIT].font,
1959                   im->text_prop[TEXT_PROP_UNIT].size, im->tabwidth,
1960                   RRDGRAPH_YLEGEND_ANGLE,
1961                   GFX_H_LEFT, GFX_V_CENTER,
1962                   im->ylegend);
1963
1964     /* graph title */
1965     gfx_new_text( im->canvas,
1966                   im->ximg/2, im->text_prop[TEXT_PROP_TITLE].size*1.3+4,
1967                   im->graph_col[GRC_FONT],
1968                   im->text_prop[TEXT_PROP_TITLE].font,
1969                   im->text_prop[TEXT_PROP_TITLE].size, im->tabwidth, 0.0,
1970                   GFX_H_CENTER, GFX_V_CENTER,
1971                   im->title);
1972     /* rrdtool 'logo' */
1973     gfx_new_text( im->canvas,
1974                   im->ximg-7, 7,
1975                   ( im->graph_col[GRC_FONT] & 0xffffff00 ) | 0x00000044,
1976                   im->text_prop[TEXT_PROP_AXIS].font,
1977                   5.5, im->tabwidth, 270,
1978                   GFX_H_RIGHT, GFX_V_TOP,
1979                   "RRDTOOL / TOBI OETIKER");
1980
1981     /* graph labels */
1982     if( !(im->extra_flags & NOLEGEND) & !(im->extra_flags & ONLY_GRAPH) ) {
1983             for(i=0;i<im->gdes_c;i++){
1984                     if(im->gdes[i].legend[0] =='\0')
1985                             continue;
1986
1987                     /* im->gdes[i].leg_y is the bottom of the legend */
1988                     X0 = im->gdes[i].leg_x;
1989                     Y0 = im->gdes[i].leg_y;
1990                     gfx_new_text ( im->canvas, X0, Y0,
1991                                    im->graph_col[GRC_FONT],
1992                                    im->text_prop[TEXT_PROP_LEGEND].font,
1993                                    im->text_prop[TEXT_PROP_LEGEND].size,
1994                                    im->tabwidth,0.0, GFX_H_LEFT, GFX_V_BOTTOM,
1995                                    im->gdes[i].legend );
1996                     /* The legend for GRAPH items starts with "M " to have
1997                        enough space for the box */
1998                     if (           im->gdes[i].gf != GF_PRINT &&
1999                                    im->gdes[i].gf != GF_GPRINT &&
2000                                    im->gdes[i].gf != GF_COMMENT) {
2001                             int boxH, boxV;
2002
2003                             boxH = gfx_get_text_width(im->canvas, 0,
2004                                                       im->text_prop[TEXT_PROP_LEGEND].font,
2005                                                       im->text_prop[TEXT_PROP_LEGEND].size,
2006                                                       im->tabwidth,"o", 0) * 1.2;
2007                             boxV = boxH*1.1;
2008
2009                             /* make sure transparent colors show up the same way as in the graph */
2010                              node = gfx_new_area(im->canvas,
2011                                                 X0,Y0-boxV,
2012                                                 X0,Y0,
2013                                                 X0+boxH,Y0,
2014                                                 im->graph_col[GRC_BACK]);
2015                             gfx_add_point ( node, X0+boxH, Y0-boxV );
2016
2017                             node = gfx_new_area(im->canvas,
2018                                                 X0,Y0-boxV,
2019                                                 X0,Y0,
2020                                                 X0+boxH,Y0,
2021                                                 im->gdes[i].col);
2022                             gfx_add_point ( node, X0+boxH, Y0-boxV );
2023                             node = gfx_new_line(im->canvas,
2024                                                 X0,Y0-boxV,
2025                                                 X0,Y0,
2026                                                 1.0,im->graph_col[GRC_FRAME]);
2027                             gfx_add_point(node,X0+boxH,Y0);
2028                             gfx_add_point(node,X0+boxH,Y0-boxV);
2029                             gfx_close_path(node);
2030                     }
2031             }
2032     }
2033 }
2034
2035
2036 /*****************************************************
2037  * lazy check make sure we rely need to create this graph
2038  *****************************************************/
2039
2040 int lazy_check(image_desc_t *im){
2041     FILE *fd = NULL;
2042         int size = 1;
2043     struct stat  imgstat;
2044
2045     if (im->lazy == 0) return 0; /* no lazy option */
2046     if (stat(im->graphfile,&imgstat) != 0)
2047       return 0; /* can't stat */
2048     /* one pixel in the existing graph is more then what we would
2049        change here ... */
2050     if (time(NULL) - imgstat.st_mtime >
2051         (im->end - im->start) / im->xsize)
2052       return 0;
2053     if ((fd = fopen(im->graphfile,"rb")) == NULL)
2054       return 0; /* the file does not exist */
2055     switch (im->canvas->imgformat) {
2056     case IF_PNG:
2057            size = PngSize(fd,&(im->ximg),&(im->yimg));
2058            break;
2059     default:
2060            size = 1;
2061     }
2062     fclose(fd);
2063     return size;
2064 }
2065
2066 #ifdef WITH_PIECHART
2067 void
2068 pie_part(image_desc_t *im, gfx_color_t color,
2069             double PieCenterX, double PieCenterY, double Radius,
2070             double startangle, double endangle)
2071 {
2072     gfx_node_t *node;
2073     double angle;
2074     double step=M_PI/50; /* Number of iterations for the circle;
2075                          ** 10 is definitely too low, more than
2076                          ** 50 seems to be overkill
2077                          */
2078
2079     /* Strange but true: we have to work clockwise or else
2080     ** anti aliasing nor transparency don't work.
2081     **
2082     ** This test is here to make sure we do it right, also
2083     ** this makes the for...next loop more easy to implement.
2084     ** The return will occur if the user enters a negative number
2085     ** (which shouldn't be done according to the specs) or if the
2086     ** programmers do something wrong (which, as we all know, never
2087     ** happens anyway :)
2088     */
2089     if (endangle<startangle) return;
2090
2091     /* Hidden feature: Radius decreases each full circle */
2092     angle=startangle;
2093     while (angle>=2*M_PI) {
2094         angle  -= 2*M_PI;
2095         Radius *= 0.8;
2096     }
2097
2098     node=gfx_new_area(im->canvas,
2099                 PieCenterX+sin(startangle)*Radius,
2100                 PieCenterY-cos(startangle)*Radius,
2101                 PieCenterX,
2102                 PieCenterY,
2103                 PieCenterX+sin(endangle)*Radius,
2104                 PieCenterY-cos(endangle)*Radius,
2105                 color);
2106     for (angle=endangle;angle-startangle>=step;angle-=step) {
2107         gfx_add_point(node,
2108                 PieCenterX+sin(angle)*Radius,
2109                 PieCenterY-cos(angle)*Radius );
2110     }
2111 }
2112
2113 #endif
2114
2115 int
2116 graph_size_location(image_desc_t *im, int elements
2117
2118 #ifdef WITH_PIECHART
2119 , int piechart
2120 #endif
2121
2122  )
2123 {
2124     /* The actual size of the image to draw is determined from
2125     ** several sources.  The size given on the command line is
2126     ** the graph area but we need more as we have to draw labels
2127     ** and other things outside the graph area
2128     */
2129
2130     /* +-+-------------------------------------------+
2131     ** |l|.................title.....................|
2132     ** |e+--+-------------------------------+--------+
2133     ** |b| b|                               |        |
2134     ** |a| a|                               |  pie   |
2135     ** |l| l|          main graph area      | chart  |
2136     ** |.| .|                               |  area  |
2137     ** |t| y|                               |        |
2138     ** |r+--+-------------------------------+--------+
2139     ** |e|  | x-axis labels                 |        |
2140     ** |v+--+-------------------------------+--------+
2141     ** | |..............legends......................|
2142     ** +-+-------------------------------------------+
2143     */
2144     int Xvertical=0,
2145                         Ytitle   =0,
2146         Xylabel  =0,
2147         Xmain    =0,    Ymain    =0,
2148 #ifdef WITH_PIECHART
2149         Xpie     =0,    Ypie     =0,
2150 #endif
2151                         Yxlabel  =0,
2152 #if 0
2153         Xlegend  =0,    Ylegend  =0,
2154 #endif
2155         Xspacing =15,  Yspacing =15;
2156
2157     if (im->extra_flags & ONLY_GRAPH) {
2158         im->xorigin =0;
2159         im->ximg = im->xsize;
2160         im->yimg = im->ysize;
2161         im->yorigin = im->ysize;
2162         ytr(im,DNAN);
2163         return 0;
2164     }
2165
2166     if (im->ylegend[0] != '\0' ) {
2167            Xvertical = im->text_prop[TEXT_PROP_UNIT].size *2;
2168     }
2169
2170
2171     if (im->title[0] != '\0') {
2172         /* The title is placed "inbetween" two text lines so it
2173         ** automatically has some vertical spacing.  The horizontal
2174         ** spacing is added here, on each side.
2175         */
2176         /* don't care for the with of the title
2177                 Xtitle = gfx_get_text_width(im->canvas, 0,
2178                 im->text_prop[TEXT_PROP_TITLE].font,
2179                 im->text_prop[TEXT_PROP_TITLE].size,
2180                 im->tabwidth,
2181                 im->title, 0) + 2*Xspacing; */
2182         Ytitle = im->text_prop[TEXT_PROP_TITLE].size*2.6+10;
2183     }
2184
2185     if (elements) {
2186         Xmain=im->xsize;
2187         Ymain=im->ysize;
2188         if (im->draw_x_grid) {
2189             Yxlabel=im->text_prop[TEXT_PROP_AXIS].size *2.5;
2190         }
2191         if (im->draw_y_grid) {
2192             Xylabel=gfx_get_text_width(im->canvas, 0,
2193                         im->text_prop[TEXT_PROP_AXIS].font,
2194                         im->text_prop[TEXT_PROP_AXIS].size,
2195                         im->tabwidth,
2196                         "0", 0) * im->unitslength;
2197         }
2198     }
2199
2200 #ifdef WITH_PIECHART
2201     if (piechart) {
2202         im->piesize=im->xsize<im->ysize?im->xsize:im->ysize;
2203         Xpie=im->piesize;
2204         Ypie=im->piesize;
2205     }
2206 #endif
2207
2208     /* Now calculate the total size.  Insert some spacing where
2209        desired.  im->xorigin and im->yorigin need to correspond
2210        with the lower left corner of the main graph area or, if
2211        this one is not set, the imaginary box surrounding the
2212        pie chart area. */
2213
2214     /* The legend width cannot yet be determined, as a result we
2215     ** have problems adjusting the image to it.  For now, we just
2216     ** forget about it at all; the legend will have to fit in the
2217     ** size already allocated.
2218     */
2219     im->ximg = Xylabel + Xmain + 2 * Xspacing;
2220
2221 #ifdef WITH_PIECHART
2222     im->ximg  += Xpie;
2223 #endif
2224
2225     if (Xmain) im->ximg += Xspacing;
2226 #ifdef WITH_PIECHART
2227     if (Xpie) im->ximg += Xspacing;
2228 #endif
2229
2230     im->xorigin = Xspacing + Xylabel;
2231
2232     /* the length of the title should not influence with width of the graph
2233        if (Xtitle > im->ximg) im->ximg = Xtitle; */
2234
2235     if (Xvertical) { /* unit description */
2236         im->ximg += Xvertical;
2237         im->xorigin += Xvertical;
2238     }
2239     xtr(im,0);
2240
2241     /* The vertical size is interesting... we need to compare
2242     ** the sum of {Ytitle, Ymain, Yxlabel, Ylegend} with Yvertical
2243     ** however we need to know {Ytitle+Ymain+Yxlabel} in order to
2244     ** start even thinking about Ylegend.
2245     **
2246     ** Do it in three portions: First calculate the inner part,
2247     ** then do the legend, then adjust the total height of the img.
2248     */
2249
2250     /* reserve space for main and/or pie */
2251
2252     im->yimg = Ymain + Yxlabel;
2253
2254 #ifdef WITH_PIECHART
2255     if (im->yimg < Ypie) im->yimg = Ypie;
2256 #endif
2257
2258     im->yorigin = im->yimg - Yxlabel;
2259
2260     /* reserve space for the title *or* some padding above the graph */
2261     if (Ytitle) {
2262         im->yimg += Ytitle;
2263         im->yorigin += Ytitle;
2264     } else {
2265         im->yimg += 1.5*Yspacing;
2266         im->yorigin += 1.5*Yspacing;
2267     }
2268     /* reserve space for padding below the graph */
2269     im->yimg += Yspacing;
2270
2271     /* Determine where to place the legends onto the image.
2272     ** Adjust im->yimg to match the space requirements.
2273     */
2274     if(leg_place(im)==-1)
2275         return -1;
2276
2277
2278 #if 0
2279     if (Xlegend > im->ximg) {
2280         im->ximg = Xlegend;
2281         /* reposition Pie */
2282     }
2283 #endif
2284
2285 #ifdef WITH_PIECHART
2286     /* The pie is placed in the upper right hand corner,
2287     ** just below the title (if any) and with sufficient
2288     ** padding.
2289     */
2290     if (elements) {
2291         im->pie_x = im->ximg - Xspacing - Xpie/2;
2292         im->pie_y = im->yorigin-Ymain+Ypie/2;
2293     } else {
2294         im->pie_x = im->ximg/2;
2295         im->pie_y = im->yorigin-Ypie/2;
2296     }
2297 #endif
2298
2299     ytr(im,DNAN);
2300     return 0;
2301 }
2302
2303 /* from http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm */
2304 /* yes we are loosing precision by doing tos with floats instead of doubles
2305    but it seems more stable this way. */
2306
2307 static int AlmostEqual2sComplement (float A, float B, int maxUlps)
2308 {
2309
2310     int aInt = *(int*)&A;
2311     int bInt = *(int*)&B;
2312     int intDiff;
2313     /* Make sure maxUlps is non-negative and small enough that the
2314        default NAN won't compare as equal to anything.  */
2315
2316     /* assert(maxUlps > 0 && maxUlps < 4 * 1024 * 1024); */
2317
2318     /* Make aInt lexicographically ordered as a twos-complement int */
2319
2320     if (aInt < 0)
2321         aInt = 0x80000000l - aInt;
2322
2323     /* Make bInt lexicographically ordered as a twos-complement int */
2324
2325     if (bInt < 0)
2326         bInt = 0x80000000l - bInt;
2327
2328     intDiff = abs(aInt - bInt);
2329
2330     if (intDiff <= maxUlps)
2331         return 1;
2332
2333     return 0;
2334 }
2335
2336 /* draw that picture thing ... */
2337 int
2338 graph_paint(image_desc_t *im, char ***calcpr)
2339 {
2340   int i,ii;
2341   int lazy =     lazy_check(im);
2342 #ifdef WITH_PIECHART
2343   int piechart = 0;
2344   double PieStart=0.0;
2345 #endif
2346   FILE  *fo;
2347   gfx_node_t *node;
2348
2349   double areazero = 0.0;
2350   graph_desc_t *lastgdes = NULL;
2351
2352   /* if we are lazy and there is nothing to PRINT ... quit now */
2353   if (lazy && im->prt_c==0) return 0;
2354
2355   /* pull the data from the rrd files ... */
2356
2357   if(data_fetch(im)==-1)
2358     return -1;
2359
2360   /* evaluate VDEF and CDEF operations ... */
2361   if(data_calc(im)==-1)
2362     return -1;
2363
2364 #ifdef WITH_PIECHART
2365   /* check if we need to draw a piechart */
2366   for(i=0;i<im->gdes_c;i++){
2367     if (im->gdes[i].gf == GF_PART) {
2368       piechart=1;
2369       break;
2370     }
2371   }
2372 #endif
2373
2374   /* calculate and PRINT and GPRINT definitions. We have to do it at
2375    * this point because it will affect the length of the legends
2376    * if there are no graph elements we stop here ...
2377    * if we are lazy, try to quit ...
2378    */
2379   i=print_calc(im,calcpr);
2380   if(i<0) return -1;
2381   if(((i==0)
2382 #ifdef WITH_PIECHART
2383 &&(piechart==0)
2384 #endif
2385 ) || lazy) return 0;
2386
2387 #ifdef WITH_PIECHART
2388   /* If there's only the pie chart to draw, signal this */
2389   if (i==0) piechart=2;
2390 #endif
2391
2392   /* get actual drawing data and find min and max values*/
2393   if(data_proc(im)==-1)
2394     return -1;
2395
2396   if(!im->logarithmic){si_unit(im);}        /* identify si magnitude Kilo, Mega Giga ? */
2397
2398   if(!im->rigid && ! im->logarithmic)
2399     expand_range(im);   /* make sure the upper and lower limit are
2400                            sensible values */
2401
2402   if (!calc_horizontal_grid(im))
2403     return -1;
2404
2405   if (im->gridfit)
2406     apply_gridfit(im);
2407
2408
2409 /**************************************************************
2410  *** Calculating sizes and locations became a bit confusing ***
2411  *** so I moved this into a separate function.              ***
2412  **************************************************************/
2413   if(graph_size_location(im,i
2414 #ifdef WITH_PIECHART
2415 ,piechart
2416 #endif
2417 )==-1)
2418     return -1;
2419
2420   /* the actual graph is created by going through the individual
2421      graph elements and then drawing them */
2422
2423   node=gfx_new_area ( im->canvas,
2424                       0, 0,
2425                       0, im->yimg,
2426                       im->ximg, im->yimg,
2427                       im->graph_col[GRC_BACK]);
2428
2429   gfx_add_point(node,im->ximg, 0);
2430
2431 #ifdef WITH_PIECHART
2432   if (piechart != 2) {
2433 #endif
2434     node=gfx_new_area ( im->canvas,
2435                       im->xorigin,             im->yorigin,
2436                       im->xorigin + im->xsize, im->yorigin,
2437                       im->xorigin + im->xsize, im->yorigin-im->ysize,
2438                       im->graph_col[GRC_CANVAS]);
2439
2440     gfx_add_point(node,im->xorigin, im->yorigin - im->ysize);
2441
2442     if (im->minval > 0.0)
2443       areazero = im->minval;
2444     if (im->maxval < 0.0)
2445       areazero = im->maxval;
2446 #ifdef WITH_PIECHART
2447    }
2448 #endif
2449
2450 #ifdef WITH_PIECHART
2451   if (piechart) {
2452     pie_part(im,im->graph_col[GRC_CANVAS],im->pie_x,im->pie_y,im->piesize*0.5,0,2*M_PI);
2453   }
2454 #endif
2455
2456   for(i=0;i<im->gdes_c;i++){
2457     switch(im->gdes[i].gf){
2458     case GF_CDEF:
2459     case GF_VDEF:
2460     case GF_DEF:
2461     case GF_PRINT:
2462     case GF_GPRINT:
2463     case GF_COMMENT:
2464     case GF_HRULE:
2465     case GF_VRULE:
2466     case GF_XPORT:
2467     case GF_SHIFT:
2468       break;
2469     case GF_TICK:
2470       for (ii = 0; ii < im->xsize; ii++)
2471         {
2472           if (!isnan(im->gdes[i].p_data[ii]) &&
2473               im->gdes[i].p_data[ii] != 0.0)
2474            {
2475               if (im -> gdes[i].yrule > 0 ) {
2476                       gfx_new_line(im->canvas,
2477                                    im -> xorigin + ii, im->yorigin,
2478                                    im -> xorigin + ii, im->yorigin - im -> gdes[i].yrule * im -> ysize,
2479                                    1.0,
2480                                    im -> gdes[i].col );
2481               } else if ( im -> gdes[i].yrule < 0 ) {
2482                       gfx_new_line(im->canvas,
2483                                    im -> xorigin + ii, im->yorigin - im -> ysize,
2484                                    im -> xorigin + ii, im->yorigin - ( 1 - im -> gdes[i].yrule ) * im -> ysize,
2485                                    1.0,
2486                                    im -> gdes[i].col );
2487
2488               }
2489            }
2490         }
2491       break;
2492     case GF_LINE:
2493     case GF_AREA:
2494       /* fix data points at oo and -oo */
2495       for(ii=0;ii<im->xsize;ii++){
2496         if (isinf(im->gdes[i].p_data[ii])){
2497           if (im->gdes[i].p_data[ii] > 0) {
2498             im->gdes[i].p_data[ii] = im->maxval ;
2499           } else {
2500             im->gdes[i].p_data[ii] = im->minval ;
2501           }
2502
2503         }
2504       } /* for */
2505
2506       /* *******************************************************
2507        a           ___. (a,t)
2508                   |   |    ___
2509               ____|   |   |   |
2510               |       |___|
2511        -------|--t-1--t--------------------------------
2512
2513       if we know the value at time t was a then
2514       we draw a square from t-1 to t with the value a.
2515
2516       ********************************************************* */
2517       if (im->gdes[i].col != 0x0){
2518         /* GF_LINE and friend */
2519         if(im->gdes[i].gf == GF_LINE ){
2520           double last_y=0.0;
2521           node = NULL;
2522           for(ii=1;ii<im->xsize;ii++){
2523             if (isnan(im->gdes[i].p_data[ii]) || (im->slopemode==1 && isnan(im->gdes[i].p_data[ii-1]))){
2524                 node = NULL;
2525                 continue;
2526             }
2527             if ( node == NULL ) {
2528                 last_y = ytr(im,im->gdes[i].p_data[ii]);
2529                 if ( im->slopemode == 0 ){
2530                   node = gfx_new_line(im->canvas,
2531                                     ii-1+im->xorigin,last_y,
2532                                     ii+im->xorigin,last_y,
2533                                     im->gdes[i].linewidth,
2534                                     im->gdes[i].col);
2535                 } else {
2536                   node = gfx_new_line(im->canvas,
2537                                     ii-1+im->xorigin,ytr(im,im->gdes[i].p_data[ii-1]),
2538                                     ii+im->xorigin,last_y,
2539                                     im->gdes[i].linewidth,
2540                                     im->gdes[i].col);
2541                 }
2542              } else {
2543                double new_y = ytr(im,im->gdes[i].p_data[ii]);
2544                if ( im->slopemode==0 && ! AlmostEqual2sComplement(new_y,last_y,4)){
2545                    gfx_add_point(node,ii-1+im->xorigin,new_y);
2546                };
2547                last_y = new_y;
2548                gfx_add_point(node,ii+im->xorigin,new_y);
2549              };
2550
2551           }
2552         } else {
2553           int idxI=-1;
2554           double *foreY=malloc(sizeof(double)*im->xsize*2);
2555           double *foreX=malloc(sizeof(double)*im->xsize*2);
2556           double *backY=malloc(sizeof(double)*im->xsize*2);
2557           double *backX=malloc(sizeof(double)*im->xsize*2);
2558           int drawem = 0;
2559           for(ii=0;ii<=im->xsize;ii++){
2560             double ybase,ytop;
2561             if ( idxI > 0 && ( drawem != 0 || ii==im->xsize)){
2562                int cntI=1;
2563                int lastI=0;
2564                while (cntI < idxI && AlmostEqual2sComplement(foreY[lastI],foreY[cntI],4) && AlmostEqual2sComplement(foreY[lastI],foreY[cntI+1],4)){cntI++;}
2565                node = gfx_new_area(im->canvas,
2566                                 backX[0],backY[0],
2567                                 foreX[0],foreY[0],
2568                                 foreX[cntI],foreY[cntI], im->gdes[i].col);
2569                while (cntI < idxI) {
2570                  lastI = cntI;
2571                  cntI++;
2572                  while ( cntI < idxI && AlmostEqual2sComplement(foreY[lastI],foreY[cntI],4) && AlmostEqual2sComplement(foreY[lastI],foreY[cntI+1],4)){cntI++;}
2573                  gfx_add_point(node,foreX[cntI],foreY[cntI]);
2574                }
2575                gfx_add_point(node,backX[idxI],backY[idxI]);
2576                while (idxI > 1){
2577                  lastI = idxI;
2578                  idxI--;
2579                  while ( idxI > 1 && AlmostEqual2sComplement(backY[lastI], backY[idxI],4) && AlmostEqual2sComplement(backY[lastI],backY[idxI-1],4)){idxI--;}
2580                  gfx_add_point(node,backX[idxI],backY[idxI]);
2581                }
2582                idxI=-1;
2583                drawem = 0;
2584             }
2585             if (drawem != 0){
2586               drawem = 0;
2587               idxI=-1;
2588             }
2589             if (ii == im->xsize) break;
2590
2591             /* keep things simple for now, just draw these bars
2592                do not try to build a big and complex area */
2593
2594
2595             if ( im->slopemode == 0 && ii==0){
2596                 continue;
2597             }
2598             if ( isnan(im->gdes[i].p_data[ii]) ) {
2599                 drawem = 1;
2600                 continue;
2601             }
2602             ytop = ytr(im,im->gdes[i].p_data[ii]);
2603             if ( lastgdes && im->gdes[i].stack ) {
2604                   ybase = ytr(im,lastgdes->p_data[ii]);
2605             } else {
2606                   ybase = ytr(im,areazero);
2607             }
2608             if ( ybase == ytop ){
2609                 drawem = 1;
2610                 continue;
2611             }
2612             /* every area has to be wound clock-wise,
2613                so we have to make sur base remains base  */
2614             if (ybase > ytop){
2615                 double extra = ytop;
2616                 ytop = ybase;
2617                 ybase = extra;
2618             }
2619             if ( im->slopemode == 0 ){
2620                     backY[++idxI] = ybase-0.2;
2621                     backX[idxI] = ii+im->xorigin-1;
2622                     foreY[idxI] = ytop+0.2;
2623                     foreX[idxI] = ii+im->xorigin-1;
2624             }
2625             backY[++idxI] = ybase-0.2;
2626             backX[idxI] = ii+im->xorigin;
2627             foreY[idxI] = ytop+0.2;
2628             foreX[idxI] = ii+im->xorigin;
2629           }
2630           /* close up any remaining area */
2631           free(foreY);
2632           free(foreX);
2633           free(backY);
2634           free(backX);
2635         } /* else GF_LINE */
2636       } /* if color != 0x0 */
2637       /* make sure we do not run into trouble when stacking on NaN */
2638       for(ii=0;ii<im->xsize;ii++){
2639         if (isnan(im->gdes[i].p_data[ii])) {
2640           if (lastgdes && (im->gdes[i].stack)) {
2641             im->gdes[i].p_data[ii] = lastgdes->p_data[ii];
2642           } else {
2643             im->gdes[i].p_data[ii] = areazero;
2644           }
2645         }
2646       }
2647       lastgdes = &(im->gdes[i]);
2648       break;
2649 #ifdef WITH_PIECHART
2650     case GF_PART:
2651       if(isnan(im->gdes[i].yrule)) /* fetch variable */
2652         im->gdes[i].yrule = im->gdes[im->gdes[i].vidx].vf.val;
2653
2654       if (finite(im->gdes[i].yrule)) {  /* even the fetched var can be NaN */
2655         pie_part(im,im->gdes[i].col,
2656                 im->pie_x,im->pie_y,im->piesize*0.4,
2657                 M_PI*2.0*PieStart/100.0,
2658                 M_PI*2.0*(PieStart+im->gdes[i].yrule)/100.0);
2659         PieStart += im->gdes[i].yrule;
2660       }
2661       break;
2662 #endif
2663     case GF_STACK:
2664       rrd_set_error("STACK should already be turned into LINE or AREA here");
2665       return -1;
2666       break;
2667
2668     } /* switch */
2669   }
2670 #ifdef WITH_PIECHART
2671   if (piechart==2) {
2672     im->draw_x_grid=0;
2673     im->draw_y_grid=0;
2674   }
2675 #endif
2676
2677
2678   /* grid_paint also does the text */
2679   if( !(im->extra_flags & ONLY_GRAPH) )
2680     grid_paint(im);
2681
2682
2683   if( !(im->extra_flags & ONLY_GRAPH) )
2684       axis_paint(im);
2685
2686   /* the RULES are the last thing to paint ... */
2687   for(i=0;i<im->gdes_c;i++){
2688
2689     switch(im->gdes[i].gf){
2690     case GF_HRULE:
2691       if(isnan(im->gdes[i].yrule)) { /* fetch variable */
2692         im->gdes[i].yrule = im->gdes[im->gdes[i].vidx].vf.val;
2693       };
2694       if(im->gdes[i].yrule >= im->minval
2695          && im->gdes[i].yrule <= im->maxval)
2696         gfx_new_line(im->canvas,
2697                      im->xorigin,ytr(im,im->gdes[i].yrule),
2698                      im->xorigin+im->xsize,ytr(im,im->gdes[i].yrule),
2699                      1.0,im->gdes[i].col);
2700       break;
2701     case GF_VRULE:
2702       if(im->gdes[i].xrule == 0) { /* fetch variable */
2703         im->gdes[i].xrule = im->gdes[im->gdes[i].vidx].vf.when;
2704       };
2705       if(im->gdes[i].xrule >= im->start
2706          && im->gdes[i].xrule <= im->end)
2707         gfx_new_line(im->canvas,
2708                      xtr(im,im->gdes[i].xrule),im->yorigin,
2709                      xtr(im,im->gdes[i].xrule),im->yorigin-im->ysize,
2710                      1.0,im->gdes[i].col);
2711       break;
2712     default:
2713       break;
2714     }
2715   }
2716
2717
2718   if (strcmp(im->graphfile,"-")==0) {
2719     fo = im->graphhandle ? im->graphhandle : stdout;
2720 #if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__)
2721     /* Change translation mode for stdout to BINARY */
2722     _setmode( _fileno( fo ), O_BINARY );
2723 #endif
2724   } else {
2725     if ((fo = fopen(im->graphfile,"wb")) == NULL) {
2726       rrd_set_error("Opening '%s' for write: %s",im->graphfile,
2727                     rrd_strerror(errno));
2728       return (-1);
2729     }
2730   }
2731   gfx_render (im->canvas,im->ximg,im->yimg,0x00000000,fo);
2732   if (strcmp(im->graphfile,"-") != 0)
2733     fclose(fo);
2734   return 0;
2735 }
2736
2737
2738 /*****************************************************
2739  * graph stuff
2740  *****************************************************/
2741
2742 int
2743 gdes_alloc(image_desc_t *im){
2744
2745     im->gdes_c++;
2746     if ((im->gdes = (graph_desc_t *) rrd_realloc(im->gdes, (im->gdes_c)
2747                                            * sizeof(graph_desc_t)))==NULL){
2748         rrd_set_error("realloc graph_descs");
2749         return -1;
2750     }
2751
2752
2753     im->gdes[im->gdes_c-1].step=im->step;
2754     im->gdes[im->gdes_c-1].step_orig=im->step;
2755     im->gdes[im->gdes_c-1].stack=0;
2756     im->gdes[im->gdes_c-1].linewidth=0;
2757     im->gdes[im->gdes_c-1].debug=0;
2758     im->gdes[im->gdes_c-1].start=im->start;
2759     im->gdes[im->gdes_c-1].end=im->end;
2760     im->gdes[im->gdes_c-1].vname[0]='\0';
2761     im->gdes[im->gdes_c-1].data=NULL;
2762     im->gdes[im->gdes_c-1].ds_namv=NULL;
2763     im->gdes[im->gdes_c-1].data_first=0;
2764     im->gdes[im->gdes_c-1].p_data=NULL;
2765     im->gdes[im->gdes_c-1].rpnp=NULL;
2766     im->gdes[im->gdes_c-1].shift=0;
2767     im->gdes[im->gdes_c-1].col = 0x0;
2768     im->gdes[im->gdes_c-1].legend[0]='\0';
2769     im->gdes[im->gdes_c-1].format[0]='\0';
2770     im->gdes[im->gdes_c-1].rrd[0]='\0';
2771     im->gdes[im->gdes_c-1].ds=-1;
2772     im->gdes[im->gdes_c-1].p_data=NULL;
2773     im->gdes[im->gdes_c-1].yrule=DNAN;
2774     im->gdes[im->gdes_c-1].xrule=0;
2775     return 0;
2776 }
2777
2778 /* copies input untill the first unescaped colon is found
2779    or until input ends. backslashes have to be escaped as well */
2780 int
2781 scan_for_col(const char *const input, int len, char *const output)
2782 {
2783     int inp,outp=0;
2784     for (inp=0;
2785          inp < len &&
2786            input[inp] != ':' &&
2787            input[inp] != '\0';
2788          inp++){
2789       if (input[inp] == '\\' &&
2790           input[inp+1] != '\0' &&
2791           (input[inp+1] == '\\' ||
2792            input[inp+1] == ':')){
2793         output[outp++] = input[++inp];
2794       }
2795       else {
2796         output[outp++] = input[inp];
2797       }
2798     }
2799     output[outp] = '\0';
2800     return inp;
2801 }
2802 /* Some surgery done on this function, it became ridiculously big.
2803 ** Things moved:
2804 ** - initializing     now in rrd_graph_init()
2805 ** - options parsing  now in rrd_graph_options()
2806 ** - script parsing   now in rrd_graph_script()
2807 */
2808 int
2809 rrd_graph(int argc, char **argv, char ***prdata, int *xsize, int *ysize, FILE *stream, double *ymin, double *ymax)
2810 {
2811     image_desc_t   im;
2812     rrd_graph_init(&im);
2813     im.graphhandle = stream;
2814
2815     rrd_graph_options(argc,argv,&im);
2816     if (rrd_test_error()) {
2817         im_free(&im);
2818         return -1;
2819     }
2820
2821     if (strlen(argv[optind])>=MAXPATH) {
2822         rrd_set_error("filename (including path) too long");
2823         im_free(&im);
2824         return -1;
2825     }
2826     strncpy(im.graphfile,argv[optind],MAXPATH-1);
2827     im.graphfile[MAXPATH-1]='\0';
2828
2829     rrd_graph_script(argc,argv,&im,1);
2830     if (rrd_test_error()) {
2831         im_free(&im);
2832         return -1;
2833     }
2834
2835     /* Everything is now read and the actual work can start */
2836
2837     (*prdata)=NULL;
2838     if (graph_paint(&im,prdata)==-1){
2839         im_free(&im);
2840         return -1;
2841     }
2842
2843     /* The image is generated and needs to be output.
2844     ** Also, if needed, print a line with information about the image.
2845     */
2846
2847     *xsize=im.ximg;
2848     *ysize=im.yimg;
2849     *ymin=im.minval;
2850     *ymax=im.maxval;
2851     if (im.imginfo) {
2852         char *filename;
2853         if (!(*prdata)) {
2854             /* maybe prdata is not allocated yet ... lets do it now */
2855             if ((*prdata = calloc(2,sizeof(char *)))==NULL) {
2856                 rrd_set_error("malloc imginfo");
2857                 return -1;
2858             };
2859         }
2860         if(((*prdata)[0] = malloc((strlen(im.imginfo)+200+strlen(im.graphfile))*sizeof(char)))
2861          ==NULL){
2862             rrd_set_error("malloc imginfo");
2863             return -1;
2864         }
2865         filename=im.graphfile+strlen(im.graphfile);
2866         while(filename > im.graphfile) {
2867             if (*(filename-1)=='/' || *(filename-1)=='\\' ) break;
2868             filename--;
2869         }
2870
2871         sprintf((*prdata)[0],im.imginfo,filename,(long)(im.canvas->zoom*im.ximg),(long)(im.canvas->zoom*im.yimg));
2872     }
2873     im_free(&im);
2874     return 0;
2875 }
2876
2877 void
2878 rrd_graph_init(image_desc_t *im)
2879 {
2880     unsigned int i;
2881
2882 #ifdef HAVE_TZSET
2883     tzset();
2884 #endif
2885 #ifdef HAVE_SETLOCALE
2886     setlocale(LC_TIME,"");
2887 #endif
2888     im->yorigin=0;
2889     im->xorigin=0;
2890     im->minval=0;
2891     im->xlab_user.minsec = -1;
2892     im->ximg=0;
2893     im->yimg=0;
2894     im->xsize = 400;
2895     im->ysize = 100;
2896     im->step = 0;
2897     im->ylegend[0] = '\0';
2898     im->title[0] = '\0';
2899     im->minval = DNAN;
2900     im->maxval = DNAN;
2901     im->unitsexponent= 9999;
2902     im->unitslength= 6;
2903     im->symbol = ' ';
2904     im->viewfactor = 1.0;
2905     im->extra_flags= 0;
2906     im->rigid = 0;
2907     im->gridfit = 1;
2908     im->imginfo = NULL;
2909     im->lazy = 0;
2910     im->slopemode = 0;
2911     im->logarithmic = 0;
2912     im->ygridstep = DNAN;
2913     im->draw_x_grid = 1;
2914     im->draw_y_grid = 1;
2915     im->base = 1000;
2916     im->prt_c = 0;
2917     im->gdes_c = 0;
2918     im->gdes = NULL;
2919     im->canvas = gfx_new_canvas();
2920     im->grid_dash_on = 1;
2921     im->grid_dash_off = 1;
2922     im->tabwidth = 40.0;
2923
2924     for(i=0;i<DIM(graph_col);i++)
2925         im->graph_col[i]=graph_col[i];
2926
2927 #if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__)
2928     {
2929             char *windir;
2930             char rrd_win_default_font[1000];
2931             windir = getenv("windir");
2932             /* %windir% is something like D:\windows or C:\winnt */
2933             if (windir != NULL) {
2934                     strncpy(rrd_win_default_font,windir,999);
2935                     rrd_win_default_font[999] = '\0';
2936                     strcat(rrd_win_default_font,"\\fonts\\");
2937                     strcat(rrd_win_default_font,RRD_DEFAULT_FONT);
2938                     for(i=0;i<DIM(text_prop);i++){
2939                             strncpy(text_prop[i].font,rrd_win_default_font,sizeof(text_prop[i].font)-1);
2940                             text_prop[i].font[sizeof(text_prop[i].font)-1] = '\0';
2941                      }
2942              }
2943     }
2944 #endif
2945     {
2946             char *deffont;
2947             deffont = getenv("RRD_DEFAULT_FONT");
2948             if (deffont != NULL) {
2949                  for(i=0;i<DIM(text_prop);i++){
2950                         strncpy(text_prop[i].font,deffont,sizeof(text_prop[i].font)-1);
2951                         text_prop[i].font[sizeof(text_prop[i].font)-1] = '\0';
2952                  }
2953             }
2954     }
2955     for(i=0;i<DIM(text_prop);i++){
2956       im->text_prop[i].size = text_prop[i].size;
2957       strcpy(im->text_prop[i].font,text_prop[i].font);
2958     }
2959 }
2960
2961 void
2962 rrd_graph_options(int argc, char *argv[],image_desc_t *im)
2963 {
2964     int                 stroff;
2965     char                *parsetime_error = NULL;
2966     char                scan_gtm[12],scan_mtm[12],scan_ltm[12],col_nam[12];
2967     time_t              start_tmp=0,end_tmp=0;
2968     long                long_tmp;
2969     struct rrd_time_value       start_tv, end_tv;
2970     gfx_color_t         color;
2971     optind = 0; opterr = 0;  /* initialize getopt */
2972
2973     parsetime("end-24h", &start_tv);
2974     parsetime("now", &end_tv);
2975
2976     while (1){
2977         static struct option long_options[] =
2978         {
2979             {"start",      required_argument, 0,  's'},
2980             {"end",        required_argument, 0,  'e'},
2981             {"x-grid",     required_argument, 0,  'x'},
2982             {"y-grid",     required_argument, 0,  'y'},
2983             {"vertical-label",required_argument,0,'v'},
2984             {"width",      required_argument, 0,  'w'},
2985             {"height",     required_argument, 0,  'h'},
2986             {"interlaced", no_argument,       0,  'i'},
2987             {"upper-limit",required_argument, 0,  'u'},
2988             {"lower-limit",required_argument, 0,  'l'},
2989             {"rigid",      no_argument,       0,  'r'},
2990             {"base",       required_argument, 0,  'b'},
2991             {"logarithmic",no_argument,       0,  'o'},
2992             {"color",      required_argument, 0,  'c'},
2993             {"font",       required_argument, 0,  'n'},
2994             {"title",      required_argument, 0,  't'},
2995             {"imginfo",    required_argument, 0,  'f'},
2996             {"imgformat",  required_argument, 0,  'a'},
2997             {"lazy",       no_argument,       0,  'z'},
2998             {"zoom",       required_argument, 0,  'm'},
2999             {"no-legend",  no_argument,       0,  'g'},
3000             {"force-rules-legend",no_argument,0,  'F'},
3001             {"only-graph", no_argument,       0,  'j'},
3002             {"alt-y-grid", no_argument,       0,  'Y'},
3003             {"no-minor",   no_argument,       0,  'I'},
3004             {"slope-mode", no_argument,       0,  'E'},
3005             {"alt-autoscale", no_argument,    0,  'A'},
3006             {"alt-autoscale-max", no_argument, 0, 'M'},
3007             {"no-gridfit", no_argument,       0,   'N'},
3008             {"units-exponent",required_argument, 0, 'X'},
3009             {"units-length",required_argument, 0, 'L'},
3010             {"step",       required_argument, 0,    'S'},
3011             {"tabwidth",   required_argument, 0,    'T'},
3012             {"font-render-mode", required_argument, 0, 'R'},
3013             {"font-smoothing-threshold", required_argument, 0, 'B'},
3014             {"alt-y-mrtg", no_argument,       0,  1000}, /* this has no effect it is just here to save old apps from crashing when they use it */
3015             {0,0,0,0}};
3016         int option_index = 0;
3017         int opt;
3018         int col_start,col_end;
3019
3020         opt = getopt_long(argc, argv,
3021                          "s:e:x:y:v:w:h:iu:l:rb:oc:n:m:t:f:a:I:zgjFYAMEX:L:S:T:NR:B:",
3022                           long_options, &option_index);
3023
3024         if (opt == EOF)
3025             break;
3026
3027         switch(opt) {
3028         case 'I':
3029             im->extra_flags |= NOMINOR;
3030             break;
3031         case 'Y':
3032             im->extra_flags |= ALTYGRID;
3033             break;
3034         case 'A':
3035             im->extra_flags |= ALTAUTOSCALE;
3036             break;
3037         case 'M':
3038             im->extra_flags |= ALTAUTOSCALE_MAX;
3039             break;
3040         case 'j':
3041            im->extra_flags |= ONLY_GRAPH;
3042            break;
3043         case 'g':
3044             im->extra_flags |= NOLEGEND;
3045             break;
3046         case 'F':
3047             im->extra_flags |= FORCE_RULES_LEGEND;
3048             break;
3049         case 'X':
3050             im->unitsexponent = atoi(optarg);
3051             break;
3052         case 'L':
3053             im->unitslength = atoi(optarg);
3054             break;
3055         case 'T':
3056             im->tabwidth = atof(optarg);
3057             break;
3058         case 'S':
3059             im->step =  atoi(optarg);
3060             break;
3061         case 'N':
3062             im->gridfit = 0;
3063             break;
3064         case 's':
3065             if ((parsetime_error = parsetime(optarg, &start_tv))) {
3066                 rrd_set_error( "start time: %s", parsetime_error );
3067                 return;
3068             }
3069             break;
3070         case 'e':
3071             if ((parsetime_error = parsetime(optarg, &end_tv))) {
3072                 rrd_set_error( "end time: %s", parsetime_error );
3073                 return;
3074             }
3075             break;
3076         case 'x':
3077             if(strcmp(optarg,"none") == 0){
3078               im->draw_x_grid=0;
3079               break;
3080             };
3081
3082             if(sscanf(optarg,
3083                       "%10[A-Z]:%ld:%10[A-Z]:%ld:%10[A-Z]:%ld:%ld:%n",
3084                       scan_gtm,
3085                       &im->xlab_user.gridst,
3086                       scan_mtm,
3087                       &im->xlab_user.mgridst,
3088                       scan_ltm,
3089                       &im->xlab_user.labst,
3090                       &im->xlab_user.precis,
3091                       &stroff) == 7 && stroff != 0){
3092                 strncpy(im->xlab_form, optarg+stroff, sizeof(im->xlab_form) - 1);
3093                 im->xlab_form[sizeof(im->xlab_form)-1] = '\0';
3094                 if((int)(im->xlab_user.gridtm = tmt_conv(scan_gtm)) == -1){
3095                     rrd_set_error("unknown keyword %s",scan_gtm);
3096                     return;
3097                 } else if ((int)(im->xlab_user.mgridtm = tmt_conv(scan_mtm)) == -1){
3098                     rrd_set_error("unknown keyword %s",scan_mtm);
3099                     return;
3100                 } else if ((int)(im->xlab_user.labtm = tmt_conv(scan_ltm)) == -1){
3101                     rrd_set_error("unknown keyword %s",scan_ltm);
3102                     return;
3103                 }
3104                 im->xlab_user.minsec = 1;
3105                 im->xlab_user.stst = im->xlab_form;
3106             } else {
3107                 rrd_set_error("invalid x-grid format");
3108                 return;
3109             }
3110             break;
3111         case 'y':
3112
3113             if(strcmp(optarg,"none") == 0){
3114               im->draw_y_grid=0;
3115               break;
3116             };
3117
3118             if(sscanf(optarg,
3119                       "%lf:%d",
3120                       &im->ygridstep,
3121                       &im->ylabfact) == 2) {
3122                 if(im->ygridstep<=0){
3123                     rrd_set_error("grid step must be > 0");
3124                     return;
3125                 } else if (im->ylabfact < 1){
3126                     rrd_set_error("label factor must be > 0");
3127                     return;
3128                 }
3129             } else {
3130                 rrd_set_error("invalid y-grid format");
3131                 return;
3132             }
3133             break;
3134         case 'v':
3135             strncpy(im->ylegend,optarg,150);
3136             im->ylegend[150]='\0';
3137             break;
3138         case 'u':
3139             im->maxval = atof(optarg);
3140             break;
3141         case 'l':
3142             im->minval = atof(optarg);
3143             break;
3144         case 'b':
3145             im->base = atol(optarg);
3146             if(im->base != 1024 && im->base != 1000 ){
3147                 rrd_set_error("the only sensible value for base apart from 1000 is 1024");
3148                 return;
3149             }
3150             break;
3151         case 'w':
3152             long_tmp = atol(optarg);
3153             if (long_tmp < 10) {
3154                 rrd_set_error("width below 10 pixels");
3155                 return;
3156             }
3157             im->xsize = long_tmp;
3158             break;
3159         case 'h':
3160             long_tmp = atol(optarg);
3161             if (long_tmp < 10) {
3162                 rrd_set_error("height below 10 pixels");
3163                 return;
3164             }
3165             im->ysize = long_tmp;
3166             break;
3167         case 'i':
3168             im->canvas->interlaced = 1;
3169             break;
3170         case 'r':
3171             im->rigid = 1;
3172             break;
3173         case 'f':
3174             im->imginfo = optarg;
3175             break;
3176         case 'a':
3177             if((int)(im->canvas->imgformat = if_conv(optarg)) == -1) {
3178                 rrd_set_error("unsupported graphics format '%s'",optarg);
3179                 return;
3180             }
3181             break;
3182         case 'z':
3183             im->lazy = 1;
3184             break;
3185         case 'E':
3186             im->slopemode = 1;
3187             break;
3188
3189         case 'o':
3190             im->logarithmic = 1;
3191             if (isnan(im->minval))
3192                 im->minval=1;
3193             break;
3194         case 'c':
3195             if(sscanf(optarg,
3196                       "%10[A-Z]#%n%8lx%n",
3197                       col_nam,&col_start,&color,&col_end) == 2){
3198                 int ci;
3199                 int col_len = col_end - col_start;
3200                 switch (col_len){
3201                         case 3:
3202                                 color = (
3203                                         ((color & 0xF00) * 0x110000) |
3204                                         ((color & 0x0F0) * 0x011000) |
3205                                         ((color & 0x00F) * 0x001100) |
3206                                         0x000000FF
3207                                         );
3208                                 break;
3209                         case 4:
3210                                 color = (
3211                                         ((color & 0xF000) * 0x11000) |
3212                                         ((color & 0x0F00) * 0x01100) |
3213                                         ((color & 0x00F0) * 0x00110) |
3214                                         ((color & 0x000F) * 0x00011)
3215                                         );
3216                                 break;
3217                         case 6:
3218                                 color = (color << 8) + 0xff /* shift left by 8 */;
3219                                 break;
3220                         case 8:
3221                                 break;
3222                         default:
3223                                 rrd_set_error("the color format is #RRGGBB[AA]");
3224                                 return;
3225                 }
3226                 if((ci=grc_conv(col_nam)) != -1){
3227                     im->graph_col[ci]=color;
3228                 }  else {
3229                   rrd_set_error("invalid color name '%s'",col_nam);
3230                   return;
3231                 }
3232             } else {
3233                 rrd_set_error("invalid color def format");
3234                 return;
3235             }
3236             break;
3237         case 'n':{
3238             char prop[15];
3239             double size = 1;
3240             char font[1024] = "";
3241
3242             if(sscanf(optarg,
3243                                 "%10[A-Z]:%lf:%1000s",
3244                                 prop,&size,font) >= 2){
3245                 int sindex,propidx;
3246                 if((sindex=text_prop_conv(prop)) != -1){
3247                   for (propidx=sindex;propidx<TEXT_PROP_LAST;propidx++){
3248                       if (size > 0){
3249                           im->text_prop[propidx].size=size;
3250                       }
3251                       if (strlen(font) > 0){
3252                           strcpy(im->text_prop[propidx].font,font);
3253                       }
3254                       if (propidx==sindex && sindex != 0) break;
3255                   }
3256                 } else {
3257                     rrd_set_error("invalid fonttag '%s'",prop);
3258                     return;
3259                 }
3260             } else {
3261                 rrd_set_error("invalid text property format");
3262                 return;
3263             }
3264             break;
3265         }
3266         case 'm':
3267             im->canvas->zoom = atof(optarg);
3268             if (im->canvas->zoom <= 0.0) {
3269                 rrd_set_error("zoom factor must be > 0");
3270                 return;
3271             }
3272           break;
3273         case 't':
3274             strncpy(im->title,optarg,150);
3275             im->title[150]='\0';
3276             break;
3277
3278         case 'R':
3279                 if ( strcmp( optarg, "normal" ) == 0 )
3280                         im->canvas->aa_type = AA_NORMAL;
3281                 else if ( strcmp( optarg, "light" ) == 0 )
3282                         im->canvas->aa_type = AA_LIGHT;
3283                 else if ( strcmp( optarg, "mono" ) == 0 )
3284                         im->canvas->aa_type = AA_NONE;
3285                 else
3286                 {
3287                         rrd_set_error("unknown font-render-mode '%s'", optarg );
3288                         return;
3289                 }
3290                 break;
3291
3292         case 'B':
3293             im->canvas->font_aa_threshold = atof(optarg);
3294                 break;
3295
3296         case '?':
3297             if (optopt != 0)
3298                 rrd_set_error("unknown option '%c'", optopt);
3299             else
3300                 rrd_set_error("unknown option '%s'",argv[optind-1]);
3301             return;
3302         }
3303     }
3304
3305     if (optind >= argc) {
3306        rrd_set_error("missing filename");
3307        return;
3308     }
3309
3310     if (im->logarithmic == 1 && (im->minval <= 0 || isnan(im->minval))){
3311         rrd_set_error("for a logarithmic yaxis you must specify a lower-limit > 0");
3312         return;
3313     }
3314
3315     if (proc_start_end(&start_tv,&end_tv,&start_tmp,&end_tmp) == -1){
3316         /* error string is set in parsetime.c */
3317         return;
3318     }
3319
3320     if (start_tmp < 3600*24*365*10){
3321         rrd_set_error("the first entry to fetch should be after 1980 (%ld)",start_tmp);
3322         return;
3323     }
3324
3325     if (end_tmp < start_tmp) {
3326         rrd_set_error("start (%ld) should be less than end (%ld)",
3327                start_tmp, end_tmp);
3328         return;
3329     }
3330
3331     im->start = start_tmp;
3332     im->end = end_tmp;
3333     im->step = max((long)im->step, (im->end-im->start)/im->xsize);
3334 }
3335
3336 int
3337 rrd_graph_check_vname(image_desc_t *im, char *varname, char *err)
3338 {
3339     if ((im->gdes[im->gdes_c-1].vidx=find_var(im,varname))==-1) {
3340         rrd_set_error("Unknown variable '%s' in %s",varname,err);
3341         return -1;
3342     }
3343     return 0;
3344 }
3345 int
3346 rrd_graph_color(image_desc_t *im, char *var, char *err, int optional)
3347 {
3348     char *color;
3349     graph_desc_t *gdp=&im->gdes[im->gdes_c-1];
3350
3351     color=strstr(var,"#");
3352     if (color==NULL) {
3353         if (optional==0) {
3354             rrd_set_error("Found no color in %s",err);
3355             return 0;
3356         }
3357         return 0;
3358     } else {
3359         int n=0;
3360         char *rest;
3361         gfx_color_t    col;
3362
3363         rest=strstr(color,":");
3364         if (rest!=NULL)
3365             n=rest-color;
3366         else
3367             n=strlen(color);
3368
3369         switch (n) {
3370             case 7:
3371                 sscanf(color,"#%6lx%n",&col,&n);
3372                 col = (col << 8) + 0xff /* shift left by 8 */;
3373                 if (n!=7) rrd_set_error("Color problem in %s",err);
3374                 break;
3375             case 9:
3376                 sscanf(color,"#%8lx%n",&col,&n);
3377                 if (n==9) break;
3378             default:
3379                 rrd_set_error("Color problem in %s",err);
3380         }
3381         if (rrd_test_error()) return 0;
3382         gdp->col = col;
3383         return n;
3384     }
3385 }
3386
3387
3388 int bad_format(char *fmt) {
3389     char *ptr;
3390     int n=0;
3391     ptr = fmt;
3392     while (*ptr != '\0')
3393         if (*ptr++ == '%') {
3394
3395              /* line cannot end with percent char */
3396              if (*ptr == '\0') return 1;
3397
3398              /* '%s', '%S' and '%%' are allowed */
3399              if (*ptr == 's' || *ptr == 'S' || *ptr == '%') ptr++;
3400
3401              /* %c is allowed (but use only with vdef!) */
3402              else if (*ptr == 'c') {
3403                 ptr++;
3404                 n=1;
3405              }
3406
3407              /* or else '% 6.2lf' and such are allowed */
3408              else {
3409                  /* optional padding character */
3410                  if (*ptr == ' ' || *ptr == '+' || *ptr == '-') ptr++;
3411
3412                  /* This should take care of 'm.n' with all three optional */
3413                  while (*ptr >= '0' && *ptr <= '9') ptr++;
3414                  if (*ptr == '.') ptr++;
3415                  while (*ptr >= '0' && *ptr <= '9') ptr++;
3416
3417                  /* Either 'le', 'lf' or 'lg' must follow here */
3418                  if (*ptr++ != 'l') return 1;
3419                  if (*ptr == 'e' || *ptr == 'f' || *ptr == 'g') ptr++;
3420                  else return 1;
3421                  n++;
3422             }
3423          }
3424
3425       return (n!=1);
3426 }
3427
3428
3429 int
3430 vdef_parse(gdes,str)
3431 struct graph_desc_t *gdes;
3432 const char *const str;
3433 {
3434     /* A VDEF currently is either "func" or "param,func"
3435      * so the parsing is rather simple.  Change if needed.
3436      */
3437     double      param;
3438     char        func[30];
3439     int         n;
3440
3441     n=0;
3442     sscanf(str,"%le,%29[A-Z]%n",&param,func,&n);
3443     if (n== (int)strlen(str)) { /* matched */
3444         ;
3445     } else {
3446         n=0;
3447         sscanf(str,"%29[A-Z]%n",func,&n);
3448         if (n== (int)strlen(str)) { /* matched */
3449             param=DNAN;
3450         } else {
3451             rrd_set_error("Unknown function string '%s' in VDEF '%s'"
3452                 ,str
3453                 ,gdes->vname
3454                 );
3455             return -1;
3456         }
3457     }
3458     if          (!strcmp("PERCENT",func)) gdes->vf.op = VDEF_PERCENT;
3459     else if     (!strcmp("MAXIMUM",func)) gdes->vf.op = VDEF_MAXIMUM;
3460     else if     (!strcmp("AVERAGE",func)) gdes->vf.op = VDEF_AVERAGE;
3461     else if     (!strcmp("MINIMUM",func)) gdes->vf.op = VDEF_MINIMUM;
3462     else if     (!strcmp("TOTAL",  func)) gdes->vf.op = VDEF_TOTAL;
3463     else if     (!strcmp("FIRST",  func)) gdes->vf.op = VDEF_FIRST;
3464     else if     (!strcmp("LAST",   func)) gdes->vf.op = VDEF_LAST;
3465     else if     (!strcmp("LSLSLOPE", func)) gdes->vf.op = VDEF_LSLSLOPE;
3466     else if     (!strcmp("LSLINT",   func)) gdes->vf.op = VDEF_LSLINT;
3467     else if     (!strcmp("LSLCORREL",func)) gdes->vf.op = VDEF_LSLCORREL;
3468     else {
3469         rrd_set_error("Unknown function '%s' in VDEF '%s'\n"
3470             ,func
3471             ,gdes->vname
3472             );
3473         return -1;
3474     };
3475
3476     switch (gdes->vf.op) {
3477         case VDEF_PERCENT:
3478             if (isnan(param)) { /* no parameter given */
3479                 rrd_set_error("Function '%s' needs parameter in VDEF '%s'\n"
3480                     ,func
3481                     ,gdes->vname
3482                     );
3483                 return -1;
3484             };
3485             if (param>=0.0 && param<=100.0) {
3486                 gdes->vf.param = param;
3487                 gdes->vf.val   = DNAN;  /* undefined */
3488                 gdes->vf.when  = 0;     /* undefined */
3489             } else {
3490                 rrd_set_error("Parameter '%f' out of range in VDEF '%s'\n"
3491                     ,param
3492                     ,gdes->vname
3493                     );
3494                 return -1;
3495             };
3496             break;
3497         case VDEF_MAXIMUM:
3498         case VDEF_AVERAGE:
3499         case VDEF_MINIMUM:
3500         case VDEF_TOTAL:
3501         case VDEF_FIRST:
3502         case VDEF_LAST:
3503         case VDEF_LSLSLOPE:
3504         case VDEF_LSLINT:
3505         case VDEF_LSLCORREL:
3506             if (isnan(param)) {
3507                 gdes->vf.param = DNAN;
3508                 gdes->vf.val   = DNAN;
3509                 gdes->vf.when  = 0;
3510             } else {
3511                 rrd_set_error("Function '%s' needs no parameter in VDEF '%s'\n"
3512                     ,func
3513                     ,gdes->vname
3514                     );
3515                 return -1;
3516             };
3517             break;
3518     };
3519     return 0;
3520 }
3521
3522
3523 int
3524 vdef_calc(im,gdi)
3525 image_desc_t *im;
3526 int gdi;
3527 {
3528     graph_desc_t        *src,*dst;
3529     rrd_value_t         *data;
3530     long                step,steps;
3531
3532     dst = &im->gdes[gdi];
3533     src = &im->gdes[dst->vidx];
3534     data = src->data + src->ds;
3535     steps = (src->end - src->start) / src->step;
3536
3537 #if 0
3538 printf("DEBUG: start == %lu, end == %lu, %lu steps\n"
3539     ,src->start
3540     ,src->end
3541     ,steps
3542     );
3543 #endif
3544
3545     switch (dst->vf.op) {
3546         case VDEF_PERCENT: {
3547                 rrd_value_t *   array;
3548                 int             field;
3549
3550
3551                 if ((array = malloc(steps*sizeof(double)))==NULL) {
3552                     rrd_set_error("malloc VDEV_PERCENT");
3553                     return -1;
3554                 }
3555                 for (step=0;step < steps; step++) {
3556                     array[step]=data[step*src->ds_cnt];
3557                 }
3558                 qsort(array,step,sizeof(double),vdef_percent_compar);
3559
3560                 field = (steps-1)*dst->vf.param/100;
3561                 dst->vf.val  = array[field];
3562                 dst->vf.when = 0;       /* no time component */
3563                 free(array);
3564 #if 0
3565 for(step=0;step<steps;step++)
3566 printf("DEBUG: %3li:%10.2f %c\n",step,array[step],step==field?'*':' ');
3567 #endif
3568             }
3569             break;
3570         case VDEF_MAXIMUM:
3571             step=0;
3572             while (step != steps && isnan(data[step*src->ds_cnt])) step++;
3573             if (step == steps) {
3574                 dst->vf.val  = DNAN;
3575                 dst->vf.when = 0;
3576             } else {
3577                 dst->vf.val  = data[step*src->ds_cnt];
3578                 dst->vf.when = src->start + (step+1)*src->step;
3579             }
3580             while (step != steps) {
3581                 if (finite(data[step*src->ds_cnt])) {
3582                     if (data[step*src->ds_cnt] > dst->vf.val) {
3583                         dst->vf.val  = data[step*src->ds_cnt];
3584                         dst->vf.when = src->start + (step+1)*src->step;
3585                     }
3586                 }
3587                 step++;
3588             }
3589             break;
3590         case VDEF_TOTAL:
3591         case VDEF_AVERAGE: {
3592             int cnt=0;
3593             double sum=0.0;
3594             for (step=0;step<steps;step++) {
3595                 if (finite(data[step*src->ds_cnt])) {
3596                     sum += data[step*src->ds_cnt];
3597                     cnt ++;
3598                 };
3599             }
3600             if (cnt) {
3601                 if (dst->vf.op == VDEF_TOTAL) {
3602                     dst->vf.val  = sum*src->step;
3603                     dst->vf.when = cnt*src->step;       /* not really "when" */
3604                 } else {
3605                     dst->vf.val = sum/cnt;
3606                     dst->vf.when = 0;   /* no time component */
3607                 };
3608             } else {
3609                 dst->vf.val  = DNAN;
3610                 dst->vf.when = 0;
3611             }
3612             }
3613             break;
3614         case VDEF_MINIMUM:
3615             step=0;
3616             while (step != steps && isnan(data[step*src->ds_cnt])) step++;
3617             if (step == steps) {
3618                 dst->vf.val  = DNAN;
3619                 dst->vf.when = 0;
3620             } else {
3621                 dst->vf.val  = data[step*src->ds_cnt];
3622                 dst->vf.when = src->start + (step+1)*src->step;
3623             }
3624             while (step != steps) {
3625                 if (finite(data[step*src->ds_cnt])) {
3626                     if (data[step*src->ds_cnt] < dst->vf.val) {
3627                         dst->vf.val  = data[step*src->ds_cnt];
3628                         dst->vf.when = src->start + (step+1)*src->step;
3629                     }
3630                 }
3631                 step++;
3632             }
3633             break;
3634         case VDEF_FIRST:
3635             /* The time value returned here is one step before the
3636              * actual time value.  This is the start of the first
3637              * non-NaN interval.
3638              */
3639             step=0;
3640             while (step != steps && isnan(data[step*src->ds_cnt])) step++;
3641             if (step == steps) { /* all entries were NaN */
3642                 dst->vf.val  = DNAN;
3643                 dst->vf.when = 0;
3644             } else {
3645                 dst->vf.val  = data[step*src->ds_cnt];
3646                 dst->vf.when = src->start + step*src->step;
3647             }
3648             break;
3649         case VDEF_LAST:
3650             /* The time value returned here is the
3651              * actual time value.  This is the end of the last
3652              * non-NaN interval.
3653              */
3654             step=steps-1;
3655             while (step >= 0 && isnan(data[step*src->ds_cnt])) step--;
3656             if (step < 0) { /* all entries were NaN */
3657                 dst->vf.val  = DNAN;
3658                 dst->vf.when = 0;
3659             } else {
3660                 dst->vf.val  = data[step*src->ds_cnt];
3661                 dst->vf.when = src->start + (step+1)*src->step;
3662             }
3663             break;
3664         case VDEF_LSLSLOPE:
3665         case VDEF_LSLINT:
3666         case VDEF_LSLCORREL:{
3667             /* Bestfit line by linear least squares method */
3668
3669             int cnt=0;
3670             double SUMx, SUMy, SUMxy, SUMxx, SUMyy, slope, y_intercept, correl ;
3671             SUMx = 0; SUMy = 0; SUMxy = 0; SUMxx = 0; SUMyy = 0;
3672
3673             for (step=0;step<steps;step++) {
3674                 if (finite(data[step*src->ds_cnt])) {
3675                     cnt++;
3676                     SUMx  += step;
3677                     SUMxx += step * step;
3678                     SUMxy += step * data[step*src->ds_cnt];
3679                     SUMy  += data[step*src->ds_cnt];
3680                     SUMyy  += data[step*src->ds_cnt]*data[step*src->ds_cnt];
3681                 };
3682             }
3683
3684             slope = ( SUMx*SUMy - cnt*SUMxy ) / ( SUMx*SUMx - cnt*SUMxx );
3685             y_intercept = ( SUMy - slope*SUMx ) / cnt;
3686             correl = (SUMxy - (SUMx*SUMy)/cnt) / sqrt((SUMxx - (SUMx*SUMx)/cnt)*(SUMyy - (SUMy*SUMy)/cnt));
3687
3688             if (cnt) {
3689                     if (dst->vf.op == VDEF_LSLSLOPE) {
3690                         dst->vf.val  = slope;
3691                         dst->vf.when = cnt*src->step;
3692                     } else if (dst->vf.op == VDEF_LSLINT)  {
3693                         dst->vf.val = y_intercept;
3694                         dst->vf.when = cnt*src->step;
3695                     } else if (dst->vf.op == VDEF_LSLCORREL)  {
3696                         dst->vf.val = correl;
3697                         dst->vf.when = cnt*src->step;
3698                     };
3699
3700             } else {
3701                 dst->vf.val  = DNAN;
3702                 dst->vf.when = 0;
3703             }
3704             }
3705             break;
3706     }
3707     return 0;
3708 }
3709
3710 /* NaN < -INF < finite_values < INF */
3711 int
3712 vdef_percent_compar(a,b)
3713 const void *a,*b;
3714 {
3715     /* Equality is not returned; this doesn't hurt except
3716      * (maybe) for a little performance.
3717      */
3718
3719     /* First catch NaN values. They are smallest */
3720     if (isnan( *(double *)a )) return -1;
3721     if (isnan( *(double *)b )) return  1;
3722
3723     /* NaN doesn't reach this part so INF and -INF are extremes.
3724      * The sign from isinf() is compatible with the sign we return
3725      */
3726     if (isinf( *(double *)a )) return isinf( *(double *)a );
3727     if (isinf( *(double *)b )) return isinf( *(double *)b );
3728
3729     /* If we reach this, both values must be finite */
3730     if ( *(double *)a < *(double *)b ) return -1; else return 1;
3731 }