#! /usr/bin/perl
#
#
#

                                                                                                          
use GDBM_File;
use Socket;

$genesis_dir='/home/wleiden/svn/genesis';
$svn='/usr/local/bin/svn';
$wlan_stats='/home/wleiden/svn/stats/mrtg/wlan_stats.pl';
$rrdimg='/home/wleiden/stats/rrd/img';
$rrddata='/home/wleiden/stats/rrd/data';
$heartbeat=700;

$PINGNODE{"172.17.8.1"}="CNodeCope";
$PINGNODE{"172.18.8.1"}="CNodeJasper";
$PINGNODE{"172.17.136.1"}="CNodeCeTIM1";
$PINGNODE{"172.20.128.1"}="CNodeRV";
$PINGNODE{"172.19.128.1"}="CNodeUnigor";
$PINGNODE{"172.17.48.1"}="CNodeThomas";

$comment="\tCOMMENT:\"                         Min:          Max:          Avg:       Current:\"\\n";

#         blauw   paars    dgroen   groen    rose      geel    cyaan     oranje    rood
#@COLORS=('0088FF','FF00F0','008000','00FF00','FFC0F8','80FFFF','E0E080','FF8000','FF0000');
                                                                                                    
@COLORS=('0000FF','0099FF','00FFCC','00FF33','CC9900','FFFF00','FF6600','FF0033','FF00CC','9900FF',
	 '0033CC','00CCCC','00CC33','66CC00','66FF00','CC0000','CC0099','6600CC',
	 '3366FF','33FFFF','33FF66','99FF33','FFCC33','FF3333','FF33CC','9933FF'
        );
	


$RRA=sprintf<<EORRA;
	RRA:AVERAGE:0.5:1:600
	RRA:AVERAGE:0.5:6:700
	RRA:AVERAGE:0.5:24:775
	RRA:AVERAGE:0.5:144:797
	RRA:AVERAGE:0.5:2016:250
EORRA
$RRA=~s/\n/ /gi;

# 600 samples of 5 minutes  (2 days and 2 hours)
# 700 samples of 30 minutes (2 days and 2 hours, plus 12.5 days)
# 775 samples of 2 hours    (above + 50 days)
# 797 samples of 1 day      (above + 732 days, rounded up to 797)
# 250 samples of 1 week     


$xyfile='/home/wleiden/stats/mrtg/xy.gdbm';
if ($ARGV[0] eq 'DEBUG') {$DEBUG=1;}

if ($DEBUG) {$q="";} else {$q='-q';}
system("$svn $q update $genesis_dir");

#print "$svn info $genesis_dir|grep 'Last Changed Rev:'\n";

$revision=`$svn info $genesis_dir|grep 'Last Changed Rev:'`;
$revision=~s/Last Changed Rev:\s+(\d+)\D*/$1/s;

$revision_file='/home/wleiden/stats/mrtg/last_cfgmaker_revision';
$last_revision=`cat $revision_file`;
$last_revision=~s/\D*(\d+)\D*/$1/s;

if ($revision <= $last_revision) 
{if ($DEBUG) {print "Nothing to do: $last_revision=$revision\n";}
 if ($ARGV[1] eq '') {exit;}

} elsif ($DEBUG) {print "Last revision= [$last_revision] <> [$revision]\n";}



chdir("/home/wleiden/svn/genesis/nodes/") || die "$!: /home/wleiden/svn/genesis/nodes/";
foreach $file (<*/wleiden.conf>)
{
   $file=~s/\/wleiden\.conf//gi;
#print "FILE: $file\n";
   if (! grep(/^$file$/,@NODES))
   {
    push(@NODES,$file);
#    if ($DEBUG) {print STDERR "Adding node $file\n";}
   }
}


unlink("$xyfile.$$");
tie %XY,'GDBM_File',"$xyfile.$$", &GDBM_WRCREAT, 0640 || die "$! $xyfile.$$\n";

$rrdindexfilename="/home/wleiden/public_html/rrdindex.html";
open (RRDINDEX,">$rrdindexfilename.$$") || die "$! $rrdindexfilename.$$\n";

#$node='CNodeCope';
foreach $node (@NODES)
{
  if ($node=~/(demo|test|vuilnis|vpn)/) {next;}
  $nodez++;
  if ($DEBUG) {print STDERR "Doing node $node\n";}
  make_cfg($node);
}
print RRDINDEX "<P><A HREF=/rrd-cgi/proxies.cgi?RRD_START=-24h>Proxies Summary</A><P>\n";
close(RRDINDEX);

rename("$rrdindexfilename.$$",$rrdindexfilename);

untie (%XY);
unlink($xyfile);
rename("$xyfile.$$",$xyfile);
open (FILE,">${revision_file}"); print FILE "$revision\n"; close(FILE);

