/*

 MRTG 2.17.7  -- Rateup

 *********************

 Rateup is a fast add-on to the great MRTG Traffic monitor.  It makes

 the database file updates much faster, and creates the graphic image

 files, ready for processing by PPMTOGIF.  It also reduces memory

 requirements by a factor of 10, and increases the speed of updates

 by a factor of at least 10.  This makes it feasible to run mrtg

 every 5 minutes.

 rateup attempts to compensate for missed updates by repeating the last

 sample, and also tries to catch bad update times.  The .log file stores

 real history every five minutes for 31 hours, then 'compresses' the 

 history into 30 minute samples for a week, then 2-hour samples for

 31 days, then daily samples for two years.  This ensures that the

 log files don't grow in size.

 The log files are a slightly different format, but convert.perl

 will fix that for you.

 Enjoy!

 Dave Rand

 dlr@bungi.com

 04/26/99 - There was some compilation bug under Watcom 10.6

            which was fixed when recompiled with VC++ 6.0

			Alexandre Steinberg

			steinberg@base.com.br

*/

#include <stdlib.h>

#include <string.h>

/* VC++ does not have unistd.h */

#ifndef WIN32

#ifndef NETWARE

#include "../config.h"

#endif

#include <unistd.h>

#endif

#include <limits.h>

#include <stdio.h>

#include <time.h>

#include <math.h>

#include <ctype.h>

#ifndef GFORM_GD

#define GFORM_GD gdImagePng

#endif

/* BSD* does not have/need malloc.h */

#if !defined(bsdi) && !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__APPLE__)

#include <malloc.h>

#endif

/* MSVCRT.DLL does not know %ll in printf */

#ifdef __MINGW32_VERSION

#define LLD "%I64d"

#define LLD_FORMAT "I64d"

#endif

#ifdef __EMX__			/* OS/2 */

#define strtoll _strtoll

#define LLD "%Ld"		/* EMX lib use %Ld for long long */

#define LLD_FORMAT "Ld"

#endif

#ifndef LLD

#define  LLD "%lld"

#define  LLD_FORMAT "lld"

#endif

/* WATCOM C/C++ 10.6 under Win95/NT */

/* VC++ 6.0 under Win95/NT */

#if defined(__WATCOMC__) || defined(WIN32)

#include <string.h>

#include <sys/types.h>

#include <direct.h>

#include <io.h>

#endif

#include <gd.h>

#include <gdfonts.h>

char *VERSION = "2.17.7";

char *program, *router, *routerpath;

int histvalid;

/* Options */

short options = 0;

#define OPTION_WITHZEROES	0x0001	/* withzeros */

#define OPTION_UNKNASZERO	0x0002	/* unknaszero */

#define OPTION_TRANSPARENT	0x0004	/* transparent */

#define OPTION_DORELPERCENT	0x0008	/* dorelpercent */

#define OPTION_NOBORDER		0x0010	/* noborder */

#define OPTION_NOARROW		0x0020	/* noarrow */

#define OPTION_NO_I		0x0040	/* ignore 'I' (first) variable */

#define OPTION_NO_O		0x0080	/* ignore 'O' (second) variable */

#define OPTION_PRINTROUTER	0x0200	/* show title in graph */

#define OPTION_LOGGRAPH		0x0400	/* Use a logarithmic Y axis */

#define OPTION_MEANOVER		0x0800	/* max Y = mean-above-the-mean */

#define OPTION_EXPGRAPH		0x1000	/* exponential scale (opposite of logscale) */

time_t NOW;

/* jpt, april 2006 : added 3 lines for date & time logging */

struct tm * stLocal;

time_t timestamp;

char bufftime[32];

char *short_si_def[] = { "", "k", "M", "G", "T" };

int kMGnumber = 4;

char **short_si = short_si_def;

char *longup = NULL;

char *shortup = NULL;

char *pngtitle = NULL;

char *rtimezone = NULL;

char weekformat = 'V';		/* strftime() fmt char for week #  */

#define DAY_COUNT (600)		/* 400 samples is 33.33 hours */

#define DAY_SAMPLE (5*60)	/* Sample every 5 minutes */

#define WEEK_COUNT (600)	/* 400 samples is 8.33 days */

#define WEEK_SAMPLE (30*60)	/* Sample every 30 minutes */

