开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
rateup.c
资源名称：mrtg-2.13.2.zip　[点击查看]
上传用户：shbosideng
上传日期：2013-05-04
资源大小：1555k
文件大小：59k
源码类别：

SNMP编程

开发平台：

C/C++

rateup.c：源码内容
  1. /*
  2.  MRTG 2.13.2  -- Rateup
  3.  *********************
  5.  Rateup is a fast add-on to the great MRTG Traffic monitor.  It makes
  6.  the database file updates much faster, and creates the graphic image
  7.  files, ready for processing by PPMTOGIF.  It also reduces memory
  8.  requirements by a factor of 10, and increases the speed of updates
  9.  by a factor of at least 10.  This makes it feasible to run mrtg
  10.  every 5 minutes.
  12.  rateup attempts to compensate for missed updates by repeating the last
  13.  sample, and also tries to catch bad update times.  The .log file stores
  14.  real history every five minutes for 31 hours, then 'compresses' the 
  15.  history into 30 minute samples for a week, then 2-hour samples for
  16.  31 days, then daily samples for two years.  This ensures that the
  17.  log files don't grow in size.
  19.  The log files are a slightly different format, but convert.perl
  20.  will fix that for you.
  22.  Enjoy!
  23.  Dave Rand
  24.  dlr@bungi.com
  26.  04/26/99 - There was some compilation bug under Watcom 10.6
  27.             which was fixed when recompiled with VC++ 6.0
  28. Alexandre Steinberg
  29. steinberg@base.com.br
  31. */
  33. #include <stdlib.h>
  34. #include <string.h>
  35. /* VC++ does not have unistd.h */
  36. #ifndef WIN32
  37. #ifndef NETWARE
  38. #include "../config.h"
  39. #endif
  40. #include <unistd.h>
  41. #endif
  42. #include <limits.h>
  43. #include <stdio.h>
  44. #include <time.h>
  45. #include <math.h>
  46. #include <ctype.h>
  47. #ifndef GFORM_GD
  48. #define GFORM_GD gdImagePng
  49. #endif
  51. /* BSD* does not have/need malloc.h */
  52. #if !defined(bsdi) && !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__APPLE__)
  53. #include <malloc.h>
  54. #endif
  56. /* MSVCRT.DLL does not know %ll in printf */
  57. #ifdef __MINGW32_VERSION
  58. #define LLD "%I64d"
  59. #define LLD_FORMAT "I64d"
  60. #endif
  62. #ifdef __EMX__ /* OS/2 */
  63. #define strtoll _strtoll
  64. #define LLD "%Ld" /* EMX lib use %Ld for long long */
  65. #define LLD_FORMAT "Ld"
  66. #endif
  68. #ifndef LLD
  69. #define  LLD "%lld"
  70. #define  LLD_FORMAT "lld"
  71. #endif
  74. /* WATCOM C/C++ 10.6 under Win95/NT */
  75. /* VC++ 6.0 under Win95/NT */
  76. #if defined(__WATCOMC__) || defined(WIN32)
  77. #include <string.h>
  78. #include <sys/types.h>
  79. #include <direct.h>
  80. #include <io.h>
  81. #endif
  83. #include <gd.h>
  84. #include <gdfonts.h>
  86. char *VERSION = "2.13.2";
  87. char *program, *router, *routerpath;
  88. int histvalid;
  90. /* Options */
  91. short options = 0;
  92. #define OPTION_WITHZEROES 0x0001 /* withzeros */
  93. #define OPTION_UNKNASZERO 0x0002 /* unknaszero */
  94. #define OPTION_TRANSPARENT 0x0004 /* transparent */
  95. #define OPTION_DORELPERCENT 0x0008 /* dorelpercent */
  96. #define OPTION_NOBORDER 0x0010 /* noborder */
  97. #define OPTION_NOARROW 0x0020 /* noarrow */
  98. #define OPTION_NO_I 0x0040 /* ignore 'I' (first) variable */
  99. #define OPTION_NO_O 0x0080 /* ignore 'O' (second) variable */
  100. #define OPTION_PNGDATE 0x0100 /* show date & time in graph */
  101. #define OPTION_PRINTROUTER 0x0200 /* show title in graph */
  102. #define OPTION_LOGGRAPH 0x0400 /* Use a logarithmic Y axis */
  103. #define OPTION_MEANOVER 0x0800 /* max Y = mean-above-the-mean */
  105. time_t NOW;
  107. char *short_si[] = { "", "k", "M", "G", "T" };
  108. char *longup = NULL;
  109. char *shortup = NULL;
  110. char *pngtitle = NULL;
  111. char *pngdate = NULL;
  112. char *rtimezone = NULL;
  113. char weekformat = 'V'; /* strftime() fmt char for week #  */
  115. #define DAY_COUNT (600) /* 400 samples is 33.33 hours */
  116. #define DAY_SAMPLE (5*60) /* Sample every 5 minutes */
  117. #define WEEK_COUNT (600) /* 400 samples is 8.33 days */
  118. #define WEEK_SAMPLE (30*60) /* Sample every 30 minutes */
  119. #define MONTH_COUNT (600) /* 400 samples is 33.33 days */
  120. #define MONTH_SAMPLE (2*60*60) /* Sample every 2 hours */
  121. #define YEAR_COUNT  (2 * 366) /* 1 sample / day, 366 days, 2 years */
  122. #define YEAR_SAMPLE (24*60*60) /* Sample every 24 hours */
  124. /* One 'rounding error' per sample period, so add 4 to total and for 
  125.    good mesure we take 10 :-) */
  126. #define MAX_HISTORY (DAY_COUNT+WEEK_COUNT+MONTH_COUNT+YEAR_COUNT+10)
  128. /* These are the colors used for the variouse parts of the graph */
  129. /* the format is Red,Green,Blue */
  131. #define c_blank 245,245,245
  132. #define c_light 194,194,194
  133. #define c_dark 100,100,100
  134. #define c_major 255,0,0
  135. #define c_in    0,235,12
  136. #define c_out   0,94,255
  137. #define c_grid  0,0,0
  138. #define c_inm   0,166,33
  139. #define c_outm  255,0,255
  140. #define c_outp  239,159,79
  142. int col_in[3];
  143. int col_out[3];
  144. int col_inm[3];
  145. int col_outm[3];
  146. int col_outp[3];
  148. long long kilo = (long long) 1000;
  149. char *kMG = (char *) NULL;
  150. char *kMGcopy = (char *) NULL; /* JML bugfix */
  151. int kMGnumber = 0;
  153. #define MAXL 200 /* Maximum length of last in & out fields */
  156. struct HISTORY
  157. {
  158.   time_t time;
  159.   double in, out, percent, inmax, outmax;
  160. }
  161.  *history;
  162. int Mh;
  164. struct LAST
  165. {
  166.   time_t time;
  167.   char in[MAXL], out[MAXL];
  168. }
  169. last;
  171. #ifndef max
  172. #define max(a,b) ((a) > (b) ? (a) : (b))
  173. #endif
  174. #ifndef min
  175. #define min(a,b) ((a) < (b) ? (a) : (b))
  176. #endif
  178. /*
  180. notes about the NEXT macro ....
  182. * position n to the entry in the history array so that NOW is between
  183.   history[n] and history[n+1]
  185. * calculate the interval according to steptime and position of 
  186.   now within the history array.
  188. for debuging 
  190.     fprintf (stderr,"NOW: %8lu  ST: %4lu  N: %4u HTN: %8lu HTN+1: %8lu IV: %6.0fn", 
  191.             now,steptime,n,history[n].time, history[n+1].time, interval);
  193. */
  195. #define NEXT(steptime) 
  196.   inmax = outmax = avc = 0; 
  197.   inr = outr = 0.0;
  198.   nextnow = now - steptime;
  199.   if (now == history[n].time && 
  200.       n<histvalid && 
  201.       nextnow == history[n+1].time) { 
  202.     inr = (double) history[n].in;
  203.     outr = (double) history[n].out;
  204.     inmax = history[n].inmax;
  205.     outmax = history[n].outmax;
  206.     n++;
  207.   } else {
  208.     if (now > history[n].time) {
  209.       fprintf(stderr,"ERROR: Rateup is trying to read ahead of the available datan");
  210.     } else {
  211.       while (now <= history[n+1].time && n < histvalid){n++;}
  212.       do {
  213. if (now >= history[n].time) {
  214.   if (nextnow <= history[n+1].time) {
  215.     interval = history[n].time - history[n+1].time;
  216.   } else {
  217.     interval = history[n].time - nextnow;
  218.   }
  219. } else {
  220.   if (nextnow > history[n+1].time) {
  221.     interval = steptime;
  222.   } else {
  223.     interval = now - history[n+1].time;
  224.   }
  225. }
  226. inr  += (double) history[n].in * interval;
  227. outr += (double) history[n].out * interval;
  228. avc += interval;
  229.        inmax =  (long long) max(inmax, history[n].inmax);
  230.        outmax = (long long) max(outmax,history[n].outmax);
  231. if (nextnow <= history[n+1].time) n++; else break;
  232.       } while (n < histvalid && nextnow < history[n].time);
  234.       if (avc != steptime) {
  235.        fprintf(stderr,"ERROR: StepTime does not match Avc %8" LLD_FORMAT ". Please Report this.n", avc);
  236.       }
  238.       inr /= avc; outr /= avc;
  239.     }
  240.   }
  243. static void
  244. image (file, maxvi, maxvo, maxx, maxy, xscale, yscale, growright, step, bits,
  245.        ytics, yticsf, peak, currdatetimeformat, currdatetimepos)
  246.      char *file;
  247.      long long maxvi, maxvo;
  248.      long maxx;
  249.      long maxy, growright, step, bits;
  250.      double xscale, yscale;
  251.      int ytics; /* number of tics on the y axis */
  252.      double yticsf; /* scale everything on the y axis with this factor */
  253.      int peak;
  254.      char *currdatetimeformat;
  255.      int currdatetimepos;
  256. {
  257.   FILE *fo;
  258.   int i, x, n, type;
  260.   long long maxv;
  261.   double origmaxvi, origmaxvo;
  262.   long long maxs, avc, inmax, outmax;
  263.   long long ytrmax;
  264.   double y, lmx1, lmx2, mea1, mea2, temp;
  265.   double inr, outr, muli = 1, interval;
  266.   time_t now, onow, nextnow;
  267.   struct tm tm2, *tm = &tm2;
  268.   struct tm tm3, *tmtz = &tm3;
  269.   char **graph_label;
  270.   char ylab[30];
  271.   /* scaling helpers */
  272.   long long maxv_q;
  273.   long long valsamp, maxin, maxout, digits, maxpercent = 0;
  274.   long long sca_ten, sca_hun;
  275.   double nmax_q;
  276.   double avmxin, avmxout, avin, avout, latestout = 0, latestin =
  277.     0, nmax, avpercent = 0, latestpercent = 0;
  278.   double nex_ten, nex_hun, nex_rnd;
  279.   double sca_max_q, dummy;
  280.   double percent;
  281.   char *short_si_out;
  282.   char currdatetimestr[256];
  283.   time_t currdatetime;
  284.   int currdatetimepos_x, currdatetimepos_y;
  286. #define NO_TIMESTAMPSTR (0)
  287. #define LU_CORNER (1)
  288. #define RU_CORNER (2)
  289. #define LL_CORNER (3)
  290. #define RL_CORNER (4)
  293.   struct HISTORY *lhist;
  294.   /* ################################################# */
  295.   /* Some general definitions for the graph generation */
  296. #define XSIZE (long)((maxx*xscale)+100+((options & OPTION_DORELPERCENT) ? 1 : 0)*30)
  297. #define YSIZE (long)((maxy*yscale)+35)
  298.   /* position the graph */
  299. #define ytr(y) (long)(maxy*yscale+14-((y)*yscale))
  300.   /* translate x/y coord into graph coord */
  301. #define xtr(x) (long)((growright) ? (maxx*xscale+81-((x)*xscale)) : (81+((x)*xscale)))
  302.   /* ################################################# */
  306.   /* GD LIB declarations */
  307.   /* Declare the image */
  308.   gdImagePtr graph, brush_out, brush_outm, brush_outp;
  309.   /* Declare color indexes */
  310.   int i_light, i_dark, i_blank, i_major, i_in, i_out, i_grid, i_inm, i_outm;
  311.   int i_outp, i_outpg;
  312.   /* Dotted style */
  313.   int styleDotted[3];
  314.   if ((graph_label = (char **) calloc (1, sizeof (char *) * maxx)) == NULL)
  315.     {
  316.       fprintf (stderr, "Rateup ERROR: Out of memory in graph creationn");
  317.       exit (1);
  318.     }
  320.   /* multiplicator for bits/bytes */
  321.   if (bits) {
  322.       muli = 8;
  323.   }
  324.   
  325.   maxv = (long long) max (maxvi, maxvo);
  326.   maxv *= (long long) muli;
  327.   
  328.   origmaxvi = maxvi < (long long) 0 ? -maxvi : maxvi;
  329.   origmaxvo = maxvo < (long long) 0 ? -maxvo : maxvo;
  331.   if (step > MONTH_SAMPLE)
  332.     {
  333.       type = 4;
  334.       now = (long) (NOW / YEAR_SAMPLE) * YEAR_SAMPLE;
  336.     }
  337.   else if (step > WEEK_SAMPLE)
  338.     {
  339.       type = 3;
  340.       now = (long) (NOW / MONTH_SAMPLE) * MONTH_SAMPLE;
  341.     }
  342.   else if (step > DAY_SAMPLE)
  343.     {
  344.       type = 2;
  345.       now = (long) (NOW / WEEK_SAMPLE) * WEEK_SAMPLE;
  346.     }
  347.   else
  348.     {
  349.       type = 1;
  350.       now = (long) (NOW / DAY_SAMPLE) * DAY_SAMPLE;
  351.     }
  352.   if ((lhist = calloc (1, sizeof (struct HISTORY) * maxx)) == NULL)
  353.     {
  354.       fprintf (stderr, "Rateup ERROR: Out of memory in graph creationn");
  355.       exit (1);
  356.     }
  357.   onow = now;
  358.   avin = avout = avmxin = avmxout = 0.0;
  359.   inmax = outmax = maxin = maxout = 0;
  360.   valsamp = 0;
  361.   for (maxs = 0, n = 0, x = 0; x < maxx; x++)
  362.     {
  363.       NEXT (step);
  364.       /*scale with muli */
  365.       inr *= muli;
  366.       outr *= muli;
  367.       inmax *= muli;
  368.       outmax *= muli;
  369.       /* ignore times when we have not sampled */
  370.       if (inmax > 0 || outmax > 0 || inr > 0 || outr > 0
  371.   || (options & OPTION_WITHZEROES)) valsamp++;
  372.       if (x == 0)
  373. {
  374.   latestin = inr;
  375.   latestout = outr;
  376.   if (outr)
  377.     {
  378.       latestpercent = inr * (double) 100. / outr;
  379.     }
  380. }
  381.       avin += inr;
  382.       avout += outr;
  383.       avmxin += inmax;
  384.       avmxout += outmax;
  386.       if (peak)
  387. {
  388.   maxin = (long long) max (maxin, inmax);
  389.   maxout = (long long) max (maxout, outmax);
  390.   maxs = (long long) max (maxs, inmax);
  391.   maxs = (long long) max (maxs, outmax);
  392. }
  393.       else
  394. {
  395.   maxin = (long long) max (maxin, inr);
  396.   maxout = (long long) max (maxout, outr);
  397.   maxs = (long long) max (maxs, inr);
  398.   maxs = (long long) max (maxs, outr);
  399. }
  400.       if ((options & OPTION_DORELPERCENT) && outr)
  401. {
  402.   dummy = (double) 100. *inr / outr;
  403.   maxpercent = max (dummy, maxpercent);
  404. }
  405.       now -= step;
  406.     }
  407.   if (options & OPTION_DORELPERCENT)
  408.     {
  409.       if (avout && valsamp)
  410. {
  411.   avpercent = (double) 100. *avin / avout;
  412. }
  413.       else
  414. {
  415.   avpercent = 0;
  416. }
  417.     }
  418.   if (valsamp)
  419.     {
  420.       avin /= valsamp;
  421.       avout /= valsamp;
  422.       avmxin /= valsamp;
  423.       avmxout /= valsamp;
  424.     }
  426.   printf ("" LLD "n", (long long) (maxin / (long long) muli + .5));
  427.   printf ("" LLD "n", (long long) (maxout / (long long) muli + .5));
  428.   if (options & OPTION_DORELPERCENT)
  429.     {
  430.       printf ("" LLD "n", (long long) (maxpercent + .5));
  431.     }
  432.   printf ("" LLD "n", (long long) (avin / (long long) muli + .5));
  433.   printf ("" LLD "n", (long long) (avout / (long long) muli + .5));
  434.   if (options & OPTION_DORELPERCENT)
  435.     {
  436.       printf ("" LLD "n", (long long) (avpercent + .5));
  437.     }
  438.   printf ("" LLD "n", (long long) (latestin / (long long) muli + .5));
  439.   printf ("" LLD "n", (long long) (latestout / (long long) muli + .5));
  440.   if (options & OPTION_DORELPERCENT)
  441.     {
  442.       printf ("" LLD "n", (long long) (latestpercent + .5));
  443.     }
  444.   printf ("" LLD "n", (long long) (avmxin / (long long) muli + .5));
  445.   printf ("" LLD "n", (long long) (avmxout / (long long) muli + .5));
  447.   if (maxv < 0 || maxv < maxs)
  448.     {
  449.       maxv = maxs;
  450.     }
  452.   now = onow;
  454.   if (maxv <= 0)
  455.     maxv = 1;
  457.   if (kMG)
  458.     {
  459.       char *string = kMG;
  460.       kMGnumber = 0;
  461.       while (strchr (string, ','))
  462. {
  463.   string = strchr (string, ',') + 1;
  464.   kMGnumber++;
  465. }
  466.     }
  467.   else
  468.     {
  469.       kMGnumber = 4;
  470.     }
  472.   /* mangle the 0.25*maxv value so, that we get a number with either */
  473.   /* one or two digits != 0 and these digits should be at the  */
  474.   /* start of the number ... */
  476.   /* the ceil compensates for rounding with small numbers */
  477.   maxv_q = ceil ((double) maxv / (double) ytics); /* int */
  479.   digits = 0;
  480.   {
  481.     double number = (double) maxv_q;
  482.     number *= yticsf; /* we just want to scale the lables nothing else */
  484. /*
  485.        while (number/(double) kilo >= (double)kilo && digits<kMGnumber*3) {
  486. */
  487.     /* yes this should be kilo, but then the log and pow bits below
  488.        should be base 'kilo' as well and not base 10 */
  490.     while (number >= (double) 1000 && digits < (long long) kMGnumber * 3)
  491.       {
  492. number /= (double) 1000;
  493. digits += 3;
  494.       }
  495.     sca_max_q = (double) ((int) (((double) 100. * (double) number) /
  496.  (pow
  497.   ((double) 10.,
  498.    (double) (int) (log10 ((double) number))))
  499.  +
  500.  (double) 9.999) / (int) 10) / (double) 10 *
  501.       (pow ((double) 10., (double) (int) (log10 ((double) number))));
  502.   }
  504.   if (kMG)
  505.     {
  506.       int count = (int) digits;
  507.       short_si_out = kMGcopy; /* JML bugfix */
  508.       strcpy (kMGcopy, kMG); /* JML bugfix */
  509.       while (count >= 3)
  510. {
  511.   count -= 3;
  512.   short_si_out = strchr (short_si_out, ',') + 1;
  513. }
  514.       if (strchr (short_si_out, ','))
  515. {
  516.   *((char *) strchr (short_si_out, ',')) = '';
  517. }
  518.     }
  519.   else
  520.     {
  521.       short_si_out = short_si[min ((signed) (digits / 3), kMGnumber)];
  522.     }
  524.   if (maxv_q * yticsf >= 1)
  525.     {
  526. /*     digits = log10((double)maxv_q); */
  527.       digits = log10 ((double) maxv_q * yticsf);
  528.     }
  529.   else
  530.     {
  531.       digits = 0;
  532.     }
  534. /*  sca_ten = maxv_q / pow(10.0,(double)digits); */
  535. /*  sca_hun = maxv_q / pow(10.0,(double)digits-1); */
  536.   sca_ten = (double) maxv_q *yticsf / pow (10.0, (double) digits);
  537.   sca_hun = (double) maxv_q *yticsf / pow (10.0, (double) digits - 1);
  538.   nex_rnd = (sca_hun) * pow (10.0, (double) digits - 1);
  539.   nex_ten = (sca_ten + 1) * pow (10.0, (double) digits);
  540.   nex_hun = (sca_hun + 1) * pow (10.0, (double) digits - 1);
  542. /*  if (nex_ten <= (1.1 * maxv_q))  { */
  543.   if (nex_ten <= (1.1 * maxv_q * yticsf))
  544.     {
  545.       nmax_q = nex_ten;
  546. /*  } else if (maxv_q == nex_rnd) {  */
  547.     }
  548.   else if ((maxv_q * yticsf) == nex_rnd)
  549.     {
  550.       nmax_q = nex_rnd;
  551.     }
  552.   else
  553.     {
  554.       nmax_q = nex_hun;
  555.     }
  557.   sca_max_q = nmax_q / (pow (10.0, (double) ((int) (digits / 3)) * 3));
  558. /*  nmax=sca_max_q*ytics*(pow((double)kilo,(double)((int)(digits/3))));  */
  559.   nmax =
  560.     (sca_max_q / yticsf) * ytics *
  561.     (pow ((double) kilo, (double) ((int) (digits / 3))));
  563.   if (nmax < 1.)
  564.     {
  565.       nmax = 1.;
  566.     }
  568.   for (n = 0, x = 0; x < maxx; x++)
  569.     {
  570.       lhist[x].time = 0;
  571.       graph_label[x] = NULL;
  572.       /* this seesm to be necessary to work a round a bug in solaris
  573.          where tm for complex TZ settings gets modified after the
  574.          fact ... so we whisk the stuff away into our own memspace
  575.          just in time */
  576.       memcpy (tm, localtime (&history[n].time), sizeof (struct tm));
  577.       switch (type)
  578. {
  579. default:
  580. case 1:
  581.   if (tm->tm_min < 5)
  582.     {
  583.       lhist[x].time |= 1;
  584.       if (tm->tm_hour == 0)
  585. lhist[x].time |= 2;
  586.     }
  587.   if ((tm->tm_min < 5) && (tm->tm_hour % 2 == 0))
  588.     {
  589.       if ((graph_label[x] = calloc (1, sizeof (char) * 4)) == NULL)
  590. {
  591.   fprintf (stderr,
  592.    "Rateup ERROR: Out of memory in graph labelingn");
  593.   exit (0);
  594. }
  595.       else
  596. {
  597.   sprintf (graph_label[x], "%i", tm->tm_hour);
  598. }
  599.     }
  600.   break;
  601. case 2:
  602.   if (tm->tm_min < 30 && tm->tm_hour == 0)
  603.     {
  604.       lhist[x].time |= 1;
  605.       if (tm->tm_wday == 1)
  606. lhist[x].time |= 2;
  607.     }
  609.   /* fprintf(stderr,"x: %i, min:%i, hour:%i day: %in",
  610.      x,tm->tm_min,tm->tm_hour,tm->tm_wday); */
  611.   if ((tm->tm_min < 30) && (tm->tm_hour == 12))
  612.     {
  613.       if ((graph_label[x] = calloc (1, sizeof (char) * 5)) == NULL)
  614. {
  615.   fprintf (stderr,
  616.    "Rateup ERROR: Out of memory in graph labelingn");
  617.   exit (0);
  618. }
  619.       else
  620. {
  621.   strftime (graph_label[x], 4, "%a", tm);
  622. }
  623.     }
  625.   break;
  626. case 3:
  627.   if (tm->tm_hour < 2)
  628.     {
  629.       if (tm->tm_wday == 1)
  630. lhist[x].time |= 1;
  631.       if (tm->tm_mday == 1)
  632. lhist[x].time |= 2;
  633.     }
  634.   /* label goes to thursday noon */
  636.   if ((tm->tm_hour > 10) && (tm->tm_hour <= 12) && (tm->tm_wday == 4))
  637.     {
  638.       if ((graph_label[x] = calloc (1, sizeof (char) * 16)) == NULL)
  639. {
  640.   fprintf (stderr,
  641.    "Rateup ERROR: Out of memory in graph labelingn");
  642.   exit (0);
  643. }
  644.       else
  645. {
  646.   char fmtbuf[10];
  647.   sprintf (fmtbuf, "Week %%%c", weekformat);
  648.   strftime (graph_label[x], 8, fmtbuf, tm);
  649. }
  650.     }
  651.   break;
  652. case 4:
  653.   if (tm->tm_mday == 1)
  654.     lhist[x].time |= 1;
  655.   if (tm->tm_yday == 0)
  656.     lhist[x].time |= 2;
  659.   if (tm->tm_mday == 15)
  660.     {
  661.       if ((graph_label[x] = calloc (1, sizeof (char) * 5)) == NULL)
  662. {
  663.   fprintf (stderr,
  664.    "Rateup Error: Out of memory in graph labelingn");
  665.   exit (0);
  666. }
  667.       else
  668. {
  669.   strftime (graph_label[x], 4, "%b", tm);
  670. }
  671.     }
  672.   break;
  673. }
  675.       NEXT (step);
  677.       /*scale with muli */
  678.       inr *= muli;
  679.       outr *= muli;
  680.       inmax *= muli;
  681.       outmax *= muli;
  684.       y = ((double) inr / nmax) * maxy;
  685.       if (y >= maxy)
  686. y = maxy;
  687.       lhist[x].in = y;
  689.       y = ((double) outr / nmax) * maxy;
  690.       if (y >= maxy)
  691. y = maxy;
  692.       lhist[x].out = y;
  694.       y = ((double) inmax / nmax) * maxy;
  695.       if (y >= maxy)
  696. y = maxy;
  697.       lhist[x].inmax = y;
  699.       y = ((double) outmax / nmax) * maxy;
  700.       if (y >= maxy)
  701. y = maxy;
  702.       lhist[x].outmax = y;
  704.       if (options & OPTION_DORELPERCENT)
  705. {
  706.   if (outr != (long long) 0)
  707.     {
  708.       percent = (double) inr / (double) outr;
  709.     }
  710.   else
  711.     {
  712.       percent = (double) 0.;
  713.     }
  714.   if (percent > (double) 1)
  715.     percent = (double) 1.;
  716.   percent *= maxy;
  717.   lhist[x].percent = (long long) percent;
  718. }
  719.       else
  720. {
  721.   lhist[x].percent = (long long) 0;
  722. }
  724.       now -= step;
  725.     }
  726.   origmaxvi = (origmaxvi * muli / nmax ) * maxy;
  727.   origmaxvo = (origmaxvo * muli / nmax ) * maxy;
  729.   /* Log and second-mean scaling added by Benjamin Despres, 2004-10-13 */
  730.   if ((options & OPTION_LOGGRAPH) || (options & OPTION_MEANOVER))
  731.     {
  732.       lmx1 = lmx2 = mea1 = mea2 = temp = 0.0;
  733.       for (x = 0; x < maxx; x++)
  734. {
  735.   if (lhist[x].in < 1.0)
  736.     lhist[x].in = 1.0;
  737.   if (lhist[x].out < 1.0)
  738.     lhist[x].out = 1.0;
  739.   if (lhist[x].inmax < 1.0)
  740.     lhist[x].inmax = 1.0;
  741.   if (lhist[x].outmax < 1.0)
  742.     lhist[x].outmax = 1.0;
  743.   if (lhist[x].in > lmx1)
  744.     lmx1 = lhist[x].in;
  745.   if (lhist[x].out > lmx1)
  746.     lmx1 = lhist[x].out;
  747.   if (lhist[x].inmax > lmx1)
  748.     lmx1 = lhist[x].inmax;
  749.   if (lhist[x].outmax > lmx1)
  750.     lmx1 = lhist[x].outmax;
  751.   mea1 +=
  752.     (lhist[x].in + lhist[x].out + lhist[x].inmax +
  753.      lhist[x].outmax) / 4.0;
  754. }
  755.       if (origmaxvi < 1.0)
  756. origmaxvi = 1.0;
  757.       if (origmaxvo < 1.0)
  758. origmaxvo = 1.0;
  760.       mea1 /= (double) maxx;
  761.       if (options & OPTION_MEANOVER)
  762. {
  763.   for (x = 0; x < maxx; x++)
  764.     {
  765.       y =
  766. (lhist[x].in + lhist[x].out + lhist[x].inmax +
  767.  lhist[x].outmax) / 4.0;
  768.       if (y > mea1)
  769. {
  770.   mea2 += y;
  771.   temp += 1.0;
  772. }
  773.     }
  774.   mea2 /= temp;
  775.   for (x = 0; x < maxx; x++)
  776.     {
  777.       if (lhist[x].in > mea2)
  778. lhist[x].in = mea2;
  779.       if (lhist[x].out > mea2)
  780. lhist[x].out = mea2;
  781.       if (lhist[x].inmax > mea2)
  782. lhist[x].inmax = mea2;
  783.       if (lhist[x].outmax > mea2)
  784. lhist[x].outmax = mea2;
  785.     }
  786. }
  787.       if (options & OPTION_LOGGRAPH)
  788. {
  789.   for (x = 0; x < maxx; x++)
  790.     {
  791.       lhist[x].in = log (lhist[x].in);
  792.       lhist[x].out = log (lhist[x].out);
  793.       lhist[x].inmax = log (lhist[x].inmax);
  794.       lhist[x].outmax = log (lhist[x].outmax);
  795.     }
  796.   origmaxvi = log (origmaxvi);
  797.   origmaxvo = log (origmaxvo);
  798. }
  799.       for (x = 0; x < maxx; x++)
  800. {
  801.   if (lhist[x].in > lmx2)
  802.     lmx2 = lhist[x].in;
  803.   if (lhist[x].out > lmx2)
  804.     lmx2 = lhist[x].out;
  805.   if (lhist[x].inmax > lmx2)
  806.     lmx2 = lhist[x].inmax;
  807.   if (lhist[x].outmax > lmx2)
  808.     lmx2 = lhist[x].outmax;
  809. }
  810.       if (lmx2 > 0.0)
  811. lmx2 = (lmx1 / lmx2);
  812.       for (x = 0; x < maxx; x++)
  813. {
  814.   lhist[x].in *= lmx2;
  815.   lhist[x].out *= lmx2;
  816.   lhist[x].inmax *= lmx2;
  817.   lhist[x].outmax *= lmx2;
  818. }
  819.       origmaxvi *= lmx2;
  820.       origmaxvo *= lmx2;
  822.       if (options & OPTION_MEANOVER)
  823. sca_max_q *= ((float) mea2 / (float) maxy);
  824.     } /* end of primary log and second-mean scaling code (more below) */
  826.   /* the graph is made ten pixels higher to acomodate the x labels */
  827.   graph = gdImageCreate (XSIZE, YSIZE);
  828.   brush_out = gdImageCreate (1, 2);
  829.   brush_outm = gdImageCreate (1, 2);
  830.   brush_outp = gdImageCreate (1, 2);
  832.   /* the first color allocated will be the background color. */
  833.   i_blank = gdImageColorAllocate (graph, c_blank);
  834.   i_light = gdImageColorAllocate (graph, c_light);
  835.   i_dark = gdImageColorAllocate (graph, c_dark);
  837.   if (options & OPTION_TRANSPARENT)
  838.     {
  839.       gdImageColorTransparent (graph, i_blank);
  840.     }
  841.   gdImageInterlace (graph, 1);
  843.   /* do NOT delete the out variables. they are dummies, but the actual color
  844.      allocation for the brush is essential */
  845.   i_major = gdImageColorAllocate (graph, c_major);
  846.   i_in = gdImageColorAllocate (graph, col_in[0], col_in[1], col_in[2]);
  847.   i_out =
  848.     gdImageColorAllocate (brush_out, col_out[0], col_out[1], col_out[2]);
  849.   i_grid = gdImageColorAllocate (graph, c_grid);
  850.   i_inm = gdImageColorAllocate (graph, col_inm[0], col_inm[1], col_inm[2]);
  851.   i_outm =
  852.     gdImageColorAllocate (brush_outm, col_outm[0], col_outm[1], col_outm[2]);
  853.   i_outp =
  854.     gdImageColorAllocate (brush_outp, col_outp[0], col_outp[1], col_outp[2]);
  855.   i_outpg =
  856.     gdImageColorAllocate (graph, col_outp[0], col_outp[1], col_outp[2]);
  858.   /* draw the image border */
  859.   if (!(options & OPTION_NOBORDER))
  860.     {
  861.       gdImageLine (graph, 0, 0, XSIZE - 1, 0, i_light);
  862.       gdImageLine (graph, 1, 1, XSIZE - 2, 1, i_light);
  863.       gdImageLine (graph, 0, 0, 0, YSIZE - 1, i_light);
  864.       gdImageLine (graph, 1, 1, 1, YSIZE - 2, i_light);
  865.       gdImageLine (graph, XSIZE - 1, 0, XSIZE - 1, YSIZE - 1, i_dark);
  866.       gdImageLine (graph, 0, YSIZE - 1, XSIZE - 1, YSIZE - 1, i_dark);
  867.       gdImageLine (graph, XSIZE - 2, 1, XSIZE - 2, YSIZE - 2, i_dark);
  868.       gdImageLine (graph, 1, YSIZE - 2, XSIZE - 2, YSIZE - 2, i_dark);
  869.     }
  871.   /* draw the incoming traffic */
  872.   if (!(options & OPTION_NO_I))
  873.     {
  874.       for (x = 0; x < maxx; x++)
  875. {
  876.   /* peak is always above average, we therefore only draw the upper part */
  877.   if (peak)
  878.     gdImageLine (graph, xtr (x), ytr (lhist[x].in),
  879.  xtr (x), ytr (lhist[x].inmax), i_inm);
  880. #ifdef INCOMING_UNFILLED
  881.   gdImageLine (graph, xtr (x), ytr (lhist[x].in), xtr (x),
  882.        ytr (lhist[x + 1].in), i_in);
  883. #else
  884.   gdImageLine (graph, xtr (x), ytr (0), xtr (x), ytr (lhist[x].in),
  885.        i_in);
  886.   /* draw the line a second time offset slightly. makes the graph
  887.    * look better if xscale is fractional */
  888.   gdImageLine (graph, xtr (x + 0.5), ytr (0), xtr (x + 0.5),
  889.        ytr (lhist[x].in), i_in);
  890. #endif
  891. }
  892.     }
  894.   /* draw the percentage */
  895.   if (options & OPTION_DORELPERCENT)
  896.     {
  897.       gdImageSetBrush (graph, brush_outp);
  898.       for (x = 0; x < maxx - 1; x++)
  899. gdImageLine (graph, xtr (x), ytr (lhist[x].percent),
  900.      xtr (x + 1), ytr (lhist[x + 1].percent), gdBrushed);
  901.     }
  903.   /* draw the outgoing traffic */
  904.   if (!(options & OPTION_NO_O))
  905.     {
  906.       gdImageSetBrush (graph, brush_outm);
  907.       if (peak)
  908. for (x = 0; x < maxx - 1; x++)
  909.   gdImageLine (graph, xtr (x), ytr (lhist[x].outmax),
  910.        xtr (x + 1), ytr (lhist[x + 1].outmax), gdBrushed);
  911.       gdImageSetBrush (graph, brush_out);
  912.       for (x = 0; x < maxx - 1; x++)
  913. gdImageLine (graph, xtr (x), ytr (lhist[x].out),
  914.      xtr (x + 1), ytr (lhist[x + 1].out), gdBrushed);
  915.     }
  917.   /* print the graph title */
  918.   if (pngtitle != NULL)
  919.     {
  920.       gdImageString (graph, gdFontSmall, 81, 1,
  921.      (unsigned char *) pngtitle, i_grid);
  922.     }
  923.   else
  924.     {
  925.       if (options & OPTION_PRINTROUTER)
  926. {
  927.   gdImageString (graph, gdFontSmall, 81, 1,
  928.  (unsigned char *) router, i_grid);
  929. }
  930.     }
  932.   /* print the date & time */
  933.   if (options & OPTION_PNGDATE)
  934.     {
  935.       pngdate = (char *) calloc (1, 100);
  936.       tmtz = localtime (&NOW);
  937.       if (rtimezone == NULL)
  938. {
  939.   strftime (pngdate, 18, "%b %d %Y %H:%M", tmtz);
  940. }
  941.       else
  942. {
  943.   strftime (pngdate, 19, "%b %d %Y %H:%M ", tmtz);
  944.   if (((size_t) strlen (pngdate) + strlen (rtimezone)) < 100)
  945.     {
  946.       strcat (pngdate, rtimezone);
  947.     }
  948.   else
  949.     {
  950.       fprintf (stderr,
  951.        "Rateup ERROR: date + timezone string too longn");
  952.       exit (1);
  953.     }
  955. }
  956.       gdImageString (graph, gdFontSmall,
  957.      (81 + maxx * xscale) - gdFontSmall->w * strlen (pngdate),
  958.      1, (unsigned char *) pngdate, i_grid);
  959.     }
  961.   /* draw the graph border */
  962.   gdImageRectangle (graph, xtr (0), ytr (0), xtr (maxx), ytr (maxy), i_grid);
  964.   /*create a dotted style for the grid lines */
  965.   styleDotted[0] = i_grid;
  966.   styleDotted[1] = gdTransparent;
  967.   styleDotted[2] = gdTransparent;
  968.   gdImageSetStyle (graph, styleDotted, 3);
  970.   /* draw the horizontal grid */
  971.   if ((longup == NULL) || (shortup == NULL))
  972.     {
  973.       if (!bits)
  974. {
  975.   longup = "Bytes per Second";
  976.   shortup = "Bytes/s";
  977. }
  978.       else
  979. {
  980.   longup = "Bits per Second";
  981.   shortup = "Bits/s";
  982. }
  983.     }
  984.   if (maxy < gdFontSmall->w * 16)
  985.     {
  986.       gdImageStringUp (graph, gdFontSmall, 8,
  987.        ytr ((maxy - gdFontSmall->w * strlen (shortup)) / 2),
  988.        (unsigned char *) shortup, i_grid);
  989.     }
  990.   else
  991.     {
  992.       gdImageStringUp (graph, gdFontSmall, 8,
  993.        ytr ((maxy - gdFontSmall->w * strlen (longup)) / 2),
  994.        (unsigned char *) longup, i_grid);
  995.     }
  997.   /* secondary log and second-mean scale code block follows */
  998.   if (options & OPTION_LOGGRAPH)
  999.     {
  1000.       for (i = 0; i <= ytics; i++)
  1001. {
  1002.   gdImageLine (graph, xtr (-2), ytr (i * maxy / ytics), xtr (1),
  1003.        ytr (i * maxy / ytics), i_grid);
  1004.   gdImageLine (graph, xtr (maxx + 2), ytr (i * maxy / ytics),
  1005.        xtr (maxx - 1), ytr (i * maxy / ytics), i_grid);
  1006.   gdImageLine (graph, xtr (0), ytr (i * maxy / ytics), xtr (maxx),
  1007.        ytr (i * maxy / ytics), gdStyled);
  1008.   temp = exp ((log ((float) maxy) / (float) ytics) * (float) i) - 1.0;
  1009.   temp *= ((float) sca_max_q * (float) ytics) / (float) maxy;
  1010.   sprintf (ylab, "%6.1f %s", temp, short_si_out);
  1011.   gdImageString (graph, gdFontSmall, 23,
  1012.  ytr (i * maxy / ytics + gdFontSmall->h / 2),
  1013.  (unsigned char *) ylab, i_grid);
  1014.   if (options & OPTION_DORELPERCENT)
  1015.     {
  1016.       sprintf (ylab, "% 6.1f%%", (float) 100 / ytics * i);
  1017.       gdImageString (graph, gdFontSmall, 77 + ((maxx) * xscale) + 1,
  1018.      ytr (i * maxy / ytics + gdFontSmall->h / 2),
  1019.      (unsigned char *) ylab, i_outpg);
  1020.     }
  1021. }
  1022.     }
  1023.   else /* end of secondary log and second-mean scaling code */
  1024.     {
  1025.       for (i = 0; i <= ytics; i++)
  1026. {
  1028.   gdImageLine (graph, xtr (-2), ytr (i * maxy / ytics),
  1029.        xtr (1), ytr (i * maxy / ytics), i_grid);
  1031.   gdImageLine (graph, xtr (maxx + 2), ytr (i * maxy / ytics),
  1032.        xtr (maxx - 1), ytr (i * maxy / ytics), i_grid);
  1034.   gdImageLine (graph, xtr (0), ytr (i * maxy / ytics),
  1035.        xtr (maxx), ytr (i * maxy / ytics), gdStyled);
  1037. /*
  1038.      sprintf(ylab,"%6.1f %s",sca_max_q*i,short_si[digits/3]);
  1039. */
  1040. /*     sprintf(ylab,"%6.1f %s",sca_max_q*i*yticsf,short_si_out);  */
  1041.   sprintf (ylab, "%6.1f %s", sca_max_q * i, short_si_out);
  1043. /*        sprintf(ylab,"%6.1f %s",sca_max_q*i,short_si_out); */
  1044.   gdImageString (graph, gdFontSmall, 23,
  1045.  ytr (i * maxy / ytics + gdFontSmall->h / 2),
  1046.  (unsigned char *) ylab, i_grid);
  1048.   if (options & OPTION_DORELPERCENT)
  1049.     {
  1050.       /* sprintf(ylab,"% 6.1f%%",(float)25.*i); */
  1051.       sprintf (ylab, "% 6.1f%%", (float) 100 / ytics * i);
  1052.       gdImageString (graph, gdFontSmall, 77 + ((maxx) * xscale) + 1,
  1053.      ytr (i * maxy / ytics + gdFontSmall->h / 2),
  1054.      (unsigned char *) ylab, i_outpg);
  1055.     }
  1056. }
  1057.     }
  1059.   /* draw vertical grid and horizontal labels */
  1060.   for (x = 0; x < maxx; x++)
  1061.     {
  1062.       if (lhist[x].time)
  1063. {
  1064.   gdImageLine (graph, xtr (x), ytr (-2), xtr (x), ytr (1), i_grid);
  1065.   gdImageLine (graph, xtr (x), ytr (0), xtr (x), ytr (maxy),
  1066.        gdStyled);
  1067. }
  1068.       if (graph_label[x] != NULL)
  1069. {
  1070.   gdImageString (graph, gdFontSmall,
  1071.  (xtr (x) - (strlen (graph_label[x]) *
  1072.      gdFontSmall->w / 2)),
  1073.  ytr (-4), (unsigned char *) graph_label[x], i_grid);
  1074.   free (graph_label[x]);
  1075. }
  1076.       if (lhist[x].time & 2)
  1077. gdImageLine (graph, xtr (x), ytr (0), xtr (x), ytr (maxy), i_major);
  1078.     }
  1080.   ytrmax = ytr (origmaxvi);
  1082.   /* draw line at peak In value in i_major color */
  1083.   /* only draw the line if it's within the graph ... */
  1084.   if (ytr (maxy) < ytrmax)
  1085.     {
  1086.       styleDotted[0] = i_major;
  1087.       gdImageSetStyle (graph, styleDotted, 3);
  1088.       gdImageLine (graph, xtr (0), ytrmax, xtr (maxx), ytrmax, gdStyled);
  1089.     }
  1091.   /* draw line at peak Out value in i_major color */
  1092.   /* only draw the line if it's within the graph ... */
  1093.   ytrmax = ytr (origmaxvo);
  1095.   if (ytr (maxy) < ytrmax)
  1096.     {
  1097.       styleDotted[0] = i_major;
  1098.       gdImageSetStyle (graph, styleDotted, 3);
  1099.       gdImageLine (graph, xtr (0), ytrmax, xtr (maxx), ytrmax, gdStyled);
  1100.     }
  1102.   /* draw a red arrow a 0,0 */
  1103.   if (!(options & OPTION_NOARROW))
  1104.     {
  1105.       gdImageLine (graph, xtr (2), ytr (3), xtr (2), ytr (-3), i_major);
  1106.       gdImageLine (graph, xtr (1), ytr (3), xtr (1), ytr (-3), i_major);
  1107.       gdImageLine (graph, xtr (0), ytr (2), xtr (0), ytr (-2), i_major);
  1108.       gdImageLine (graph, xtr (-1), ytr (1), xtr (-1), ytr (-1), i_major);
  1109.       gdImageLine (graph, xtr (-2), ytr (1), xtr (-2), ytr (-1), i_major);
  1110.       gdImageLine (graph, xtr (-3), ytr (0), xtr (-3), ytr (0), i_major);
  1111.     }
  1113.   if (currdatetimepos > NO_TIMESTAMPSTR)
  1114.     {
  1115.       currdatetime = time (NULL);
  1116.       strftime (currdatetimestr, 250, currdatetimeformat,
  1117. localtime (&currdatetime));
  1118.       switch (currdatetimepos)
  1119. {
  1120. case LL_CORNER:
  1121.   currdatetimepos_x = 3;
  1122.   currdatetimepos_y = YSIZE - gdFontSmall->h - 3;
  1123.   break;
  1124. case RL_CORNER:
  1125.   currdatetimepos_x =
  1126.     XSIZE - strlen (currdatetimestr) * gdFontSmall->w - 3;
  1127.   currdatetimepos_y = YSIZE - gdFontSmall->h - 3;
  1128.   break;
  1129. case LU_CORNER:
  1130.   currdatetimepos_x = 3;
  1131.   currdatetimepos_y = 1;
  1132.   break;
  1133. case RU_CORNER:
  1134. default:
  1135.   currdatetimepos_x =
  1136.     XSIZE - strlen (currdatetimestr) * gdFontSmall->w - 3;
  1137.   currdatetimepos_y = 1;
  1138. };
  1139.       gdImageString (graph, gdFontSmall,
  1140.      currdatetimepos_x, currdatetimepos_y,
  1141.      currdatetimestr, i_grid);
  1142.     }
  1144.   if ((fo = fopen (file, "wb")) == NULL)
  1145.     {
  1146.       perror (program);
  1147.       fprintf (stderr, "Rateup Error: Can't open %s for writen", file);
  1148.       exit (1);
  1149.     }
  1150.   GFORM_GD (graph, fo);
  1151.   fclose (fo);
  1152.   gdImageDestroy (graph);
  1153.   gdImageDestroy (brush_out);
  1154.   gdImageDestroy (brush_outm);
  1155.   gdImageDestroy (brush_outp);
  1156.   free (lhist);
  1157.   free (graph_label);
  1159. }
  1162. static double
  1163. diff (a, b)
  1164.      char *a, *b;
  1165. {
  1166.   char res[MAXL], *a1, *b1, *r1;
  1167.   int c, x, m;
  1168.   if (*a == '-' && *b == '-')
  1169.     {
  1170.       b1 = b + 1;
  1171.       b = a + 1;
  1172.       a = b1;
  1173.     }
  1175.   while (!isdigit ((int) *a))
  1176.     a++;
  1177.   while (!isdigit ((int) *b))
  1178.     b++;
  1179.   a1 = &a[strlen (a) - 1];
  1180.   m = max (strlen (a), strlen (b));
  1181.   r1 = &res[m + 1];
  1182.   for (b1 = res; b1 <= r1; b1++)
  1183.     *b1 = ' ';
  1184.   b1 = &b[strlen (b) - 1];
  1185.   r1[1] = 0; /* Null terminate result */
  1186.   c = 0;
  1187.   for (x = 0; x < m; x++)
  1188.     {
  1189.       /* we want to avoid reading off the edge of the string */
  1190.       char save_a, save_b;
  1191.       save_a = (a1 >= a) ? *a1 : '0';
  1192.       save_b = (b1 >= b) ? *b1 : '0';
  1193.       *r1 = save_a - save_b - c + '0';
  1194.       if (*r1 < '0')
  1195. {
  1196.   *r1 += 10;
  1197.   c = 1;
  1198. }
  1199.       else if (*r1 > '9')
  1200. { /* 0 - 10 */
  1201.   *r1 -= 10;
  1202.   c = 1;
  1203. }
  1204.       else
  1205. {
  1206.   c = 0;
  1207. }
  1208.       a1--;
  1209.       b1--;
  1210.       r1--;
  1211.     }
  1212.   if (c)
  1213.     {
  1214.       r1 = &res[m + 1];
  1215.       for (x = 0; isdigit ((int) *r1) && x < m; x++, r1--)
  1216. {
  1217.   *r1 = ('9' - *r1 + c) + '0';
  1218.   if (*r1 > '9')
  1219.     {
  1220.       *r1 -= 10;
  1221.       c = 1;
  1222.     }
  1223.   else
  1224.     {
  1225.       c = 0;
  1226.     }
  1227. }
  1228.       return (-atof (res));
  1229.     }
  1230.   else
  1231.     return (atof (res));
  1232. }
  1234. static int
  1235. readhist (file)
  1236.      char *file;
  1237. {
  1238.   FILE *fi;
  1239.   int x, retcode = 0;
  1240.   char buf[256], tempform[50];
  1241.   struct HISTORY *hist;
  1242.   long long rd[5];
  1243.   time_t cur;
  1244.   long lasttime;
  1246.   sprintf (tempform, "%%ld %%%ds %%%dsn", MAXL - 1, MAXL - 1);
  1247.   if ((fi = fopen (file, "r")) != NULL)
  1248.     {
  1249.       if (fscanf (fi, tempform, &lasttime, &last.in[0], &last.out[0]) != 3)
  1250. {
  1251.   fprintf (stderr, "Read Error: File %s lin 1n", file);
  1252.   retcode = 1;
  1253. }
  1254.       last.time = lasttime;
  1255.       cur = last.time;
  1256.       x = histvalid = 0;
  1257.       hist = history;
  1258.       while (!feof (fi))
  1259. {
  1260.   fgets (buf, 256, fi);
  1261.   if (sscanf (buf, "" LLD " " LLD " " LLD " " LLD " " LLD "",
  1262.       &rd[0], &rd[1], &rd[2], &rd[3], &rd[4]) < 5)
  1263.     {
  1264.       rd[3] = rd[1];
  1265.       rd[4] = rd[2];
  1266.     }
  1268. /* we are long long now, so don't cut bit 8
  1269.     for (i=0;i<=4;i++){
  1270.       if (rd[i] & 0x80000000)
  1271. rd[i] = 0;
  1272.     }
  1273. */
  1275.   hist->time = rd[0];
  1276.   hist->in = rd[1];
  1277.   hist->out = rd[2];
  1278.   hist->inmax = rd[3];
  1279.   hist->outmax = rd[4];
  1280.   if (hist->inmax < hist->in)
  1281.     hist->inmax = hist->in;
  1282.   if (hist->outmax < hist->out)
  1283.     hist->outmax = hist->out;
  1284.   if (hist->time > cur)
  1285.     {
  1286.       fprintf (stderr,
  1287.        "Rateup ERROR: %s found %s's log file was corruptn          or not in sorted order:ntime: %lu.",
  1288.        program, router, (unsigned long) hist->time);
  1289.       retcode = 2;
  1290.       break;
  1291.     }
  1292.   cur = hist->time;
  1293.   if (++x >= Mh)
  1294.     {
  1295.       struct HISTORY *lh;
  1297.       Mh += MAX_HISTORY;
  1298.       lh = realloc (history, (Mh + 1) * sizeof (struct HISTORY));
  1299.       if (lh == NULL)
  1300. {
  1301.   fprintf (stderr,
  1302.    "Rateup WARNING: (pay attention to this)nWARNING: %s found %s's log file had too many entries, data discardedn",
  1303.    program, router);
  1304.   break;
  1305. }
  1306.       hist = lh + (hist - history);
  1307.       history = lh;
  1308.     }
  1309.   hist++;
  1310. }
  1311.       histvalid = x;
  1312.       fclose (fi);
  1313.     }
  1314.   else
  1315.     {
  1316.       retcode = 1;
  1317.     }
  1318.   return (retcode);
  1319. }
  1321. static void
  1322. readfile ()
  1323. {
  1324.   char buf[128];
  1325.   int err, x;
  1326.   time_t now;
  1327.   struct HISTORY *hist;
  1329.   sprintf (buf, "%s.log", router);
  1330.   if ((err = readhist (buf)) != 0)
  1331.     { /* Read of log file failed.  Try backup */
  1332.       fprintf (stderr,
  1333.        "Rateup WARNING: %s could not read the primary log file for %sn",
  1334.        program, router);
  1335.       sprintf (buf, "%s.old", router);
  1336.       if ((err = readhist (buf)) != 0)
  1337. { /* Backup failed too. New file? */
  1338.   fprintf (stderr,
  1339.    "Rateup WARNING: %s The backup log file for %s was invalid as welln",
  1340.    program, router);
  1341.   if (err == 2)
  1342.     exit (1);
  1344.   /* File does not exist - it must be created */
  1345.   now = NOW - DAY_SAMPLE;
  1346.   hist = history;
  1347.   histvalid = DAY_COUNT + WEEK_COUNT + MONTH_COUNT + YEAR_COUNT - 1;
  1348.   last.time = now;
  1349.   /* calculating a diff does not make sense */
  1350.   last.in[0] = 'x';
  1351.   now /= DAY_SAMPLE;
  1352.   now *= DAY_SAMPLE;
  1353.   for (x = 0; x < DAY_COUNT; x++, hist++)
  1354.     {
  1355.       hist->time = now;
  1356.       hist->in = hist->inmax = hist->out = hist->outmax = 0;
  1357.       now -= DAY_SAMPLE;
  1358.     }
  1359.   now /= WEEK_SAMPLE;
  1360.   now *= WEEK_SAMPLE;
  1361.   for (x = 0; x < WEEK_COUNT; x++, hist++)
  1362.     {
  1363.       hist->time = now;
  1364.       hist->in = hist->inmax = hist->out = hist->outmax = 0;
  1365.       now -= WEEK_SAMPLE;
  1366.     }
  1367.   now /= MONTH_SAMPLE;
  1368.   now *= MONTH_SAMPLE;
  1369.   for (x = 0; x < MONTH_COUNT; x++, hist++)
  1370.     {
  1371.       hist->time = now;
  1372.       hist->in = hist->inmax = hist->out = hist->outmax = 0;
  1373.       now -= MONTH_SAMPLE;
  1374.     }
  1375.   now /= YEAR_SAMPLE;
  1376.   now *= YEAR_SAMPLE;
  1377.   for (x = 0; x < YEAR_COUNT; x++, hist++)
  1378.     {
  1379.       hist->time = now;
  1380.       hist->in = hist->inmax = hist->out = hist->outmax = 0;
  1381.       now -= YEAR_SAMPLE;
  1382.     }
  1383. }
  1384.     }
  1385. }
  1387. static void
  1388. update (in, out, abs_max, absupdate)
  1389.      char *in, *out;
  1390.      long long abs_max;
  1391.      int absupdate;
  1392. {
  1393.   FILE *fo;
  1394.   char buf[128], buf1[128], buf2[128];
  1395.   time_t now, nextnow, plannow;
  1396.   long long inrate, outrate;
  1397.   long long avc, inmax, outmax;
  1398.   double period, interval;
  1399.   int x, n, nout;
  1400.   struct HISTORY *lhist, *hist;
  1401.   double inr, outr;
  1403.   now = NOW;
  1405.   if (now < last.time)
  1406.     {
  1407.       fprintf (stderr,
  1408.        "Rateup ERROR: %s found that %s's log file time of %lu was greater than now (%lu)nERROR: Let's not do the time warp, again. Logfile unchanged.n",
  1409.        program, router, (unsigned long) last.time,
  1410.        (unsigned long) now);
  1411.       return;
  1412.     }
  1413.   sprintf (buf, "%s.tmp", router);
  1414.   sprintf (buf1, "%s.log", router);
  1415.   sprintf (buf2, "%s.old", router);
  1416.   if ((lhist = calloc (1, sizeof (struct HISTORY) * (MAX_HISTORY + 1))) ==
  1417.       NULL)
  1418.     {
  1419.       fprintf (stderr, "Rateup ERROR: Out of memory in updaten");
  1420.       exit (1);
  1421.     }
  1422.   hist = lhist;
  1424.   period = (now - last.time);
  1425.   if (period <= 0 || period > (60 * 60) || last.in[0] == 'x')
  1426.     { /* if last update is strange */
  1427.       if (options & OPTION_UNKNASZERO)
  1428. {
  1429.   inrate = 0; /* sync unknown to zero */
  1430.   outrate = 0;
  1431. }
  1432.       else
  1433. {
  1434.   inrate = history[0].in; /* Sync by using last value */
  1435.   outrate = history[0].out;
  1436. }
  1437.     }
  1438.   else
  1439.     {
  1440.       /* gauge and absolute */
  1441.       if (strcmp (in, "-1") == 0 || /* if current count missing */
  1442.   strcmp (last.in, "-1") == 0)
  1443. { /* or previous count missing */
  1444.   if (options & OPTION_UNKNASZERO)
  1445.     { /* then use 0 or last value */
  1446.       inrate = 0;
  1447.     }
  1448.   else
  1449.     {
  1450.       inrate = history[0].in;
  1451.     }
  1452. }
  1453.       else
  1454. {
  1455.   if ((absupdate != 0) && (absupdate != 3) && (absupdate != 4))
  1456.     {
  1457.       inr = diff (in, "0");
  1458.     }
  1459.   else
  1460.     {
  1461.       inr = diff (in, last.in);
  1462.       if (inr < 0) /* wrapped 32-bit counter? */
  1463. inr += (long long) 1 << 32;
  1464.     }
  1465.   if (absupdate == 2)
  1466.     {
  1467.       inrate = inr + .5;
  1468.     }
  1469.   else if (absupdate == 3)
  1470.     {
  1471.       inrate = inr * (3600.0 / (period * 1.0)) + .5;
  1472.     }
  1473.   else if (absupdate == 4)
  1474.     {
  1475.       inrate = inr * (60.0 / (period * 1.0)) + .5;
  1476.     }
  1477.   else
  1478.     {
  1479.       inrate = inr / period + .5;
  1480.     }
  1481. }
  1482.       if (strcmp (out, "-1") == 0 || /* if current count missing */
  1483.   strcmp (last.out, "-1") == 0)
  1484. { /* or previous count missing */
  1485.   if (options & OPTION_UNKNASZERO)
  1486.     { /* then use 0 or last value */
  1487.       outrate = 0;
  1488.     }
  1489.   else
  1490.     {
  1491.       outrate = history[0].out;
  1492.     }
  1493. }
  1494.       else
  1495. {
  1496.   if ((absupdate != 0) && (absupdate != 3) && (absupdate != 4))
  1497.     {
  1498.       outr = diff (out, "0");
  1499.     }
  1500.   else
  1501.     {
  1502.       outr = diff (out, last.out);
  1503.       if (outr < 0) /* wrapped 32-bit counter? */
  1504. outr += (long long) 1 << 32;
  1505.     }
  1506.   if (absupdate == 2)
  1507.     {
  1508.       outrate = outr + .5;
  1509.     }
  1510.   else if (absupdate == 3)
  1511.     {
  1512.       outrate = outr * (3600.0 / (period * 1.0)) + .5;
  1513.     }
  1514.   else if (absupdate == 4)
  1515.     {
  1516.       outrate = outr * (60.0 / (period * 1.0)) + .5;
  1517.     }
  1518.   else
  1519.     {
  1520.       outrate = outr / period + .5;
  1521.     }
  1522. }
  1523.     }
  1527.   if (inrate < 0 || (unsigned) inrate > abs_max)
  1528.     {
  1529.       if (options & OPTION_UNKNASZERO)
  1530. {
  1531.   inrate = 0; /* sync unknown to zero */
  1532. }
  1533.       else
  1534. {
  1535.   inrate = history[0].in; /* Sync by using last value */
  1536. }
  1537.     }
  1538.   if (outrate < 0 || (unsigned) outrate > abs_max)
  1539.     {
  1540.       if (options & OPTION_UNKNASZERO)
  1541. {
  1542.   outrate = 0; /* sync unknown to zero */
  1543. }
  1544.       else
  1545. {
  1546.   outrate = history[0].out; /* Sync by using last value */
  1547. }
  1548.     }
  1549.   if ((fo = fopen (buf, "w")) != NULL)
  1550.     {
  1551.       fprintf (fo, "%lu %s %sn", (unsigned long) now, in, out);
  1552.       last.time = now;
  1553.       /* what is this good for? */
  1554.       /* gauge und absolute */
  1555.       if ((absupdate != 0) && (absupdate != 3) && (absupdate != 4))
  1556. {
  1557.   strcpy (last.in, "0");
  1558.   strcpy (last.out, "0");
  1559. }
  1560.       else
  1561. {
  1562.   strcpy (last.in, in);
  1563.   strcpy (last.out, out);
  1564. }
  1565.       fprintf (fo, "%lu " LLD " " LLD " " LLD " " LLD "n",
  1566.        (unsigned long) now, inrate, outrate, inrate, outrate);
  1567.       nout = 1;
  1568.       hist->time = now;
  1569.       hist->in = inrate;
  1570.       hist->out = outrate;
  1571.       hist->inmax = inrate;
  1572.       hist->outmax = outrate;
  1573.       hist++;
  1575.       /* just in case we were dead for a long time, don't try to gather 
  1576.          data from non existing log entries  */
  1577.       now = plannow = history[0].time;
  1579.       plannow /= DAY_SAMPLE;
  1580.       plannow *= DAY_SAMPLE;
  1581.       n = 0;
  1583.       /* gobble up every shred of data we can get ... */
  1584.       if (plannow < now)
  1585. {
  1586.   NEXT ((unsigned long) (now - plannow));
  1587.   fprintf (fo, "%lu " LLD " " LLD " " LLD " " LLD "n",
  1588.    (unsigned long) now, (long long) inr, (long long) outr,
  1589.    (long long) inmax, (long long) outmax);
  1590.   hist->time = now;
  1591.   hist->in = inr;
  1592.   hist->out = outr;
  1593.   hist->inmax = inmax;
  1594.   hist->outmax = outmax;
  1595.   nout++;
  1596.   hist++;
  1597.   now = plannow;
  1599. }
  1601.       for (x = 1; x < DAY_COUNT; x++)
  1602. {
  1603.   NEXT (DAY_SAMPLE);
  1604.   fprintf (fo, "%lu " LLD " " LLD " " LLD " " LLD "n",
  1605.    (unsigned long) now, (long long) inr, (long long) outr,
  1606.    (long long) inmax, (long long) outmax);
  1607.   hist->time = now;
  1608.   hist->in = inr;
  1609.   hist->out = outr;
  1610.   hist->inmax = inmax;
  1611.   hist->outmax = outmax;
  1612.   nout++;
  1613.   hist++;
  1614.   now -= DAY_SAMPLE;
  1615. }
  1617.       plannow = now;
  1618.       plannow /= WEEK_SAMPLE;
  1619.       plannow *= WEEK_SAMPLE;
  1621.       if (plannow < now)
  1622. {
  1623.   NEXT ((unsigned long) (now - plannow));
  1624.   fprintf (fo, "%lu " LLD " " LLD " " LLD " " LLD "n",
  1625.    (unsigned long) now, (long long) inr, (long long) outr,
  1626.    inmax, outmax);
  1627.   hist->time = now;
  1628.   hist->in = inr;
  1629.   hist->out = outr;
  1630.   hist->inmax = inmax;
  1631.   hist->outmax = outmax;
  1632.   nout++;
  1633.   hist++;
  1634.   now = plannow;
  1636. }
  1638.       for (x = 0; x < WEEK_COUNT; x++)
  1639. {
  1640.   NEXT (WEEK_SAMPLE);
  1641.   fprintf (fo, "%lu " LLD " " LLD " " LLD " " LLD "n",
  1642.    (unsigned long) now, (long long) inr, (long long) outr,
  1643.    inmax, outmax);
  1644.   hist->time = now;
  1645.   hist->in = inr;
  1646.   hist->out = outr;
  1647.   hist->inmax = inmax;
  1648.   hist->outmax = outmax;
  1649.   nout++;
  1650.   hist++;
  1651.   now -= WEEK_SAMPLE;
  1652. }
  1654.       plannow = now;
  1655.       plannow /= MONTH_SAMPLE;
  1656.       plannow *= MONTH_SAMPLE;
  1658.       if (plannow < now)
  1659. {
  1660.   NEXT ((unsigned long) (now - plannow));
  1661.   fprintf (fo, "%lu " LLD " " LLD " " LLD " " LLD "n",
  1662.    (unsigned long) now, (long long) inr, (long long) outr,
  1663.    inmax, outmax);
  1664.   hist->time = now;
  1665.   hist->in = inr;
  1666.   hist->out = outr;
  1667.   hist->inmax = inmax;
  1668.   hist->outmax = outmax;
  1669.   nout++;
  1670.   hist++;
  1671.   now = plannow;
  1673. }
  1675.       for (x = 0; x < MONTH_COUNT; x++)
  1676. {
  1677.   NEXT (MONTH_SAMPLE);
  1678.   fprintf (fo, "%lu " LLD " " LLD " " LLD " " LLD "n",
  1679.    (unsigned long) now, (long long) inr, (long long) outr,
  1680.    inmax, outmax);
  1681.   hist->time = now;
  1682.   hist->in = inr;
  1683.   hist->out = outr;
  1684.   hist->inmax = inmax;
  1685.   hist->outmax = outmax;
  1686.   nout++;
  1687.   hist++;
  1688.   now -= MONTH_SAMPLE;
  1689. }
  1691.       plannow = now;
  1692.       plannow /= YEAR_SAMPLE;
  1693.       plannow *= YEAR_SAMPLE;
  1695.       if (plannow < now)
  1696. {
  1697.   NEXT ((unsigned long) (now - plannow));
  1698.   fprintf (fo, "%lu " LLD " " LLD " " LLD " " LLD "n",
  1699.    (unsigned long) now, (long long) inr, (long long) outr,
  1700.    inmax, outmax);
  1701.   hist->time = now;
  1702.   hist->in = inr;
  1703.   hist->out = outr;
  1704.   hist->inmax = inmax;
  1705.   hist->outmax = outmax;
  1706.   nout++;
  1707.   hist++;
  1708.   now = plannow;
  1710. }
  1712.       for (x = 0; x < YEAR_COUNT; x++)
  1713. {
  1714.   NEXT (YEAR_SAMPLE);
  1715.   fprintf (fo, "%lu " LLD " " LLD " " LLD " " LLD "n",
  1716.    (unsigned long) now, (long long) inr, (long long) outr,
  1717.    inmax, outmax);
  1718.   hist->time = now;
  1719.   hist->in = inr;
  1720.   hist->out = outr;
  1721.   hist->inmax = inmax;
  1722.   hist->outmax = outmax;
  1723.   nout++;
  1724.   hist++;
  1725.   now -= YEAR_SAMPLE;
  1726. }
  1728.       if (ferror (fo) || fclose (fo))
  1729. {
  1730.   perror (program);
  1731.   fprintf (stderr, "Rateup ERROR: Can't write new log filen");
  1732.   exit (1);
  1733. }
  1734.       /* another fix to get things working under NT */
  1735.       if (unlink (buf2))
  1736. {
  1737.   fprintf (stderr,
  1738.    "Rateup WARNING: %s Can't remove %s updating log filen",
  1739.    program, buf2);
  1740. }
  1742.       if (rename (buf1, buf2))
  1743. {
  1744.   fprintf (stderr,
  1745.    "Rateup WARNING: %s Can't rename %s to %s updating log filen",
  1746.    program, buf1, buf2);
  1747. }
  1748.       if (rename (buf, buf1))
  1749. {
  1750.   fprintf (stderr,
  1751.    "Rateup WARNING: %s Can't rename %s to %s updating log filen",
  1752.    program, buf, buf1);
  1753. }
  1754.       for (n = 0; n < nout && n < MAX_HISTORY; n++)
  1755. {
  1756.   history[n] = lhist[n];
  1757. }
  1758.     }
  1759.   else
  1760.     {
  1761.       perror (program);
  1762.       fprintf (stderr, "Rateup ERROR: Can't open %s for writen", buf);
  1763.       exit (1);
  1764.     }
  1765.   free (lhist);
  1766. }
  1768. static void
  1769. init_colour (int *colmap, int c0, int c1, int c2)
  1770. {
  1771.   *colmap++ = c0;
  1772.   *colmap++ = c1;
  1773.   *colmap = c2;
  1774. }
  1776. /* Constants for readparm option */
  1777. #define LENGTH_OF_BUFF  (2048)
  1778. #define NUMBER_OF_PARM   (100)
  1780. char buff[LENGTH_OF_BUFF + 1];
  1781. char *program;
  1783. static int
  1784. readparam (char const *file)
  1785. {
  1786.   FILE *fp = NULL;
  1787.   int cbuf;
  1789.   /* Open the file */
  1790.   if ((fp = fopen (file, "r")) == NULL)
  1791.     {
  1792.       fprintf (stderr, "%s ERROR: Can't open parameters file: %sn", program,
  1793.        file);
  1794.       return (1);
  1795.     }
  1796.   /* Check we actually got something */
  1797.   if (!(cbuf = fread (buff, 1, LENGTH_OF_BUFF, fp)))
  1798.     {
  1799.       fprintf (stderr, "%s ERROR: Parameters file emptyn", program);
  1800.       return (1);
  1801.     }
  1802.   fclose (fp);
  1803.   buff[cbuf] = '';
  1805. /* #define READPARAM_INFO */
  1806. #ifdef READPARAM_INFO
  1808.   fprintf (stderr, "%s INFO: Read: %d bytes from File: '%s'n", program, cbuf,
  1809.    file);
  1811. #endif
  1813.   return (0);
  1814. }
  1816. int
  1817. main (argc, argv)
  1818.      int argc;
  1819.      char **argv;
  1820. {
  1821.   int x, argi, used, initarg;
  1823.   program = argv[0];
  1825.   /* Is Argv[1] a path/file to passed parameters? */
  1826.   if ((argc > 1) && (strncasecmp (argv[1], "-F", 2) == 0))
  1827.     {
  1828.       char *b, *c, *l;
  1829.       if (readparam (argv[2]))
  1830. {
  1831.   return (1);
  1832. }
  1833.       /* Parse buffer into argv[] */
  1834.       argv = calloc (NUMBER_OF_PARM + 1, sizeof (char *));
  1835.       argc = 0;
  1836.       b = buff;
  1837.       l = b + strlen (b);
  1838.       while (b < l)
  1839. {
  1840.   if (b[0] == '"')
  1841.     {
  1842.       b++;
  1843.       c = strstr (b, """);
  1844.       if (c != NULL)
  1845. {
  1846.   *c = '';
  1847.   argv[argc] = b;
  1848.   argc++;
  1849.   b = c + 2;
  1850. }
  1851.       else
  1852. {
  1853.   fprintf (stderr,
  1854.    "Rateup ERROR: Parameter %d [%s] missing quoten",
  1855.    argc, b);
  1856.   break;
  1857. }
  1858.     }
  1859.   else
  1860.     {
  1861.       c = strstr (b, " ");
  1862.       if (c != NULL)
  1863. {
  1864.   *c = '';
  1865.   argv[argc] = b;
  1866.   argc++;
  1867.   b = c + 1;
  1868. }
  1869.       else
  1870. {
  1871.   argv[argc] = b;
  1872.   argc++;
  1873.   b = l;
  1874. }
  1875.     }
  1876.   if (argc == NUMBER_OF_PARM)
  1877.     {
  1878.       break;
  1879.     }
  1880. }
  1881.       /* Check we didn't fill argv[] */
  1882.       if (argc == NUMBER_OF_PARM)
  1883. {
  1884.   fprintf (stderr, "Rateup ERROR: Too many parameters read: %dn",
  1885.    argc);
  1886.   return (1);
  1887. }
  1889.       /* Check we didn't end early */
  1890.       if (b < l)
  1891. {
  1892.   return (1);
  1893. }
  1895.       /* Mark End of argv[] */
  1896.       argv[argc] = NULL;
  1898. #ifdef READPARAM_DEBUG
  1900.       for (i = 0; i < argc; i++)
  1901. {
  1902.   printf ("ParameterX %2d : '%s'n", i, argv[i] ? argv[i] : "<null>");
  1903. }
  1905. #endif
  1906.     }
  1908.   if (argc < 3)
  1909.     {
  1910.       fprintf (stderr, "%s for MRTG %sn"
  1911.        "Usage: %s -f <parameter file>n"
  1912.        "       %s directory basename [sampletime] [t sampletime] "
  1913.        "[-(t)ransparent] [-(b)order]"
  1914.        "[u|a|g|h|m in out abs_max] "
  1915.        "[i/p file maxvi maxvo maxx maxy growright step bits]n",
  1916.        program, VERSION, program, program);
  1917.       return (1);
  1918.     }
  1920.   routerpath = argv[1];
  1921.   /* this is for NT compatibility, because it does not seem to like
  1922.      rename across directories */
  1923.   if (chdir (routerpath))
  1924.     {
  1925.       fprintf (stderr, "Rateup ERROR: Chdir to %s failed ...n", routerpath);
  1926.       return (1);
  1927.     }
  1929.   /* Initialiase the colour variables  - should be overwritten */
  1930.   init_colour (&col_in[0], c_in);
  1931.   init_colour (&col_out[0], c_out);
  1932.   init_colour (&col_inm[0], c_inm);
  1933.   init_colour (&col_outm[0], c_outm);
  1934.   init_colour (&col_outp[0], c_outp);
  1936.   if ((history = calloc (1, sizeof (struct HISTORY) * (MAX_HISTORY + 1))) ==
  1937.       NULL)
  1938.     {
  1939.       fprintf (stderr, "Rateup ERROR: Out of memory in mainn");
  1940.       exit (1);
  1941.     }
  1942. #if defined(__WATCOMC__) || defined(NETWARE)
  1943.   memset (history, 0, sizeof (struct HISTORY) * (MAX_HISTORY + 1));
  1944. #endif
  1946.   Mh = MAX_HISTORY;
  1948.   router = argv[2];
  1950.   /* from  mrtg-2.x with x>5 rateup calling syntax changed to
  1951.      to support time properly ... this is for backward compat
  1952.      we check if now is remotely reasonable ... 
  1953.    */
  1955.   if (argc > 3)
  1956.     {
  1957.       NOW = atol (argv[3]);
  1958.       if (NOW > 10 * 365 * 24 * 60 * 60)
  1959. {
  1960.   initarg = 4;
  1961. }
  1962.       else
  1963. {
  1964.   initarg = 3;
  1965.   time (&NOW);
  1966. }
  1967.     }
  1968.   else
  1969.     {
  1970.       initarg = 3;
  1971.       time (&NOW);
  1972.     }
  1974.   readfile ();
  1975.   used = 1;
  1977.   for (argi = initarg; argi < argc; argi += used)
  1978.     {
  1979.       switch (argv[argi][0])
  1980. {
  1981. case '-': /* -options */
  1982.   switch (argv[argi][1])
  1983.     {
  1984.     case 'a': /* Turn off the direction arrow */
  1985.       options |= OPTION_NOARROW;
  1986.       used = 1;
  1987.       break;
  1988.     case 'A': /* Turn on the direction arrow */
  1989.       options &= ~OPTION_NOARROW;
  1990.       used = 1;
  1991.       break;
  1992.     case 'b': /* Turn off the shaded border */
  1993.       options |= OPTION_NOBORDER;
  1994.       used = 1;
  1995.       break;
  1996.     case 'B': /* Turn on the shaded border */
  1997.       options &= ~OPTION_NOBORDER;
  1998.       used = 1;
  1999.       break;
  2000.     case 'd': /* Print date in image */
  2001.       options |= OPTION_PNGDATE;
  2002.       used = 1;
  2003.       break;
  2004.     case 'i': /* Do not graph the I variable */
  2005.       options |= OPTION_NO_I;
  2006.       used = 1;
  2007.       break;
  2008.     case 'I': /* Graph the I variable */
  2009.       options &= ~OPTION_NO_I;
  2010.       used = 1;
  2011.       break;
  2012.     case 'o': /* Do not graph the O variable */
  2013.       options |= OPTION_NO_O;
  2014.       used = 1;
  2015.       break;
  2016.     case 'O': /* Graph the O variable */
  2017.       options &= ~OPTION_NO_O;
  2018.       used = 1;
  2019.       break;
  2020.     case 'l': /* logarithmic scaling */
  2021.       options |= OPTION_LOGGRAPH;
  2022.       options &= ~OPTION_MEANOVER;
  2023.       used = 1;
  2024.       break;
  2025.     case 'm': /* second-mean scaling */
  2026.       options |= OPTION_MEANOVER;
  2027.       options &= ~OPTION_LOGGRAPH;
  2028.       used = 1;
  2029.       break;
  2030.     case 'p': /* print router name in image */
  2031.       options |= OPTION_PRINTROUTER;
  2032.       used = 1;
  2033.       break;
  2034.     case 't': /* Transparent Image */
  2035.       options |= OPTION_TRANSPARENT;
  2036.       used = 1;
  2037.       break;
  2038.     case 'T': /* non-Transparent Image */
  2039.       options &= ~OPTION_TRANSPARENT;
  2040.       used = 1;
  2041.       break;
  2042.     case 'z': /* unknown as zero */
  2043.       options |= OPTION_UNKNASZERO;
  2044.       used = 1;
  2045.       break;
  2046.     case 'Z': /* repeat last */
  2047.       options &= ~OPTION_UNKNASZERO;
  2048.       used = 1;
  2049.       break;
  2050.     case '0': /* assume zeroes */
  2051.       options |= OPTION_WITHZEROES;
  2052.       used = 1;
  2053.       break;
  2054.     default:
  2055.       fprintf (stderr, "Rateup ERROR: Unknown option: %s, sorry!n",
  2056.        argv[argi]);
  2057.       return (1);
  2058.     }
  2059.   break;
  2060. case 'i': /* Create PPM Image record */
  2061.   image (argv[argi + 1], /* Image */
  2062.  strtoll (argv[argi + 2], NULL, 10), /* Max Value In */
  2063.  strtoll (argv[argi + 3], NULL, 10), /* Max Value Out */
  2064.  atol (argv[argi + 4]), /* xsize maxx */
  2065.  atol (argv[argi + 5]), /* ysize maxy */
  2066.  atof (argv[argi + 6]), /* xscale */
  2067.  atof (argv[argi + 7]), /* yscale */
  2068.  atol (argv[argi + 8]), /* growright */
  2069.  atol (argv[argi + 9]), /* step */
  2070.  atol (argv[argi + 10]), /* bits */
  2071.  atol (argv[argi + 11]), /* ytics */
  2072.  atof (argv[argi + 12]), /* yticsfactor */
  2073.  0, argv[argi + 13], atol (argv[argi + 14]));
  2074.   used = 15;
  2075.   break;
  2076. case 'p': /* Create PPM Image record with Peak values */
  2077.   image (argv[argi + 1], strtoll (argv[argi + 2], NULL, 10), /* Max Value In */
  2078.  strtoll (argv[argi + 3], NULL, 10), /* Max Value Out */
  2079.  atol (argv[argi + 4]), /* xsize maxx */
  2080.  atol (argv[argi + 5]), /* ysize maxy */
  2081.  atof (argv[argi + 6]), /* xscale */
  2082.  atof (argv[argi + 7]), /* yscale */
  2083.  atol (argv[argi + 8]), /* growright */
  2084.  atol (argv[argi + 9]), /* step */
  2085.  atol (argv[argi + 10]), /* bits */
  2086.  atol (argv[argi + 11]), /* ytics */
  2087.  atof (argv[argi + 12]), /* yticsfactor */
  2088.  1, argv[argi + 13], atol (argv[argi + 14]));
  2089.   used = 15;
  2090.   break;
  2091. case 'r': /* Create random records, then update */
  2092.   for (x = 0; x < histvalid; x++)
  2093.     {
  2094.       history[x].in = rand () % atoi (argv[argi + 1]);
  2095.       history[x].out = rand () % atoi (argv[argi + 2]);
  2096.     }
  2097. case 'u': /* Update file */
  2098.   if (argv[argi][1] == 'p')
  2099.     {
  2100.       options |= OPTION_DORELPERCENT;
  2101.     }
  2102.   update (argv[argi + 1], argv[argi + 2],
  2103.   strtoll (argv[argi + 3], NULL, 10), 0);
  2104.   used = 4;
  2105.   break;
  2106. case 'a': /* Absolute Update file */
  2107.   if (argv[argi][1] == 'p')
  2108.     {
  2109.       options |= OPTION_DORELPERCENT;
  2110.     }
  2111.   update (argv[argi + 1], argv[argi + 2],
  2112.   strtoll (argv[argi + 3], NULL, 10), 1);
  2113.   used = 4;
  2114.   break;
  2115. case 'g': /* Gauge Update file */
  2116.   if (argv[argi][1] == 'p')
  2117.     {
  2118.       options |= OPTION_DORELPERCENT;
  2119.     }
  2120.   update (argv[argi + 1], argv[argi + 2],
  2121.   strtoll (argv[argi + 3], NULL, 10), 2);
  2122.   used = 4;
  2123.   break;
  2124. case 'h':
  2125.   if (argv[argi][1] == 'p')
  2126.     {
  2127.       options |= OPTION_DORELPERCENT;
  2128.     }
  2129.   update (argv[argi + 1], argv[argi + 2],
  2130.   strtoll (argv[argi + 3], NULL, 10), 3);
  2131.   used = 4;
  2132.   break;
  2133. case 'm':
  2134.   if (argv[argi][1] == 'p')
  2135.     {
  2136.       options |= OPTION_DORELPERCENT;
  2137.     }
  2138.   update (argv[argi + 1], argv[argi + 2],
  2139.   strtoll (argv[argi + 3], NULL, 10), 4);
  2140.   used = 4;
  2141.   break;
  2142. case 'W': /* Week format */
  2143.   weekformat = argv[argi + 1][0];
  2144.   used = 2;
  2145.   break;
  2146. case 'c': /* Colour Map */
  2147.   sscanf (argv[argi + 1], "#%2x%2x%2x", &col_in[0], &col_in[1],
  2148.   &col_in[2]);
  2149.   sscanf (argv[argi + 2], "#%2x%2x%2x", &col_out[0], &col_out[1],
  2150.   &col_out[2]);
  2151.   sscanf (argv[argi + 3], "#%2x%2x%2x", &col_inm[0], &col_inm[1],
  2152.   &col_inm[2]);
  2153.   sscanf (argv[argi + 4], "#%2x%2x%2x", &col_outm[0], &col_outm[1],
  2154.   &col_outm[2]);
  2155.   used = 5;
  2156.   break;
  2157. case 'C': /* Extented Colour Map */
  2158.   sscanf (argv[argi + 1], "#%2x%2x%2x", &col_in[0], &col_in[1],
  2159.   &col_in[2]);
  2160.   sscanf (argv[argi + 2], "#%2x%2x%2x", &col_out[0], &col_out[1],
  2161.   &col_out[2]);
  2162.   sscanf (argv[argi + 3], "#%2x%2x%2x", &col_inm[0], &col_inm[1],
  2163.   &col_inm[2]);
  2164.   sscanf (argv[argi + 4], "#%2x%2x%2x", &col_outm[0], &col_outm[1],
  2165.   &col_outm[2]);
  2166.   sscanf (argv[argi + 5], "#%2x%2x%2x", &col_outp[0], &col_outp[1],
  2167.   &col_outp[2]);
  2168.   used = 6;
  2169.   break;
  2170. case 't':
  2171.   NOW = atol (argv[argi + 1]);
  2172.   used = 2;
  2173.   break;
  2174. case 'k':
  2175.   kilo = atol (argv[argi + 1]);
  2176.   used = 2;
  2177.   break;
  2178. case 'K':
  2179.   kMG = calloc (strlen (argv[argi + 1]) + 1, sizeof (char));
  2180.   strcpy (kMG, argv[argi + 1]);
  2181.   kMGcopy = calloc (strlen (argv[argi + 1]) + 1, sizeof (char));
  2182.   used = 2;
  2183.   break;
  2184. case 'Z': /* Timezone name */
  2185.   rtimezone = argv[argi + 1];
  2186.   used = 2;
  2187.   break;
  2188. case 'l': /* YLegend - rewritten by Oliver Haidi, re-rewritten by Jon Barber */
  2189.   {
  2190.     int i, j, k, loop = 1;
  2191.     int start = 1, got_esc = 0, append_ok;
  2192.     char *qstr;
  2193.     longup = (char *) calloc (1, 100);
  2194.     *longup = 0;
  2195.     /* this rather twisty argument scanning is necesary
  2196.        because NT command.coms rather dumb argument
  2197.        passing .... or because we don't know
  2198.        better. Under Unix we just would say.  if
  2199.        ((sscanf(argv[argi+1],"[%[^]]]", longup); */
  2200.     /* at start, check 1st char must be [ */
  2201.     if (argv[argi + 1][0] != '[')
  2202.       {
  2203. fprintf (stderr,
  2204.  "Rateup ERROR: YLegend: Option must be passed with '[' at start and  ']' at end (these will not be printed).n");
  2205. return (1);
  2206.       }
  2207.     for (i = 1; (i < argc) && loop; i++)
  2208.       { /* check all args until unescaped ']'  */
  2209. qstr = argv[argi + i];
  2210. for (j = start; ((size_t) j < strlen (qstr)) && loop; j++)
  2211.   {
  2212.     start = 0; /* 1st char in 1st arg already checked */
  2213.     append_ok = 1; /* OK to append unless we find otherwise */
  2214.     if (qstr[j] == '\')
  2215.       {
  2216. if (++got_esc == 1)
  2217.   {
  2218.     append_ok = 0; /* don't append 1st '/' */
  2219.   }
  2220. else
  2221.   {
  2222.     got_esc = 0; /* 2nd '/' in a row, i.e. '//' */
  2223.   }
  2224.       }
  2225.     if (qstr[j] == ']')
  2226.       { /* is this the end? */
  2227. if (got_esc == 1)
  2228.   {
  2229.     if (strlen (qstr + j) >= 2)
  2230.       {
  2231. append_ok = 1;
  2232. got_esc = 0;
  2233.       }
  2234.     else
  2235.       {
  2236. fprintf (stderr,
  2237.  "1: rateup ERROR: YLegend:  use "\]" for "]" or "\\" for "\".n");
  2238. return (1);
  2239.       }
  2240.   }
  2241. else
  2242.   {
  2243.     if (strlen (qstr + j) >= 2)
  2244.       {
  2245. fprintf (stderr,
  2246.  "2: rateup ERROR: YLegend:  use "\]" for "]" or "\\" for "\".n");
  2247. return (1);
  2248.       }
  2249.     loop = 0;
  2250.     append_ok = 0;
  2251.   }
  2252.       }
  2253.     if (append_ok == 1)
  2254.       {
  2255. k = strlen (longup);
  2256. if ((size_t) (k + 1) > 99)
  2257.   {
  2258.     fprintf (stderr,
  2259.      "3: rateup ERROR: YLegend too longn");
  2260.     return (1);
  2261.   }
  2262. longup[k] = qstr[j];
  2263. longup[k + 1] = 0;
  2264.       }
  2265.   } /* for (j=start...)   */
  2266. /* append space */
  2267. k = strlen (longup);
  2268. if ((size_t) (k + 1) > 99)
  2269.   {
  2270.     fprintf (stderr, "4: rateup ERROR: YLegend too longn");
  2271.     return (1);
  2272.   }
  2273. longup[k] = ' ';
  2274. longup[k + 1] = 0;
  2275.       } /* for (i =1 ... */
  2276.     used = i;
  2277.   }
  2278.   /* remove trailing space */
  2279.   longup[max (0, (signed) strlen (longup) - 1)] = 0;
  2280.   shortup = longup;
  2281.   /* fprintf(stderr, "YLegend = "%s"n", longup);  */
  2282.   break;
  2283. case 'T': /* pngTitle - based on YLegend */
  2284.   {
  2285.     int i, j, k, loop = 1;
  2286.     int start = 1, got_esc = 0, append_ok;
  2287.     char *qstr;
  2288.     pngtitle = (char *) calloc (1, 100);
  2289.     *pngtitle = 0;
  2290.     /* this rather twisty argument scanning is necesary
  2291.        because NT command.coms rather dumb argument
  2292.        passing .... or because we don't know
  2293.        better. Under Unix we just would say.  if
  2294.        ((sscanf(argv[argi+1],"[%[^]]]", pngtitle); */
  2295.     /* at start, check 1st char must be [ */
  2296.     if (argv[argi + 1][0] != '[')
  2297.       {
  2298. fprintf (stderr,
  2299.  "Rateup ERROR: YLegend: Option must be passed with '[' at start and  ']' at end (these will not be printed).n");
  2300. return (1);
  2301.       }
  2302.     for (i = 1; (i < argc) && loop; i++)
  2303.       { /* check all args until unescaped ']'  */
  2304. qstr = argv[argi + i];
  2305. for (j = start; ((size_t) j < strlen (qstr)) && loop; j++)
  2306.   {
  2307.     start = 0; /* 1st char in 1st arg already checked */
  2308.     append_ok = 1; /* OK to append unless we find otherwise */
  2309.     if (qstr[j] == '\')
  2310.       {
  2311. if (++got_esc == 1)
  2312.   {
  2313.     append_ok = 0; /* don't append 1st '/' */
  2314.   }
  2315. else
  2316.   {
  2317.     got_esc = 0; /* 2nd '/' in a row, i.e. '//' */
  2318.   }
  2319.       }
  2320.     if (qstr[j] == ']')
  2321.       { /* is this the end? */
  2322. if (got_esc == 1)
  2323.   {
  2324.     if (strlen (qstr + j) >= 2)
  2325.       {
  2326. append_ok = 1;
  2327. got_esc = 0;
  2328.       }
  2329.     else
  2330.       {
  2331. fprintf (stderr,
  2332.  "1: rateup ERROR: YLegend:  use "\]" for "]" or "\\" for "\".n");
  2333. return (1);
  2334.       }
  2335.   }
  2336. else
  2337.   {
  2338.     if (strlen (qstr + j) >= 2)
  2339.       {
  2340. fprintf (stderr,
  2341.  "2: rateup ERROR: YLegend:  use "\]" for "]" or "\\" for "\".n");
  2342. return (1);
  2343.       }
  2344.     loop = 0;
  2345.     append_ok = 0;
  2346.   }
  2347.       }
  2348.     if (append_ok == 1)
  2349.       {
  2350. k = strlen (pngtitle);
  2351. if ((size_t) (k + 1) > 99)
  2352.   {
  2353.     fprintf (stderr,
  2354.      "3: rateup ERROR: YLegend too longn");
  2355.     return (1);
  2356.   }
  2357. pngtitle[k] = qstr[j];
  2358. pngtitle[k + 1] = 0;
  2359.       }
  2360.   } /* for (j=start...)   */
  2361. /* append space */
  2362. k = strlen (pngtitle);
  2363. if ((size_t) (k + 1) > 99)
  2364.   {
  2365.     fprintf (stderr, "4: rateup ERROR: YLegend too longn");
  2366.     return (1);
  2367.   }
  2368. pngtitle[k] = ' ';
  2369. pngtitle[k + 1] = 0;
  2370.       } /* for (i =1 ... */
  2371.     used = i;
  2372.   }
  2373.   /* remove trailing space */
  2374.   pngtitle[max (0, (signed) strlen (pngtitle) - 1)] = 0;
  2375.   /* fprintf(stderr, "YLegend = "%s"n", pngtitle);  */
  2376.   break;
  2377. default:
  2378.   fprintf (stderr, "Rateup ERROR: Can't cope with %s, sorry!n",
  2379.    argv[argi]);
  2380.   return (1);
  2381. }
  2382.     }
  2383.   return (0);
  2384. }