sub make_cfg
{
   local($node)=@_;
   local($r,$if,$main,$wireless)='';

   local($X,$Y,$Real_X,$RealY);
   local(%config,%DESC,%SDESC,%ANTENNA,%BEAMWIDTH,%CABLE,%CHANNEL,%DHCP,%DHCP_STATIC);
   local(%DIRECTION,%ESSID,%GAIN,%IP,%MODE,%NAT,%OSPF_AREA,%OSPF_BROADCAST);

local(%OSPF_NEIGHBORS,%POINT_TO_POINT,%POLAR,%ROUTE,%SENS,%SPEED,%TXPOWER,%TYPE,%DISPLAY_LINK);
   local($labelpos,$neighbors,$link_file,$int_file);
   local(%ptp_done);

   chdir("/home/wleiden/genesis/nodes");
#   $doit="curl -m 10 -sf http://www.wleiden.net/cgi-bin/g_list.pl/$node/config -o ${node}.pl";
#   if ($DEBUG) {print STDERR "Fetching config for $node: $doit\n";}
#   system($doit);

   do "${node}/wleiden.conf" || return;
   parse_config();

   $XY{"$node-XY"}="$X:$Y";
   if ($Real_X) {$XY{"$node-RXY"}="$Real_X:$Real_Y";}
   $XY{"$node-labelpos"}=$labelpos;

   if ($nodetype=~/CNode|proxy/i)
   {
    local($rrd_traffic,$rrd_routes,$rrd_quality,$rrd_channels,$rrd_links)=();
    local($rrd_traffic1,$rrd_traffic2,$rrd_traffic3,$rrd_traffic4,$rrd_traffic5)=();
    local($rrd_routes1,$rrd_routes2)=();
    local($rrd_quality1,$rrd_quality2)=();
    local($rrd_channels1,$rrd_channels2)=();
    local($linkc_counter)=10;
    local($ifc_counter)=0;
    $rrd_traffic=RRD_init("Traffic",'traffic','Bytes/s',250,'',"-${heartbeat}s");
    $rrd_trafficSi="\tCDEF:TOTALi=0,";
    $rrd_trafficSo="\tCDEF:TOTALo=0,";

    $rrd_routes=RRD_init("Routes",'routes','Routes',100,'',"-${heartbeat}s");
    $rrd_routes.="   --lower-limit 0 --rigid\n";
    $rrd_routesS="\tCDEF:TOTAL=0,";

    $rrd_quality=RRD_init("Quality",'quality','dB',100,'',"-${heartbeat}s");


    $rrd_channels=RRD_init("Channels",'channels','',100,'',"-${heartbeat}s");

    $rrd_channels.="   --lower-limit 1 --upper-limit 13 --rigid\n";

   $dir="/home/wleiden/public_html/mrtg/$node";
   if (! -d $dir) {mkdir($dir,0755) || die "$! $dir\n";}

   $rrddir="/home/wleiden/stats/rrd/data/$node";
   if (! -d $rrddir) {mkdir($rrddir,0755) || die "$! $rrddir\n";}

   $rrdimgdir="/home/wleiden/stats/rrd/img/$node";
   if (! -d $rrdimgdir) {mkdir($rrdimgdir,0777) || die "$! $rrdimgdir\n";}

   check_rrd_system_file("$rrddir/system.rrd",$heartbeat);
   check_rrd_icmp_file("$rrddir/icmp.rrd",$heartbeat);

   print RRDINDEX "<A HREF=/rrd-cgi/system.cgi?RRD_START=-24h&RRD_NODE=$node>$node</A><BR>\n";

   $rrdcgidir="/home/wleiden/stats/rrd/cgi/$node";
   if (! -d $rrdcgidir) {mkdir($rrdcgidir,0755) || die "$! $rrdcgidir\n";;}

   $rrd_cgi_file="$rrdcgidir/interfaces.cgi";
   open(CGI,">$rrd_cgi_file.$$") || die "$! $rrd_cgi_file\n";
   print CGI init_cgi();

   $filename="/home/wleiden/stats/mrtg/cfg/${node}.cfg";
   open (MRTG,">$filename") || die die "$! $filename\n";;
   print MRTG <<EOR1;

# Minimal mrtg.cfg rev: $revision
#--------------------

IconDir: /mrtgicons/
WorkDir: $dir 

#
#
#

Target[httpspeed]: `$wlan_stats $node httpspeed`
MaxBytes[httpspeed]: 10000000000
Title[httpspeed]: httpspeed Analysis for $node
PageTop[httpspeed]: <H1>Http speed for $node</H1>
Options[httpspeed]: transparent, gauge, nopercent
WithPeak[httpspeed]: wmy
Legendi[httpspeed]: tango
Legendo[httpspeed]: proxy


Target[total_bytes]: `$wlan_stats $node bytes-total`
MaxBytes[total_bytes]: 10000000000
Title[total_bytes]: Total Traffic 
PageTop[total_bytes]: <H1>Total Traffic on all interfaces</H1>
Options[total_bytes]: transparent, gauge, nopercent
WithPeak[total_bytes]: wmy

Target[total_users]: `$wlan_stats $node bytes-users`
MaxBytes[total_users]:  10000000000
Title[total_users]: Total Users Traffic 
PageTop[total_users]: <H1>Total Traffic on all Usersinterfaces</H1>
Options[total_users]: transparent, gauge, nopercent
WithPeak[total_users]: wmy

Target[total_links]: `$wlan_stats $node bytes-links`
MaxBytes[total_links]:  10000000000
Title[total_links]: Total Link Traffic 
PageTop[total_links]: <H1>Total Traffic on all Link interfaces</H1>
Options[total_links]: transparent, gauge, nopercent
WithPeak[total_links]: wmy

Target[total_ospf]: `$wlan_stats $node bytes-ospf`
MaxBytes[total_ospf]:  10000000000
Title[total_ospf]: Total OSPF Traffic 
PageTop[total_ospf]: <H1>Total OSPF Traffic on all Link interfaces</H1>
Options[total_ospf]: transparent, gauge, nopercent
WithPeak[total_ospf]: wmy

Target[${node}_uptime]: `$wlan_stats $node fetch`
MaxBytes[${node}_uptime]: 1000
Title[${node}_uptime]: $node Uptime
PageTop[${node}_uptime]: <H1>$node Uptime</H1>
Options[${node}_uptime]: transparent, gauge, nopercent
Legendi[${node}_uptime]: uptime
Legendo[${node}_uptime]:
ShortLegend[${node}_uptime]: Days
YLegend[${node}_uptime]: Days
WithPeak[${node}_uptime]: wmy

Target[${node}_load]: `$wlan_stats $node cpuload`
MaxBytes[${node}_load]: 1000
Title[${node}_load]: CPU load on $node
PageTop[${node}_load]: <H1>CPU load on $node</H1>
Options[${node}_load]: transparent, gauge, nopercent
Legendi[${node}_load]: 5min
Legendo[${node}_load]: 15min
ShortLegend[${node}_load]: %
YLegend[${node}_load]: %
WithPeak[${node}_load]: wmy


Target[${node}_mem]: `$wlan_stats $node mem`
MaxBytes[${node}_mem]:300000000
Title[${node}_mem]: Memory usage on $node
PageTop[${node}_mem]: <H1>Memory usage on $node</H1>
Options[${node}_mem]: transparent, gauge, nopercent
Legendi[${node}_mem]: free
Legendo[${node}_mem]: swap
ShortLegend[${node}_mem]: Bytes
YLegend[${node}_mem]: Bytes
WithPeak[${node}_mem]: wmy

Target[${node}_routes]: `$wlan_stats $node routes`
MaxBytes[${node}_routes]: 3000
Title[${node}_routes]: Routes on $node
PageTop[${node}_routes]: <H1>Routes on $node</H1>
Options[${node}_routes]: transparent, gauge, nopercent
Legendi[${node}_routes]: routes
Legendo[${node}_routes]: 
ShortLegend[${node}_routes]: routes
YLegend[${node}_routes]: routes
WithPeak[${node}_routes]: wmy

###############################################################

EOR1

   foreach $if (sort keys %config)
   {

      if ($if!~/:\d+/) {$main=1;} else {$main=0;}
      if ($if=~/^([^:]+):(\d+)/) {$mymain=$1;$mysub=$2;} else {$mymain=$if;}
      $ip=$IP{$if};
      $ip=~s/\/(\d+)$//;$XY{$ip}=$node;
      $IF=$if;$IF=~s/[^a-z0-9_-]/_/gi;
      if (! $main)
      {
	  $speed=$SPEED{$mymain};
	  if ($speed!~/\d+/) {$speed= 10000000000;}



	  print MRTG <<EOM21s;

#### Interface subint $if ($ip)

Target[${IF}_bytes]: `$wlan_stats $node bytes-$mymain-$ip`
MaxBytes[${IF}_bytes]: $speed
Title[${IF}_bytes]: Traffic on ${if} $DESC{$if}
PageTop[${IF}_bytes]: <H1>Traffic on ${if} $DESC{$if} </H1>
Options[${IF}_bytes]: transparent
WithPeak[${IF}_bytes]: wmy



EOM21s

      } else  # main:
      {
	  $speed=$SPEED{$if};
	  if ($speed!~/\d+/) {$speed=10000000000;}
	  check_rrd_interface($rrddir,$if,$heartbeat);
	  $int_file="$rrddata/<RRD::CV::PATH RRD_NODE>/int-${if}.rrd";
	  $rrd_traffic1.="\tDEF:${if}_b_in=$int_file:bytes_in:AVERAGE\n";
	  $rrd_traffic2.="\tDEF:${if}_b_out=$int_file:bytes_out:AVERAGE\n";
	  $rrd_trafficSi.="U${if}_b_in,+,";
	  $rrd_trafficSo.="UN${if}_b_out,+,";

	  if ($rrd_traffic4) {$STACK='STACK';}
	  else {$STACK='AREA';$rrd_traffic3="\tCDEF:Null=${if}_b_out,UN,0,*\n";} 
	  $rrd_traffic3.="\tCDEF:N${if}_b_out=0,${if}_b_out,-\n";
	  $ifcolor='#' . $COLORS[$ifc_counter+=3];
	  $rrd_traffic4.=addData("${if}_b_in",$ifcolor,"${if} in",$STACK,"%sB/s");
#"\t$STACK:${if}_bytes_in${ifcolor}:\"${if}\"\n";
	  $rrd_traffic5.=addData("N${if}_b_out",$ifcolor,"${if} out",$STACK,"%sB/s");
#"\t$STACK:N${if}_bytes_out${ifcolor}:\n";


	  $rrd_routes1.="\tDEF:${if}_routes=$int_file:routes:AVERAGE\n";
	  $rrd_routesS.="U${if}_routes,+,";

	  if ($rrd_routes2) {$STACK='STACK';}
	  else {$STACK='AREA';}
	  $rrd_routes2.=addData("${if}_routes",$ifcolor,"${if}",$STACK,"");
#"\t$STACK:${if}_routes${ifcolor}:\"${if}\"\n";

	  if ($TYPE{$if}=~/wireless/i)
 	  {
	    $rrd_channels1.="\tDEF:${if}_channel=$int_file:channel:AVERAGE\n";
	    $rrd_channels2.=addData("${if}_channel",$ifcolor,"${if}","LINE2","");
#"\tLINE2:${if}_channel${ifcolor}:\"${if}\"\n";
	  }
	  print MRTG <<EOM21;

#### Interface $if

Target[${IF}_bytes]: `$wlan_stats $node bytes-$if`
MaxBytes[${IF}_bytes]: $speed
Title[${IF}_bytes]: Total Traffic on ${if}
PageTop[${IF}_bytes]: <H1>Total Traffic on ${if}</H1>
Options[${IF}_bytes]: transparent
WithPeak[${IF}_bytes]: wmy

EOM21

	if ($IP{"${if}:0"})
	{
	print MRTG <<EOM22;

Target[${IF}__bytes]: `$wlan_stats $node bytes-$if-$ip`
MaxBytes[${IF}__bytes]: $speed
Title[${IF}__bytes]: Traffic on ${if}_ $DESC{$if}
PageTop[${IF}__bytes]: <H1>Traffic on ${if}_ $DESC{$if}</H1>
Options[${IF}__bytes]: transparent
WithPeak[${IF}__bytes]: wmy

Target[${IF}_routes]: `$wlan_stats $node routes-${if}`
MaxBytes[${IF}_routes]: 10000
Title[${IF}_routes]: routes on ${if}
PageTop[${IF}_routes]: <H1>routes on ${if}</H1>
Options[${IF}_routes]: transparent, gauge, nopercent
Legendi[${IF}_routes]: routes:
Legendo[${IF}_routes]: 
WithPeak[${IF}_routes]: wmy

EOM22


	}
	if ($TYPE{$if}=~/wireless/)
        {
          if (($DIRECTION{$if} > 0) && ($BEAMWIDTH{$if} ne 360))
	  {
	    $XY{"DIR_${node}_$ESSID{$if}"}=$DIRECTION{$if};
	  }
	  if ($MODE{$if}=~/master/)
{   $XY{"${node}-M"}.=":$ESSID{$if}=$POINT_TO_POINT{$if}=$if:";
    $XY{"$ESSID{$if}-E"}=$node;
print MRTG<<EOM2;


Target[${IF}_users]: `$wlan_stats $node users-$if`
MaxBytes[${IF}_users]: 100
Title[${IF}_users]: Users on ${if}
PageTop[${IF}_users]: <H1>Users on ${if}</H1>
Options[${IF}_users]: transparent, gauge, nopercent
Legendi[${IF}_users]: users
Legendo[${IF}_users]: 
ShortLegend[${IF}_users]: users
YLegend[${IF}_users]: users
WithPeak[${IF}_users]: wmy

EOM2
} else {$XY{"${node}-S"}.=":$ESSID{$if}=$POINT_TO_POINT{$if}=$if:";}
	print MRTG <<EOM3;
Target[${IF}_beacons]: `$wlan_stats $node ${if}-beacons`
MaxBytes[${IF}_beacons]: 100
Title[${IF}_beacons]: Beacons on ${if}
PageTop[${IF}_beacons]: <H1>Beacons on ${if}</H1>
Options[${IF}_beacons]: transparent, gauge, nopercent
Legendi[${IF}_beacons]: beacons
Legendo[${IF}_beacons]: 
ShortLegend[${IF}_beacons]: beacons
YLegend[${IF}_beacons]: beacons
WithPeak[${IF}_beacons]: wmy

Target[${IF}_TXspeed]: `$wlan_stats $node TX-speed-${if}`
MaxBytes[${IF}_TXspeed]: 100000000
Title[${IF}_TXspeed]: TX Speed on ${if}
PageTop[${IF}_TXspeed]: <H1>TX Speed on ${if}</H1>
Options[${IF}_TXspeed]: transparent, gauge, nopercent, bits 
Legendi[${IF}_TXspeed]: actual:
Legendo[${IF}_TXspeed]: select:
WithPeak[${IF}_TXspeed]: wmy



EOM3



	} # wireless
	else
	{
	  if ($ETHER_ESSID{$if}) #Artifical display ethernet bridge link.
	  {
	    $XY{"${node}-S"}.=":$ETHER_ESSID{$if}=$POINT_TO_POINT{$if}=$if:";
	  }
	}
      } # main
      check_rrd_links($rrddir,$if,$heartbeat);

       $nname=lc($SDESC{$if});
       $desc=$DESC{$if};
#	 if ($a++ >1) {$nname.=$a;}

      if ($OSPF_NEIGHBORS{$if}!~/no|off/i)
      {
	$neighbors="$OSPF_NEIGHBORS{$if} ";$a=0;
	foreach $neighbor (split(/\s+/,$neighbors))
        {

	print MRTG<<EOM31;
Target[routes-$mymain-$neighbor]: `$wlan_stats $node routes-${mymain}-${neighbor}`
MaxBytes[routes-$mymain-$neighbor]: 10000
Title[routes-$mymain-$neighbor]: routes on ${if} via $neighbor
PageTop[routes-$mymain-$neighbor]: <H1>routes on ${if} via $neighbor</H1>
Options[routes-$mymain-$neighbor]: transparent, gauge, nopercent
Legendi[routes-$mymain-$neighbor]: routes:
Legendo[routes-$mymain-$neighbor]: 
WithPeak[routes-$mymain-$neighbor]: wmy
EOM31


      if ($TYPE{$if}=~/wireless/)
      {

		print MRTG<<EOM4;
### Link $desc [$neighbor] [$SDESC{$if}]

Target[snr-${mymain}-$nname]: `$wlan_stats $node SNR-${mymain}-$neighbor`
MaxBytes1[snr-${mymain}-$nname]: 200
MaxBytes2[snr-${mymain}-$nname]: 200
Title[snr-${mymain}-$nname]: Signal and Noise for $desc on ${if}
PageTop[snr-${mymain}-$nname]: <H1>Signal and Noise for $desc on ${if}</H1>
Options[snr-${mymain}-$nname]: transparent, gauge, nopercent 
Legendi[snr-${mymain}-$nname]: Signal:  
Legendo[snr-${mymain}-$nname]: Noise: 
ShortLegend[snr-${mymain}-$nname]: dBm
YLegend[snr-${mymain}-$nname]: dBm
WithPeak[snr-${mymain}-$nname]: wmy

Target[qual-${mymain}-$nname]: `$wlan_stats $node qual-${mymain}-$neighbor`
MaxBytes1[qual-${mymain}-$nname]: 100
MaxBytes2[qual-${mymain}-$nname]: 100
Title[qual-${mymain}-$nname]: Quality $desc on ${if}
PageTop[qual-${mymain}-$nname]: <H1>Quality for $desc on ${if}</H1>
Options[qual-${mymain}-$nname]: transparent, gauge, nopercent 
Legendi[qual-${mymain}-$nname]: Quality:  
Legendo[qual-${mymain}-$nname]: 
ShortLegend[qual-${mymain}-$nname]: dBm
YLegend[qual-${mymain}-$nname]: dBm
WithPeak[qual-${mymain}-$nname]: wmy

Target[lat-$nname]: `$wlan_stats $node latency-$neighbor`
MaxBytes1[lat-$nname]: 100
MaxBytes2[lat-$nname]: 600
Title[lat-$nname]: Latency/PktLoss Analysis $desc on ${if}
PageTop[lat-$nname]: <H1>Latency/PktLoss on $desc in ${if}</H1>
Options[lat-$nname]: transparent, gauge, nopercent
Legendi[lat-$nname]: PacketLoss%
Legendo[lat-$nname]: Avg. Latency (ms)
ShortLegend[lat-$nname]: %/ms
YLegend[lat-$nname]: %/ms
WithPeak[lat-$nname]: wmy


EOM4
     
       } # Wireless
      } # neighbor
     } # OSPF

     foreach $ptp (split(/\s+/,$neighbors . " " . $POINTOPOINT{$if}))
     {  
	if (exists($ptp_done{$ptp})) {next;}
	$ptp_done{$ptp}=1;

	$_ptp=$ptp;$_ptp=~s/\./_/gi;
	$lcolor='#' . $COLORS[$linkc_counter++];
        local($iaddr) = inet_aton($ptp); # or whatever address
        local($hostname)  = gethostbyaddr($iaddr, AF_INET);

	$hostname=~s/^[^.]+\.([^.]+)\..*$/$1/i;
	$hostname=~s/.node//i;
#	print "HM:$ptp=$hostname\n"; 

	$rrd_links.="<H2>Link to $ptp on $if</H2><P>\n";
	local($a,$s);
        $a=addData("${_ptp}_AvgNoise","#00FF00","Noise","AREA","dB");
        $s=addData("${_ptp}_AvgSignal","#0000FF","Signal","LINE2","dB");
#        AREA:${_ptp}_AvgNoise#00FF00:"Noise"
#        LINE2:${_ptp}_AvgSignal#0000FF:"Signal"

	if ($TYPE{$mymain}=~/wireless/i)
	{
	     $rrd_links.=RRD_init("Signal/Noise to 2$hostname on $if","snr-$ptp",'dB',100,'',"-${heartbeat}s");

	     $link_file="$rrddata/<RRD::CV::PATH RRD_NODE>/link-${ptp}.rrd";
	     $rrd_links.=<<EOR;
   --lower-limit -160 --upper-limit 0 --rigid
	DEF:${_ptp}_AvgSignal=$link_file:AvgSignal:AVERAGE
        DEF:${_ptp}_AvgNoise=$link_file:AvgNoise:AVERAGE

$a
$s                                                                                                                     
><P>\n
EOR
        $a=addData("InBytes","#00FF00","In","AREA","%sB/s");
        $s=addData("NOutBytes","#0000FF","Out","AREA","%sB/s");

#	AREA:InBytes#00FF00:
#	AREA:NOutBytes#00FF00:

	     $rrd_links.=RRD_init("Traffic 2$hostname on $if","traffic-$ptp",'Bytes/s',100,'',"-${heartbeat}s");
	     $rrd_links.=<<EOR;
	DEF:InBytes=$link_file:InBytes:AVERAGE
	DEF:OutBytes=$link_file:OutBytes:AVERAGE

	CDEF:Null=OutBytes,UN,0,*

	CDEF:NOutBytes=0,OutBytes,-

$a
$s

	LINE2:Null#000000:

><P>\n
EOR
#    AREA:AvgInBandwidth#00FF00:"Avg"
#    LINE2:DevInBandwidth#0000FF:"Dev"
                                                                                                                     
#    AREA:NAvgOutBandwidth#00FF00:
#    LINE2:NDevOutBandwidth#0000FF:

        $a=addData("AvgInBandwidth","#00FF00","AvgIn","AREA","%sB/s");
        $a.=addData("DevInBandwidth","#0000FF","DevIn","LINE2","%sB/s");
        $s=addData("NAvgOutBandwidth","#00FF00","AvgOut","AREA","%sB/s");
        $s.=addData("NDevOutBandwidth","#0000FF","DevOut","LINE2","%sB/s");


	     $rrd_links.=RRD_init("Bandwith 2$hostname on
	     $$if","bandw-$ptp",'Bytes/s',100,'',"-${heartbeat}s");
	     $rrd_links.=<<EOR;
    DEF:AvgInBandwidth=$link_file:AvgInBandwidth:AVERAGE
    DEF:DevInBandwidth=$link_file:DevInBandwidth:AVERAGE
    DEF:AvgOutBandwidth=$link_file:AvgOutBandwidth:AVERAGE
    DEF:DevOutBandwidth=$link_file:DevOutBandwidth:AVERAGE
                                                                                                                     
    CDEF:Null=AvgOutBandwidth,UN,0,*
                                                                                                                     
    CDEF:NAvgOutBandwidth=0,AvgOutBandwidth,-
    CDEF:NDevOutBandwidth=0,DevOutBandwidth,-

$a
$s                                                                                                                     
                                                                                                                     
\tLINE2:Null#000000:
><P>\n
EOR

	$rrd_quality1.="\tDEF:${_ptp}_AvgQuality=$link_file:AvgQuality:AVERAGE\n";
	$rrd_quality2.=addData("${_ptp}_AvgQuality",$lcolor,"2$hostname","LINE2","dB");
#"\tLINE2:${_ptp}_AvgQuality${lcolor}:\"2$hostname\"\n";
#print "PTP=$ptp [$neighbors|$POINTOPOINT{$if}|$if|\n";

	} # type=Wireless
     } # foreach ptp

   } # foreach $if
   print MRTG "################# Latency key nodes #############\n";
   foreach $ip (sort keys %PINGNODE)
   {
	$pingnode=$PINGNODE{$ip};
	print MRTG<<EOMP;

Target[lat-$pingnode]: `$wlan_stats $node latency-$ip`
MaxBytes1[lat-$pingnode]: 100
MaxBytes2[lat-$pingnode]: 600
Title[lat-$pingnode]: Latency/PktLoss Analysis to $pingnode
PageTop[lat-$pingnode]: <H1>Latency/PktLoss to $pingnode</H1>
Options[lat-$pingnode]: transparent, gauge, nopercent
Legendi[lat-$pingnode]: PacketLoss%
Legendo[lat-$pingnode]: Avg. Latency (ms)
ShortLegend[lat-$pingnode]: %/ms
YLegend[lat-$pingnode]: %/ms
WithPeak[lat-$pingnode]: wmy

EOMP
   }
   close(MRTG);
   $rrd_trafficSi=~s/,$//;
   $rrd_trafficSo=~s/,$//;
   $color="#000000";
   $rrd_traffic.=$rrd_traffic1 ."\n". $rrd_traffic2 ."\n".
	$rrd_traffic3 ."\n". $rrd_traffic4 ."\n". $rrd_traffic5 ."\n".
	"\tLINE2:Null#000000:" . "$rrd_trafficSi\n$rrd_trafficSo\n" 
			. addData("TOTALi",$color,"totaal in",'LINE1',"%sB/s")
 			. addData("TOTALo",$color,"totaal out",'LINE1',"%sB/s") . "\n>\n\n";

   $rrd_routes.="${rrd_routes1}\n${rrd_routes2}\n${rrd_routesS}\n" 
		. addData("TOTAL",$color,"totaal",'LINE1') . ">\n<P>\n\n";
   $rrd_channels.=$rrd_channels1 ."\n". $rrd_channels2 ."><P>\n\n";
   $rrd_quality.=$rrd_quality1 ."\n". $rrd_quality2 ."><P>\n\n";

   if ($node=~/proxy/){$proxy="<P><A HREF=proxy.cgi?RRD_START=-24h>Proxy stats</A><P>\n";}
   else {$proxy='';}
   print CGI <<EOC;
$rrd_traffic
$rrd_routes
$rrd_quality
$rrd_channels
$rrd_links
$proxy
</P>
</BODY>
</HTML>
EOC

   close(CGI);
   chmod(0755,"$rrd_cgi_file.$$");
   unlink($rrd_cgi_file);
   rename("$rrd_cgi_file.$$",$rrd_cgi_file);
   system("indexmaker $filename > $dir/index.html");

   } elsif ($nodetype=~/HNode/i)
   {
     $XY{$ip}=$node;
     if ($MODE=~/managed/i)   {$XY{"${node}-S"}.=":$ESSID==:";}
     else {$XY{"${node}-M"}.=":$ESSID=$ip=wi0:";$XY{"${ESSID}-E"}=$node;}
  
   }
} #make_cfg


sub parse_config
{
  foreach $if (keys %config)
  {
     $cfg=$config{$if};
#if (! $html) {print "Parsing interface: $if\n";}
     while ($cfg)
     {
        $cfg=~s/^([^\n\r]+)[\r\n]*//m;
        $line=$1;
        $line=~s/\s*#.*//;
        if ((($name,$value)=split(/=/,$line)) eq 2)
        {
#print "VAL($name)=$value\n";
           $doit="if (exists(\$$name\{\"$if\"\})) {\$$name\{\"$if\"\}.=\"$separator$value\";} else {\$$name\{\"$if\"\}.=\"$value\";}";

#print "DOIT: [$doit]\n";
           eval($doit);
        }
#print "CFG:[$cfg]\n";
        $cfg=~s/[\r\n]*$//m;
     }
  }
#if ($functions_only<1) {print "Done parsing config.\n";}
}


sub check_rrd_system_file
{
  local($file,$timeout)=@_;

  if ( -e $file) {return();}
  
  $DS=<<EODS;
DS:uptime:GAUGE:$timeout:0:9999
DS:users:GAUGE:$timeout:0:999
DS:processes:GAUGE:$timeout:0:9999
DS:IRQs:GAUGE:$timeout:0:99999999
DS:idle:GAUGE:$timeout:0:9999
DS:five:GAUGE:$timeout:0:999
DS:ten:GAUGE:$timeout:0:999
DS:fifteen:GAUGE:$timeout:0:999
DS:memTotalSwap:GAUGE:$timeout:0:999999999999999999
DS:memAvailSwap:GAUGE:$timeout:0:999999999999999999
DS:memTotalReal:GAUGE:$timeout:0:999999999999999999
DS:memAvailReal:GAUGE:$timeout:0:999999999999999999
DS:memTotalFree:GAUGE:$timeout:0:999999999999999999
DS:memMinimumSwap:GAUGE:$timeout:0:999999999999999999
DS:memShared:GAUGE:$timeout:0:999999999999999999
DS:memBuffer:GAUGE:$timeout:0:999999999999999999
DS:memCached:GAUGE:$timeout:0:999999999999999999
DS:memSwapError:GAUGE:$timeout:0:999999999999999999
DS:_size:GAUGE:$timeout:0:999999999999999999
DS:tmp_size:GAUGE:$timeout:0:999999999999999999
DS:var_size:GAUGE:$timeout:0:999999999999999999
DS:usr_size:GAUGE:$timeout:0:999999999999999999
DS:local_size:GAUGE:$timeout:0:999999999999999999
DS:_used:GAUGE:$timeout:0:999999999999999999
DS:tmp_used:GAUGE:$timeout:0:999999999999999999
DS:var_used:GAUGE:$timeout:0:999999999999999999
DS:usr_used:GAUGE:$timeout:0:999999999999999999
DS:local_used:GAUGE:$timeout:0:999999999999999999
DS:empty0:GAUGE:$timeout:0:999999999999999999 
DS:empty1:GAUGE:$timeout:0:999999999999999999 
DS:empty2:GAUGE:$timeout:0:999999999999999999 
DS:empty3:GAUGE:$timeout:0:999999999999999999 
DS:empty4:GAUGE:$timeout:0:999999999999999999 
DS:empty5:GAUGE:$timeout:0:999999999999999999 
DS:empty6:GAUGE:$timeout:0:999999999999999999 
DS:empty7:GAUGE:$timeout:0:999999999999999999 
DS:empty8:GAUGE:$timeout:0:999999999999999999 
DS:empty9:GAUGE:$timeout:0:999999999999999999 
DS:empty10:GAUGE:$timeout:0:999999999999999999 
EODS

  $DS=~s/\n/ /gi;
  system("rrdtool create $file -s 300 $DS $RRA");

}

sub check_rrd_interface
{
  local($dir,$if,$timeout)=@_;
  local($file)="$dir/int-${if}.rrd";

  if ( -e $file) {return();}
  
  $DS=<<EODS;
 DS:bytes_in:COUNTER:700:0:999999999999999999
 DS:errors_in:COUNTER:700:0:999999999999999999
 DS:Ucast_in:COUNTER:700:0:999999999999999999
 DS:NUcast_in:COUNTER:700:0:999999999999999999

 DS:bytes_out:COUNTER:700:0:999999999999999999
 DS:errors_out:COUNTER:700:0:999999999999999999
 DS:Ucast_out:COUNTER:700:0:999999999999999999
 DS:NUcast_out:COUNTER:700:0:999999999999999999

 DS:beacons:GAUGE:700:0:99999
 DS:channel:GAUGE:700:0:15
 DS:TXspeed:GAUGE:700:0:99999999999
 DS:routes:GAUGE:700:0:9999
 DS:users:GAUGE:700:0:999
 
EODS
  $DS=~s/\n/ /gi;
  system("rrdtool create $file -s 300 $DS $RRA");

}


sub check_rrd_links
{
  local($dir,$if,$timeout)=@_;
  local($desc)=$SDESC{$if};
  local($file);

  foreach $ip (split(/\s+/,$NEIGHBORS{$if} . " " . $POINT_TO_POINT{$if}))
  {
   $ip=~s/\s+//gi;
   if ($ip eq '' ) {next;}
print "Doing $node link to $ip ($desc).\n";
  $file="$dir/link-$ip.rrd";

  if ( -e $file) {return();}
  
  $DS=<<EODS;
 DS:InBytes:COUNTER:$timeout:0:999999999999999999
 DS:AvgInBandwidth:GAUGE:$timeout:0:999999999999999999
 DS:DevInBandwidth:GAUGE:$timeout:0:999999999999999999

 DS:OutBytes:COUNTER:$timeout:0:999999999999999999
 DS:AvgOutBandwidth:GAUGE:$timeout:0:999999999999999999
 DS:DevOutBandwidth:GAUGE:$timeout:0:999999999999999999

 DS:AvgSignal:GAUGE:$timeout:-10000:999999999999999999
 DS:AvgNoise:GAUGE:$timeout:-10000:999999999999999999
 DS:AvgQuality:GAUGE:$timeout:0:999999999999999999

 DS:routes:GAUGE:$timeout:0:999999999999999999
 DS:pktloss:GAUGE:$timeout:0:999999999999999999
 DS:latency:GAUGE:$timeout:0:999999999999999999

EODS
  $DS=~s/\n/ /gi;
  system("rrdtool create $file -s 300 $DS $RRA");
  }
}

sub check_rrd_icmp_file
{
  local($file,$timeout)=@_;

  if ( -e $file) {return();}
  
  $DS=<<EODS;
DS:icmpInMsgs:COUNTER:$timeout:0:999999999999999999
DS:icmpInErrors:COUNTER:$timeout:0:999999999999999999
DS:icmpInDestUnreachs:COUNTER:$timeout:0:999999999999999999
DS:icmpInTimeExcds:COUNTER:$timeout:0:999999999999999999
DS:icmpInRedirects:COUNTER:$timeout:0:999999999999999999
DS:icmpInEchos:COUNTER:$timeout:0:999999999999999999
DS:icmpInEchoReps:COUNTER:$timeout:0:999999999999999999

DS:icmpOutMsgs:COUNTER:$timeout:0:999999999999999999
DS:icmpOutErrors:COUNTER:$timeout:0:999999999999999999
DS:icmpOutDestUnreachs:COUNTER:$timeout:0:999999999999999999
DS:icmpOutTimeExcds:COUNTER:$timeout:0:999999999999999999
DS:icmpOutSrcQuenchs:COUNTER:$timeout:0:999999999999999999
DS:icmpOutRedirects:COUNTER:$timeout:0:999999999999999999
DS:icmpOutEchos:COUNTER:$timeout:0:999999999999999999
DS:icmpOutEchoReps:COUNTER:$timeout:0:999999999999999999

EODS
  $DS=~s/\n/ /gi;
  system("rrdtool create $file -s 300 $DS $RRA");

}



sub init_cgi
{
  local($now);$now=localtime(time());
  return <<EOS;
#!/usr/bin/rrdcgi

<!-- for $node revision: $revision created at: $now -->

<HTML>
<HEAD><TITLE><RRD::CV RRD_NODE> Interface statistieken <RRD::CV RRD_START></TITLE></HEAD>
<BODY>
<H1><RRD::CV RRD_NODE> Interface statistieken <RRD::CV RRD_START></H1>
<P>

<RRD::GOODFOR -300>

Start graph at:
<FORM><INPUT NAME=RRD_START TYPE=RADIO VALUE="-1h"> -1,
      <INPUT NAME=RRD_START TYPE=RADIO VALUE="-4h"> -4,
      <INPUT NAME=RRD_START TYPE=RADIO VALUE="-8h"> -8.
      <INPUT NAME=RRD_START TYPE=RADIO VALUE="-24h" CHECKED> -24 hours.
      <INPUT NAME=RRD_START TYPE=RADIO VALUE="-4d"> -4 days.
      <INPUT NAME=RRD_START TYPE=RADIO VALUE="-7d"> -7 days.
      <INPUT NAME=RRD_START TYPE=RADIO VALUE="-1m"> -1 month.
      <INPUT NAME=RRD_START TYPE=RADIO VALUE="-6m"> -6 months.
      <INPUT NAME=RRD_START TYPE=RADIO VALUE="-1y"> -1 year.
      <INPUT TYPE=SUBMIT VALUE="Graph">
      <INPUT TYPE=HIDDEN NAME=RRD_NODE VALUE=<RRD::CV::QUOTE RRD_NODE>>
</FORM>

EOS
}

sub RRD_init
{
  local($Desc,$sdesc,$Yunit,$height,$log,$end)=@_;
  if ($sdesc eq '')
        {$sdesc=lc($Desc);$sdesc=~s/\s+/_/gi;$sdesc=~s/[^a-z0-9]//gi;}
  if ($Yunit eq '') {$Yunit='Bytes/s';}
  if ($height) {$heigth="--height $height";}
  if ($log) {$log="-logarithmic";}
  if ($end eq '') {$end="now";}
  return <<EOS;
<RRD::GRAPH $rrdimg/$node/$sdesc<RRD::CV::PATH RRD_START>.png
   -a PNG -v '$Yunit' $heigth $log
   --alt-autoscale-max
   --imginfo '<IMG SRC=/rrd-img/$node/\%s WIDTH=\%lu HEIGHT=\%lu >'
   --lazy --start <RRD::CV::QUOTE RRD_START>
   --end $end --title="$Desc $node"
$comment
EOS
}


sub addData
{
  local($p,$color,$pdesc,$type,$unit)=@_;
  if ($unit=~s/^%s//) {$unit="%s" . sprintf("%-4s",$unit);}
  else {$unit=sprintf("%-5s",$unit);}
  $pdesc=sprintf("%-18s",$pdesc);

  local($result)=<<EOC;
\t$type:$p$color:"$pdesc"
\tCDEF:U$p=$p,UN,0,$p,IF
\tGPRINT:U$p:MIN:"%6.1lf $unit"
\tGPRINT:U$p:MAX:"%6.1lf $unit"
\tGPRINT:U$p:AVERAGE:"%6.1lf $unit"
\tGPRINT:U$p:LAST:"%6.1lf $unit\\n"
EOC
 return($result);
}