#define MONTH_COUNT (600)	/* 400 samples is 33.33 days */

#define MONTH_SAMPLE (2*60*60)	/* Sample every 2 hours */

#define YEAR_COUNT  (2 * 366)	/* 1 sample / day, 366 days, 2 years */

#define YEAR_SAMPLE (24*60*60)	/* Sample every 24 hours */

/* One 'rounding error' per sample period, so add 4 to total and for 

   good mesure we take 10 :-) */

#define MAX_HISTORY (DAY_COUNT+WEEK_COUNT+MONTH_COUNT+YEAR_COUNT+10)

/* These are the colors used for the variouse parts of the graph */

/* the format is Red,Green,Blue */

#define c_blank 245,245,245

#define c_light 194,194,194

#define c_dark 100,100,100

#define c_major 255,0,0

#define c_in    0,235,12

#define c_out   0,94,255

#define c_grid  0,0,0

#define c_inm   0,166,33

#define c_outm  255,0,255

#define c_outp  239,159,79

int col_in[3];

int col_out[3];

int col_inm[3];

int col_outm[3];

int col_outp[3];

long long kilo = (long long) 1000;

char *kMG = (char *) NULL;

#define MAXL	200		/* Maximum length of last in & out fields */

struct HISTORY

{

  time_t time;

  double in, out, percent, inmax, outmax;

}

 *history;

int Mh;

struct LAST

{

  time_t time;

  char in[MAXL], out[MAXL];

}

last;

#ifndef max

#define max(a,b) ((a) > (b) ? (a) : (b))

#endif

#ifndef min

#define min(a,b) ((a) < (b) ? (a) : (b))

#endif

/*

notes about the NEXT macro ....

* position n to the entry in the history array so that NOW is between

  history[n] and history[n+1]

* calculate the interval according to steptime and position of 

  now within the history array.

for debuging 

    fprintf (stderr,"%s, NOW: %8lu  ST: %4lu  N: %4u HTN: %8lu HTN+1: %8lu IV: %6.0f\n", \

            bufftime,now,steptime,n,history[n].time, history[n+1].time, interval);\

*/

#define NEXT(steptime) \

  inmax = outmax = avc = 0; \

  inr = outr = 0.0;\

  nextnow = now - steptime;\

  if (now == history[n].time && \

      n

      nextnow == history[n+1].time) { \

    inr = (double) history[n].in;\

    outr = (double) history[n].out;\

    inmax = history[n].inmax;\

    outmax = history[n].outmax;\

    n++;\

  } else {\

    if (now > history[n].time) {\

      fprintf(stderr,"%s, ERROR: Rateup is trying to read ahead of the available data\n" ,bufftime);\

    } else {\

      while (now <= history[n+1].time && n < histvalid){n++;}\

      do {\

	if (now >= history[n].time) {\

	  if (nextnow <= history[n+1].time) {\

	    interval = history[n].time - history[n+1].time;\

	  } else {\

	    interval = history[n].time - nextnow;\

	  }\

	} else {\

	  if (nextnow > history[n+1].time) {\

	    interval = steptime;\

	  } else {\

	    interval = now - history[n+1].time;\

	  }\

	}\

	inr  += (double) history[n].in * interval;\

	outr += (double) history[n].out * interval;\

	avc += interval;\

       inmax =  (long long) max(inmax, history[n].inmax);\

       outmax = (long long) max(outmax,history[n].outmax);\

	if (nextnow <= history[n+1].time) n++; else break;\

      } while (n < histvalid && nextnow < history[n].time);\

\

      if (avc != steptime) {\

       fprintf(stderr,"%s, ERROR: StepTime does not match Avc %8" LLD_FORMAT ". Please Report this.\n", bufftime, avc);\

      }\

\

      inr /= avc; outr /= avc;\

    }\

  }

static double logscale(double y, double maxy)

{

     y = (y * (maxy - 1) / maxy) + 1;

     y = log(y) / log (maxy) * maxy;

     if (y < 0) return 0;

     if (y > maxy) return maxy;

     return y;

}

static double expscale(double y, double maxy)

{

    y = exp(y / maxy * log(maxy));

    return (y - 1) * maxy / (maxy - 1);

}

static void

image (file, maxvi, maxvo, maxx, maxy, xscale, yscale, growright, step, bits,

       ytics, yticsf, peak, currdatetimeformat, currdatetimepos)

     char *file;

     long long maxvi, maxvo;

     long maxx;

     long maxy, growright, step, bits;

     double xscale, yscale;

     int ytics;			/* number of tics on the y axis */

     double yticsf;		/* scale everything on the y axis with this factor */

     int peak;

     char *currdatetimeformat;

     int currdatetimepos;

{

  FILE *fo;

  char file_tmp[10240];

  int i, x, n, type;

  long long maxv;

  double origmaxvi, origmaxvo;

  long long maxs, avc, inmax, outmax;

  long long ytrmax;

  double y, lmx1, lmx2, mea1, mea2, temp;

  double inr, outr, muli = 1, interval;

  time_t now, onow, nextnow;

  struct tm tm2, *tm = &tm;;

  char **graph_label;

  char ylab[30];

  /* scaling helpers */

  long long maxv_q;

  long long valsamp, maxin, maxout, digits, digits1, maxpercent = 0;

  long long sca_ten, sca_hun;

  double nmax_q;

  double avmxin, avmxout, avin, avout, latestout = 0, latestin =

    0, nmax, avpercent = 0, latestpercent = 0;

  double nex_ten, nex_hun, nex_rnd;

  double sca_max_q, dummy;

  double percent;

  char *short_si_out;

  char currdatetimestr[256];

  time_t currdatetime;

  int currdatetimepos_x, currdatetimepos_y;

#define NO_TIMESTAMPSTR (0)

#define LU_CORNER (1)

#define RU_CORNER (2)

#define LL_CORNER (3)

#define RL_CORNER (4)

  struct HISTORY *lhist;

  /* ################################################# */

  /* Some general definitions for the graph generation */

#define XSIZE (long)((maxx*xscale)+100+((options & OPTION_DORELPERCENT) ? 1 : 0)*30)

#define YSIZE (long)((maxy*yscale)+35)

  /* position the graph */

#define ytr(y) (long)(maxy*yscale+14-((y)*yscale))

  /* translate x/y coord into graph coord */

#define xtr(x) (long)((growright) ? (maxx*xscale+81-((x)*xscale)) : (81+((x)*xscale)))

  /* ################################################# */

  /* GD LIB declarations */

  /* Declare the image */

  gdImagePtr graph, brush_out, brush_outm, brush_outp;

  /* Declare color indexes */

  int i_light, i_dark, i_blank, i_major, i_in, i_out, i_grid, i_inm, i_outm;

  int i_outp, i_outpg;

  /* Dotted style */

  int styleDotted[3];

  if ((graph_label = (char **) calloc (1, sizeof (char *) * maxx)) == NULL)

    {

      fprintf (stderr, "%s, Rateup ERROR: Out of memory in graph creation\n", bufftime);

      exit (1);

    }

  /* multiplicator for bits/bytes */

  if (bits) {

      muli = 8;

  }

  maxv = (long long) max (maxvi, maxvo);

  maxv *= (long long) muli;

  origmaxvi = maxvi < (long long) 0 ? -maxvi : maxvi;

  origmaxvo = maxvo < (long long) 0 ? -maxvo : maxvo;

  if (step > MONTH_SAMPLE)

    {

      type = 4;

      now = (long) (NOW / YEAR_SAMPLE) * YEAR_SAMPLE;

    }

  else if (step > WEEK_SAMPLE)

    {

      type = 3;

      now = (long) (NOW / MONTH_SAMPLE) * MONTH_SAMPLE;

    }

  else if (step > DAY_SAMPLE)

    {

      type = 2;

      now = (long) (NOW / WEEK_SAMPLE) * WEEK_SAMPLE;

    }

  else

    {

      type = 1;

      now = (long) (NOW / DAY_SAMPLE) * DAY_SAMPLE;

    }

  if ((lhist = calloc (1, sizeof (struct HISTORY) * maxx)) == NULL)

    {

      fprintf (stderr, "%s, Rateup ERROR: Out of memory in graph creation\n", bufftime);

      exit (1);

    }

  onow = now;

  avin = avout = avmxin = avmxout = 0.0;

  inmax = outmax = maxin = maxout = 0;

  valsamp = 0;

  for (maxs = 0, n = 0, x = 0; x < maxx; x++)

    {

      NEXT (step);

      /*scale with muli */

      inr *= muli;

      outr *= muli;

      inmax *= muli;

      outmax *= muli;

      /* ignore times when we have not sampled */

      if (inmax > 0 || outmax > 0 || inr > 0 || outr > 0

	  || (options & OPTION_WITHZEROES)) valsamp++;

      if (x == 0)

	{

	  latestin = inr;

	  latestout = outr;

	  if (outr)

	    {

	      latestpercent = inr * (double) 100. / outr;

	    }

	}

      avin += inr;

      avout += outr;

      avmxin += inmax;

      avmxout += outmax;

      if (peak)

	{

	  maxin = (long long) max (maxin, inmax);

	  maxout = (long long) max (maxout, outmax);

          if (!(options & OPTION_NO_I)){

   	     maxs = (long long) max (maxs, inmax);

          }

          if (!(options & OPTION_NO_O)){

  	     maxs = (long long) max (maxs, outmax);

          }

	}

      else

	{

	  maxin = (long long) max (maxin, inr);

	  maxout = (long long) max (maxout, outr);

          if (!(options & OPTION_NO_I)){

  	     maxs = (long long) max (maxs, inr);

          }

          if (!(options & OPTION_NO_O)){

  	     maxs = (long long) max (maxs, outr);

          }

	}

      if ((options & OPTION_DORELPERCENT) && outr)

	{

	  dummy = (double) 100. *inr / outr;

	  maxpercent = max (dummy, maxpercent);

	}

      now -= step;

    }

  if (options & OPTION_DORELPERCENT)

    {

      if (avout && valsamp)

	{

	  avpercent = (double) 100. *avin / avout;

	}

      else

	{

	  avpercent = 0;

	}

    }

  if (valsamp)

    {

      avin /= valsamp;

      avout /= valsamp;

      avmxin /= valsamp;

      avmxout /= valsamp;

    }

  printf ("" LLD "\n", (long long) (maxin / (long long) muli + .5));

  printf ("" LLD "\n", (long long) (maxout / (long long) muli + .5));

  if (options & OPTION_DORELPERCENT)

    {

      printf ("" LLD "\n", (long long) (maxpercent + .5));

    }

  printf ("" LLD "\n", (long long) (avin / (long long) muli + .5));

  printf ("" LLD "\n", (long long) (avout / (long long) muli + .5));

  if (options & OPTION_DORELPERCENT)

    {

      printf ("" LLD "\n", (long long) (avpercent + .5));

    }

  printf ("" LLD "\n", (long long) (latestin / (long long) muli + .5));

  printf ("" LLD "\n", (long long) (latestout / (long long) muli + .5));

  if (options & OPTION_DORELPERCENT)

    {

      printf ("" LLD "\n", (long long) (latestpercent + .5));

    }

  printf ("" LLD "\n", (long long) (avmxin / (long long) muli + .5));

  printf ("" LLD "\n", (long long) (avmxout / (long long) muli + .5));

  if (maxv < 0 || maxv < maxs)

    {

      maxv = maxs;

    }

  now = onow;

  if (maxv <= 0)

    maxv = 1;

  if (kMG)

    {

      if (short_si[0] != kMG)

        {

          short_si_out = kMG;

          kMGnumber = 0;

          while ((short_si_out = strchr (short_si_out, ',')) != NULL)

	    {

	      short_si_out++;

              kMGnumber++;

	    }

          short_si = calloc(kMGnumber + 1, sizeof(*short_si));

          short_si_out = kMG;

          for (kMGnumber = 0; ; kMGnumber++)

            {

              short_si[kMGnumber] = short_si_out;

             short_si_out = strchr(short_si_out, ',');

              if (short_si_out == NULL) break;

              short_si_out[0] = '\0';

              short_si_out++;

            }

        }

     }

  /* mangle the 0.25*maxv value so, that we get a number with either */

  /* one or two digits != 0 and these digits should be at the  */

  /* start of the number ... */

  /* the ceil compensates for rounding with small numbers */

  maxv_q = ceil ((double) maxv / (double) ytics);	/* int */

  digits = 0;

  {

    double number = (double) maxv_q;

    number *= yticsf;		/* we just want to scale the lables nothing else */

/*

       while (number/(double) kilo >= (double)kilo && digits

*/

    /* yes this should be kilo, but then the log and pow bits below

       should be base 'kilo' as well and not base 10 */

    while (digits < (long long) kMGnumber * 3 &&

           (number >= (double) 1000 || short_si[digits / 3][0] == '-'))

      {

	number /= (double) 1000;

	digits += 3;

      }

    sca_max_q = (double) ((int) (((double) 100. * (double) number) /

				 (pow

				  ((double) 10.,

				   (double) (int) (log10 ((double) number))))

				 +

				 (double) 9.999) / (int) 10) / (double) 10 *

      (pow ((double) 10., (double) (int) (log10 ((double) number))));

  }

  short_si_out = short_si[min ((signed) (digits / 3), kMGnumber)];

  if (maxv_q * yticsf >= 1)

    {

      digits1 = log10 ((double) maxv_q * yticsf);

    }

  else

    {

      digits1 = 0;

    }

/*  sca_ten = maxv_q / pow(10.0,(double)digits); */

/*  sca_hun = maxv_q / pow(10.0,(double)digits-1); */

  sca_ten = (double) maxv_q *yticsf / pow (10.0, (double) digits1);

  sca_hun = (double) maxv_q *yticsf / pow (10.0, (double) digits1 - 1);

  nex_rnd = (sca_hun) * pow (10.0, (double) digits1 - 1);

  nex_ten = (sca_ten + 1) * pow (10.0, (double) digits1);

  nex_hun = (sca_hun + 1) * pow (10.0, (double) digits1 - 1);

/*  if (nex_ten <= (1.1 * maxv_q))  { */

  if (nex_ten <= (1.1 * maxv_q * yticsf))

    {

      nmax_q = nex_ten;

/*  } else if (maxv_q == nex_rnd) {  */

    }

  else if ((maxv_q * yticsf) == nex_rnd)

    {

      nmax_q = nex_rnd;

    }

  else

    {

      nmax_q = nex_hun;

    }

  sca_max_q = nmax_q / (pow (10.0, (double) ((int) (digits / 3)) * 3));

/*  nmax=sca_max_q*ytics*(pow((double)kilo,(double)((int)(digits1/3))));  */

  nmax =

    (sca_max_q / yticsf) * ytics *

    (pow ((double) kilo, (double) ((int) (digits / 3))));

  if (nmax < 1.)

    {

      nmax = 1.;

    }

  for (n = 0, x = 0; x < maxx; x++)

    {

      lhist[x].time = 0;

      graph_label[x] = NULL;

      /* this seesm to be necessary to work a round a bug in solaris

         where tm for complex TZ settings gets modified after the

         fact ... so we whisk the stuff away into our own memspace

         just in time */

      memcpy (tm, localtime (&history[n].time), sizeof (struct tm));

      switch (type)

	{

	default:

	case 1:

	  if (tm->tm_min < 5)

	    {

	      lhist[x].time |= 1;

	      if (tm->tm_hour == 0)

		lhist[x].time |= 2;

	    }

	  if ((tm->tm_min < 5) && (tm->tm_hour % 2 == 0))

	    {

	      if ((graph_label[x] = calloc (1, sizeof (char) * 4)) == NULL)

		{

		  fprintf (stderr,

			   "%s, Rateup ERROR: Out of memory in graph labeling\n", bufftime);

		  exit (0);

		}

	      else

		{

		  sprintf (graph_label[x], "%i", tm->tm_hour);

		}

	    }

	  break;

	case 2:

	  if (tm->tm_min < 30 && tm->tm_hour == 0)

	    {

	      lhist[x].time |= 1;

	      if (tm->tm_wday == 1)

		lhist[x].time |= 2;

	    }

	  /* fprintf(stderr,"%s, x: %i, min:%i, hour:%i day: %i\n",

	     bufftime,x,tm->tm_min,tm->tm_hour,tm->tm_wday); */

	  if ((tm->tm_min < 30) && (tm->tm_hour == 12))

	    {

	      if ((graph_label[x] = calloc (1, sizeof (char) * 5)) == NULL)

		{

		  fprintf (stderr,

			   "%s, Rateup ERROR: Out of memory in graph labeling\n", bufftime);

		  exit (0);

		}

	      else

		{

		  strftime (graph_label[x], 4, "%a", tm);

		}

	    }

	  break;

	case 3:

	  if (tm->tm_hour < 2)

	    {

	      if (tm->tm_wday == 1)

		lhist[x].time |= 1;

	      if (tm->tm_mday == 1)

		lhist[x].time |= 2;

	    }

	  /* label goes to thursday noon */

	  if ((tm->tm_hour > 10) && (tm->tm_hour <= 12) && (tm->tm_wday == 4))

	    {

	      if ((graph_label[x] = calloc (1, sizeof (char) * 16)) == NULL)

		{

		  fprintf (stderr,

			   "%s, Rateup ERROR: Out of memory in graph labeling\n", bufftime);

		  exit (0);

		}

	      else

		{

		  char fmtbuf[10];

		  sprintf (fmtbuf, "Week %%%c", weekformat);

		  strftime (graph_label[x], 8, fmtbuf, tm);

		}

	    }

	  break;

	case 4:

	  if (tm->tm_mday == 1)

	    lhist[x].time |= 1;

	  if (tm->tm_yday == 0)

	    lhist[x].time |= 2;

	  if (tm->tm_mday == 15)

	    {

	      if ((graph_label[x] = calloc (1, sizeof (char) * 5)) == NULL)

		{

		  fprintf (stderr,

			   "%s, Rateup Error: Out of memory in graph labeling\n", bufftime);

		  exit (0);

		}

	      else

		{

		  strftime (graph_label[x], 4, "%b", tm);

		}

	    }

	  break;

	}

      NEXT (step);

      /*scale with muli */

      inr *= muli;

      outr *= muli;

      inmax *= muli;

      outmax *= muli;

      y = ((double) inr / nmax) * maxy;

      if (y >= maxy)

	y = maxy;

      lhist[x].in = y;

      y = ((double) outr / nmax) * maxy;

      if (y >= maxy)

	y = maxy;

      lhist[x].out = y;

      y = ((double) inmax / nmax) * maxy;

      if (y >= maxy)

	y = maxy;

      lhist[x].inmax = y;

      y = ((double) outmax / nmax) * maxy;

      if (y >= maxy)

	y = maxy;

      lhist[x].outmax = y;

      if (options & OPTION_DORELPERCENT)

	{

	  if (outr != (long long) 0)

	    {

	      percent = (double) inr / (double) outr;

	    }

	  else

	    {

	      percent = (double) 0.;

	    }

	  if (percent > (double) 1)

	    percent = (double) 1.;

	  percent *= maxy;

	  lhist[x].percent = (long long) percent;

	}

      else

	{

	  lhist[x].percent = (long long) 0;

	}

      now -= step;

    }

  origmaxvi = (origmaxvi * muli / nmax ) * maxy;

  origmaxvo = (origmaxvo * muli / nmax ) * maxy;

  /* Log and second-mean scaling added by Benjamin Despres, 2004-10-13 */

  if (options & OPTION_MEANOVER)

    {

      lmx1 = lmx2 = mea1 = mea2 = temp = 0.0;

      for (x = 0; x < maxx; x++)

	{

	  if (lhist[x].in < 1.0)

	    lhist[x].in = 1.0;

	  if (lhist[x].out < 1.0)

	    lhist[x].out = 1.0;

	  if (lhist[x].inmax < 1.0)

	    lhist[x].inmax = 1.0;

	  if (lhist[x].outmax < 1.0)

	    lhist[x].outmax = 1.0;

	  if (lhist[x].in > lmx1)

	    lmx1 = lhist[x].in;

	  if (lhist[x].out > lmx1)

	    lmx1 = lhist[x].out;

	  if (lhist[x].inmax > lmx1)

	    lmx1 = lhist[x].inmax;

	  if (lhist[x].outmax > lmx1)

	    lmx1 = lhist[x].outmax;

	  mea1 +=

	    (lhist[x].in + lhist[x].out + lhist[x].inmax +

	     lhist[x].outmax) / 4.0;

	}

      if (origmaxvi < 1.0)

	origmaxvi = 1.0;

      if (origmaxvo < 1.0)

	origmaxvo = 1.0;

      mea1 /= (double) maxx;

	  for (x = 0; x < maxx; x++)

	    {

	      y =

		(lhist[x].in + lhist[x].out + lhist[x].inmax +

		 lhist[x].outmax) / 4.0;

	      if (y > mea1)

		{

		  mea2 += y;

		  temp += 1.0;

		}

	    }

	  mea2 /= temp;

	  for (x = 0; x < maxx; x++)

	    {

	      if (lhist[x].in > mea2)

		lhist[x].in = mea2;

	      if (lhist[x].out > mea2)

		lhist[x].out = mea2;

	      if (lhist[x].inmax > mea2)

		lhist[x].inmax = mea2;

	      if (lhist[x].outmax > mea2)

		lhist[x].outmax = mea2;

	    }

      for (x = 0; x < maxx; x++)

	{

	  if (lhist[x].in > lmx2)

	    lmx2 = lhist[x].in;

	  if (lhist[x].out > lmx2)

	    lmx2 = lhist[x].out;

	  if (lhist[x].inmax > lmx2)

	    lmx2 = lhist[x].inmax;

	  if (lhist[x].outmax > lmx2)

	    lmx2 = lhist[x].outmax;

	}

      if (lmx2 > 0.0)

	lmx2 = (lmx1 / lmx2);

      for (x = 0; x < maxx; x++)

	{

	  lhist[x].in *= lmx2;

	  lhist[x].out *= lmx2;

	  lhist[x].inmax *= lmx2;

	  lhist[x].outmax *= lmx2;

	}

      origmaxvi *= lmx2;

      origmaxvo *= lmx2;

      sca_max_q *= ((float) mea2 / (float) maxy);

    }

  else if (options & OPTION_LOGGRAPH)

    {

      for (x = 0; x < maxx; x++)

        {

          lhist[x].in = logscale (lhist[x].in, maxy);

          lhist[x].out = logscale (lhist[x].out, maxy);

          lhist[x].inmax = logscale (lhist[x].inmax, maxy);

          lhist[x].outmax = logscale (lhist[x].outmax, maxy);

        }

      origmaxvi = logscale (origmaxvi, maxy);

      origmaxvo = logscale (origmaxvo, maxy);

    }	/* end of primary log and second-mean scaling code (more below) */

  else if (options & OPTION_EXPGRAPH)

    {

      for (x = 0; x < maxx; x++)

        {

          lhist[x].in = expscale (lhist[x].in, maxy);

          lhist[x].out = expscale (lhist[x].out, maxy);

          lhist[x].inmax = expscale (lhist[x].inmax, maxy);

          lhist[x].outmax = expscale (lhist[x].outmax, maxy);

        }

      origmaxvi = expscale (origmaxvi, maxy);

      origmaxvo = expscale (origmaxvo, maxy);

    }

  /* the graph is made ten pixels higher to acomodate the x labels */

  graph = gdImageCreate (XSIZE, YSIZE);

  brush_out = gdImageCreate (1, 2);

  brush_outm = gdImageCreate (1, 2);

  brush_outp = gdImageCreate (1, 2);

  /* the first color allocated will be the background color. */

  i_blank = gdImageColorAllocate (graph, c_blank);

  i_light = gdImageColorAllocate (graph, c_light);

  i_dark = gdImageColorAllocate (graph, c_dark);

  if (options & OPTION_TRANSPARENT)

    {

      gdImageColorTransparent (graph, i_blank);

    }

  gdImageInterlace (graph, 1);

  /* do NOT delete the out variables. they are dummies, but the actual color

     allocation for the brush is essential */

  i_major = gdImageColorAllocate (graph, c_major);

  i_in = gdImageColorAllocate (graph, col_in[0], col_in[1], col_in[2]);

  i_out =

    gdImageColorAllocate (brush_out, col_out[0], col_out[1], col_out[2]);

  i_grid = gdImageColorAllocate (graph, c_grid);

  i_inm = gdImageColorAllocate (graph, col_inm[0], col_inm[1], col_inm[2]);

  i_outm =

    gdImageColorAllocate (brush_outm, col_outm[0], col_outm[1], col_outm[2]);

  i_outp =

    gdImageColorAllocate (brush_outp, col_outp[0], col_outp[1], col_outp[2]);