[ipfire-2.x.git] / config / cfgroot / net-traffic-lib.pl

#!/usr/bin/perl
#
# $Id: net-traffic-lib.pl,v 1.4 2005/03/17 11:43:55 dotzball Exp $
#
# Summarize all IP accounting files from start to end time
#
# Copyright (C) 1997 - 2000 Moritz Both
#		2001 - 2002 Al Zaharov
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
#
# The author can be reached via email: moritz@daneben.de, or by
# snail mail: Moritz Both, Im Moore 26, 30167 Hannover,
#             Germany. Phone: +49-511-1610129
#
#
# 22 June 2004 By Achim Weber dotzball@users.sourceforge.net
#	- changed to use it with Net-Traffic Addon
#	- renamed to avoid issues when calling this file or original ipacsum
#	- this file is net-traffic-lib.pl for IPCop 1.4.0
#

package Traffic;

use 5.000;
use Getopt::Long;
use POSIX qw(strftime);
use Time::Local;
use Socket;
use IO::Handle;

$|=1; # line buffering

@moff = (0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 );

# =()<$datdelim="@<DATDELIM>@";>()=
$datdelim="#-#-#-#-#";
# =()<$prefix="@<prefix>@";>()=
$prefix="/usr";
# =()<$exec_prefix="@<exec_prefix>@";>()=
$exec_prefix="${prefix}";
# =()<$INSTALLPATH="@<INSTALLPATH>@";>()=
$INSTALLPATH="${exec_prefix}/sbin";
$datdir="/var/log/ip-acct";

$me=$0;
$me =~ s|^.*/([^/]+)$|$1|;
$now = time;
$fetchipac="$INSTALLPATH/fetchipac";
$rule_regex = ".*";				# match rules with this regex only

## Net-Traffic variables ##
my %allDays = ();
my $allDaysBytes;
my $tzoffset = 0;
my $displayMode = "daily";
my ($curMonth, $curYear);
${Traffic::blue_in} = 'incoming BLUE';
${Traffic::green_in} = 'incoming GREEN';
${Traffic::orange_in} = 'incoming ORANGE';
${Traffic::red_in} = 'incoming RED';
${Traffic::blue_out} = 'outgoing BLUE';
${Traffic::green_out} = 'outgoing GREEN';
${Traffic::orange_out} = 'outgoing ORANGE';
${Traffic::red_out} = 'outgoing RED';


sub calcTraffic{
	$allDaysBytes = shift;
	$starttime = shift;
	$endtime = shift;
	$displayMode = shift;

	$starttime =~ /^(\d\d\d\d)(\d\d)/;
	$curYear = $1;
	$curMonth = $2;

	# calculate time zone offset in seconds - use difference of output of date
	# command and time function, round it
	$tzoffset = time-timegm(localtime());
	$machine_name = undef;

	$starttime = makeunixtime($starttime);
	$endtime = makeunixtime($endtime);
	$endtime -= 1;

	# options that we need to pass to fetchipac if we call it.
	$fetchipac_options = "--directory=$datdir";

	$endtime = $now if ($endtime > $now);
	$starttime = 0 if ($starttime < 0);
	$mystarttime = &makemydailytime($starttime);
	$myendtime = &makemydailytime($endtime);
	%rule_firstfile =  %rule_lastfile = ( );

	# find out which timestamps we need to read.
	# remember newest timestamp before starttime so we know when data for
	# the first file starts
	# also remember oldest timestamp after end time
	$newest_timestamp_before_starttime = "";
	$oldest_timestamp_after_endtime = "";
	open(DATA, "$fetchipac $fetchipac_options --timestamps=$starttime,$endtime ".
			"--machine-output-format|") || die "$me: cant run $fetchipac\n";
	# the first thing is the timestamp count
	$count=<DATA>;
	if ($count == 0) {
		return ();
	}
	while(<DATA>)
	{
		if (/^(.)\s(\d+)$/) {
			my $ts = $2;
			if ($1 eq "-") {
				$newest_timestamp_before_starttime=$ts;
			}
			elsif ($1 eq "+") {
				$oldest_timestamp_after_endtime=$ts;
			}
			elsif ($1 eq "*") {
				push(@timestamps, $ts);
			}
			else {
				die "$me: illegal output from $fetchipac: \"$_\"\n";
			}
		}
		else {
			die "$me: illegal output from $fetchipac: \"$_\"\n";
		}
	}
	close DATA;

	push(@timestamps, $oldest_timestamp_after_endtime) 
		if ($oldest_timestamp_after_endtime);
	unshift(@timestamps, $newest_timestamp_before_starttime) 
		if ($newest_timestamp_before_starttime);

	$rulenumber = 0;

	# read all data we need and put the data into memory.
	&read_data;

	@days_sorted = sort keys %allDays;
	return @days_sorted;
}
##########################
# END OF MAIN PROGRAM
##########################

# read all data (@timestmaps contains the timestamps, must be sorted!)
# and put the data into our global memory data
# structures. special care must be taken with data of the first and
# the last timestamps we read, since we only want data which is from our
# time frame. Furthermore, data from before and after this time frame
# must be preserved in special data structures because we might replace
# them (option --replace) and have to write extra data for these times
# then.
sub read_data {
	my $run_s;
	my $s;
	my $i;
	my $in_time = 0;
	my $after_time = 0;

	my $curDay = $starttime;

	# feed the timestamp list to fetchipac on its stdin.
	socketpair(CHILD, PARENT, AF_UNIX, SOCK_STREAM, PF_UNSPEC)
			    or die "socketpair: $!";
	CHILD->autoflush(1);
	PARENT->autoflush(1);
	my $pid = open(CHILD, "-|");
	die "$me: can't fork: $!\n" unless defined $pid;
	if ($pid == 0) {
		# child
		close CHILD;
		open(FETCHIPAC, "|$fetchipac $fetchipac_options --record "
				."--machine-output-format")
			or die "$me: cant exec fetchipac\n";

#this is much more efficient than the original code (Manfred Weihs)
# and it adds more troubles than solves (Al Zakharov)
                if ($timestamps[0] == $newest_timestamp_before_starttime) {
                        print(FETCHIPAC $timestamps[1],"-",$timestamps[$count],"\n");
                } else {
                        print(FETCHIPAC $timestamps[0],"-",$timestamps[$count-1],"\n");
		}
		close(FETCHIPAC);
		close(PARENT);
		exit;
	}
	close PARENT;

	my $laststamp = undef;
	$laststamp = $newest_timestamp_before_starttime
		if ($newest_timestamp_before_starttime);
	$i = 0;
	$i++ if ($laststamp);
	while (<CHILD>) {
		# first line of fetchipac output: "ADD"
		/^ADD\s*$/i or die "$me: bad line from fetchipac: $_\n";
		# second line of fetchipac output: timestamp no_of_records
		$_ = <CHILD> || last;
		/^(\d+)\s(\d+)$/ or die "$me: bad line from fetchipac: $_\n";
		my $timestamp = int $1;
		my $number_of_records = int $2;
		my $do_collect = 1;

		if ($displayMode =~ /^daily/) {
			# increment Day aslong current timestamp is not in current Day
			while ( ($timestamp-$curDay) > 86399) {
				$curDay += 86400;
			}
		}
		else
		{
			my @dummy =  localtime($timestamp);
			# increment Month aslong current timestamp is not in current Month
			while ($curMonth < ($dummy[4]+1) || $curYear<($dummy[5]+1900)) {
				$curMonth++;
				if ($curMonth > 12) {
					$curMonth = 1;
					$curYear++;
				}
				my $newMonth = $curYear;				
				$newMonth .= $curMonth < 10 ? "0".$curMonth."01" : $curMonth."01";
				$newMonth .= "01";
				$curDay = &makeunixtime($newMonth);
			}
		}

		if ($timestamp < $starttime) {
			# this record is too old, we dont need the data.
			# However, the timestamp gives us a clue on the 
			# time period the next item covers.
			$do_collect = 0;
		}

		my $irec;
		# read each record
		my $data = &read_data_record(CHILD, $number_of_records);

		if ($do_collect && $in_time == 0) {
			# the data is from after starttime. if it is the
			# first one, split the data (if we know for how
			# long this data is valid, and if $laststamp is not
			# equal to $starttime in which case the split is
			# redundant). If we don't have a clue about the 
			# last file time before our first file was created,
			# we do not know how much of the file data is in our
			# time frame. we assume everything belongs to us.
			$in_time = 1;
#			if ($laststamp && $laststamp != $starttime) {
			if ($laststamp && $laststamp != $newest_timestamp_before_starttime) {
				my $newdata = &split_data($data,
					$laststamp, $timestamp, $starttime);
				$glb_data_before = $data;
				$data = $newdata;
				$laststamp = $starttime;
			}
		}

		if ($timestamp > $endtime) {
			# this data is too new, but the data in it may have
			# begun within our time frame. (if endtime eq laststamp
			# we do a redundant split here, too - it works for now
			# and --replace relies on it, but it is ugly.)
			if ($after_time == 0) {
				$after_time = 1;
				if ($laststamp) {
					$glb_data_after =
						&split_data($data,$laststamp,$timestamp,$endtime);
				} else {
					$do_collect = 0;
				}
			} else {
				$do_collect = 0;	# just too new.
			}
		}

		if ($do_collect) {
			&collect_data($data, $i, $curDay);
		}
		$laststamp = $timestamp;
		$i++;
	}
	close CHILD;
	wait;
}

# split the data in $1 (format as from read_data) into a pair of two
# such data sets. The set referenced to as $1 will afterwards contain
# the first part of the data, another set which is returned contains
# the second part of the data.
# interpret the data as having start time=$2 and end time=$3 and split
# time=$4
sub split_data {
	my $data = shift;
	my $mstart = shift;
	my $mend = shift;
	my $msplit = shift;

	# calculate factors for multiplications
	my $ust = $mstart;
	my $uperiod = $mend - $ust;
	my $usplit = $msplit - $ust;

	if ($uperiod < 0) {
		# hmmm? die Daten sind rueckwaerts???
		$uperiod = -$uperiod;
	}
	my $fac1;
	if ($usplit < 0) {
		$fac1 = 0;
	}
	elsif ($usplit > $uperiod) {
		$fac1 = 1;
	}
	else {
		$fac1 = $usplit / $uperiod;
	}

	# $fac1 now says us how much weight the first result has.
	# initialize the set we will return.
	my @ret = ( );
	
	foreach $set (@$data) {
		my ($rule, $bytes, $pkts) = @$set;
		$$set[1] = int($bytes * $fac1 + 0.5);
		$$set[2] = int($pkts * $fac1 + 0.5);
		push(@ret, [ $rule, $bytes - $$set[1], $pkts - $$set[2] ]);
	}
	return \@ret;
}

# put data from one file into global data structures
# must be called in correct sorted file name order to set rules_lastfile
# and rules_firstfile (which are currently useless)
# arguments: 
# $1=index number of file; $2 = reference to array with data from file
sub collect_data {
	my($filedata, $ifile, $i, $day);

	$filedata = shift;
	$ifile=shift;
	$day =shift;

	# if day first appeared in this file, initialize its
	# life.
	if (!defined($allDays{$day})) {
		return if (&init_filter_id($day));
		$allDays{$day} = $rulenumber++;
	}

	for ($i=0; $i<=$#$filedata; $i++) {
		my $set = $$filedata[$i];
		my $rule = $$set[0];
		my $bytes = $$set[1];
		my $pkts = $$set[2];
		
		$_ = $rule;
		/^(.*) \(.*$/;
		$_ = $1;
		/^forwarded (.*)$/;
		$rule = $1;
		$allDaysBytes->{$day}{$rule} += $bytes;
	}
}

# initialize data variables for a new rule - if it is new
sub init_filter_id {
	my($s, $ifile) = @_;

	if (!defined $allDaysBytes->{$s}) {
		if ($displayMode =~ /^daily/) {
			my $newDay = &makemydailytime($s);
			$newDay =~ /^\d\d\d\d-(\d\d)-\d\d$/;

			return 1 if ($1 > $curMonth && $displayMode ne "daily_multi");	
			
			$allDaysBytes->{$s}{'Day'} = $newDay;
		}
		else {
			$allDaysBytes->{$s}{'Day'} = &makemymonthlytime($s);
		}
		$allDaysBytes->{$s}{${Traffic::blue_in}} = int(0);
		$allDaysBytes->{$s}{${Traffic::green_in}} = int(0);
		$allDaysBytes->{$s}{${Traffic::orange_in}} = int(0);
		$allDaysBytes->{$s}{${Traffic::red_in}} = int(0);
		$allDaysBytes->{$s}{${Traffic::blue_out}} = int(0);
		$allDaysBytes->{$s}{${Traffic::green_out}} = int(0);
		$allDaysBytes->{$s}{${Traffic::orange_out}} = int(0);
		$allDaysBytes->{$s}{${Traffic::red_out}} = int(0);
	}
	return 0;
}

# read data record from filehandle $1
# number of records is $2
# Return value: reference to array a of length n; 
# 	n is the number of rules
# 	each field in a is an array aa with 3 fields
#	the fields in arrays aa are: [0]=name of rule; [1]=byte count;
#	[2]=packet count
# function does not use global variables
sub read_data_record {
	my($file, $number_of_records, $beforedata, $indata, $i, $irec);
	my($pkts, $bytes, $rule);
	my(@result);

	$file=shift;
	$number_of_records = shift;
	$indata=0;
	$beforedata=1;

	for($irec = 0; $irec < $number_of_records; $irec++) {
		$_ = <$file>;
		chop;
		/^\(\s*(.*)$/ or die "$me: bad line from fetchipac (expecting machine name): $_\n";
		$machine_name = $1; 	# remember final machine name
		while(<$file>) {
			last if (/^\)$/);	# terminating line ')'
			/^(\d+)\s(\d+)\s\|(.*)\|$/
				or die "$me: bad line from fetchipac (expecting rule item): $_\n";
			$bytes = $1;
			$pkts = $2;
			$rule = $3;
			if ($rule =~ /$rule_regex/) {
				push(@result, [ $rule, $bytes, $pkts]);
			}
		}
	}
	# read another emtpy line (data format consistency)
	$_ = <$file>;
	die "$me: bad data from fetchipac (expected emtpy line): $_\n"
		if ($_ !~ /^$/);
	\@result;
}

# given a string in format YYYYMMDD[hh[mm[ss]]], make unix time
# use time zone offset $tzoffset (input=wall clock time, output=UTC)
sub makeunixtime {
	my($y, $m, $d, $h, $i, $e);
	$s = shift;

	$h=0; $i=0; $e=0;
	if ($s =~ /^(\d\d\d\d)(\d\d)(\d\d)/) {
		($y, $m, $d) = ($1, $2, $3);
		if ($s =~ /^\d\d\d\d\d\d\d\d-?(\d\d)/) {
			$h=$1;
			if ($s =~ /^\d\d\d\d\d\d\d\d-?\d\d(\d\d)/) {
				$i=$1;
				if ($s =~ /^\d\d\d\d\d\d\d\d-?\d\d\d\d(\d\d)/) {
					$e=$1;
				}
			}
		}
	}
	else {
		return 0;
	}

	$y-=1970;
	$s = (($y)*365) + int(($y+2)/4) + $moff[$m-1] + $d-1;
	$s-- if (($y+2)%4 == 0 && $m < 3);
	$s*86400 + $h*3600 + $i*60 + $e + $tzoffset;
}

# return the given unix time in localtime in "mydaily" time format
sub makemydailytime {
	my($s)=shift;

	my($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) =
                                                 localtime($s);
	return sprintf("%04d-%02d-%02d", 1900+$year, $mon+1, $mday);
}

# return the given unix time in localtime in "mymonthly" time format
sub makemymonthlytime {
	my($s)=shift;

	my($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) =
                                                 localtime($s);
	return sprintf("%04d-%02d", 1900+$year, $mon+1);
}

# EOF
Commit	Line	Data
10a04d70 MT	1	#!/usr/bin/perl
	2	#
	3	# $Id: net-traffic-lib.pl,v 1.4 2005/03/17 11:43:55 dotzball Exp $
	4	#
	5	# Summarize all IP accounting files from start to end time
	6	#
	7	# Copyright (C) 1997 - 2000 Moritz Both
	8	# 2001 - 2002 Al Zaharov
	9	#
	10	# This program is free software; you can redistribute it and/or modify
	11	# it under the terms of the GNU General Public License as published by
	12	# the Free Software Foundation; either version 2 of the License, or
	13	# (at your option) any later version.
	14	#
	15	# This program is distributed in the hope that it will be useful,
	16	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	# GNU General Public License for more details.
	19	#
	20	# You should have received a copy of the GNU General Public License
	21	# along with this program; if not, write to the Free Software
	22	# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	23	#
	24	# The author can be reached via email: moritz@daneben.de, or by
	25	# snail mail: Moritz Both, Im Moore 26, 30167 Hannover,
	26	# Germany. Phone: +49-511-1610129
	27	#
	28	#
	29	# 22 June 2004 By Achim Weber dotzball@users.sourceforge.net
	30	# - changed to use it with Net-Traffic Addon
	31	# - renamed to avoid issues when calling this file or original ipacsum
	32	# - this file is net-traffic-lib.pl for IPCop 1.4.0
	33	#
	34
	35	package Traffic;
	36
	37	use 5.000;
	38	use Getopt::Long;
	39	use POSIX qw(strftime);
	40	use Time::Local;
	41	use Socket;
	42	use IO::Handle;
	43
	44	$\|=1; # line buffering
	45
	46	@moff = (0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 );
	47
	48	# =()<$datdelim="@<DATDELIM>@";>()=
	49	$datdelim="#-#-#-#-#";
	50	# =()<$prefix="@<prefix>@";>()=
	51	$prefix="/usr";
	52	# =()<$exec_prefix="@<exec_prefix>@";>()=
	53	$exec_prefix="${prefix}";
	54	# =()<$INSTALLPATH="@<INSTALLPATH>@";>()=
	55	$INSTALLPATH="${exec_prefix}/sbin";
	56	$datdir="/var/log/ip-acct";
	57
	58	$me=$0;
	59	$me =~ s\|^.*/([^/]+)$\|$1\|;
	60	$now = time;
	61	$fetchipac="$INSTALLPATH/fetchipac";
	62	$rule_regex = ".*"; # match rules with this regex only
	63
	64	## Net-Traffic variables ##
65	my %allDays = ();
66	my $allDaysBytes;
67	my $tzoffset = 0;
68	my $displayMode = "daily";
69	my ($curMonth, $curYear);
70	${Traffic::blue_in} = 'incoming BLUE';
71	${Traffic::green_in} = 'incoming GREEN';
72	${Traffic::orange_in} = 'incoming ORANGE';
73	${Traffic::red_in} = 'incoming RED';
74	${Traffic::blue_out} = 'outgoing BLUE';
75	${Traffic::green_out} = 'outgoing GREEN';
76	${Traffic::orange_out} = 'outgoing ORANGE';
77	${Traffic::red_out} = 'outgoing RED';
78
79
80	sub calcTraffic{
81	$allDaysBytes = shift;
82	$starttime = shift;
83	$endtime = shift;
84	$displayMode = shift;
85
86	$starttime =~ /^(\d\d\d\d)(\d\d)/;
87	$curYear = $1;
88	$curMonth = $2;
89
90	# calculate time zone offset in seconds - use difference of output of date
91	# command and time function, round it
92	$tzoffset = time-timegm(localtime());
93	$machine_name = undef;
94
95	$starttime = makeunixtime($starttime);
96	$endtime = makeunixtime($endtime);
97	$endtime -= 1;
98
99	# options that we need to pass to fetchipac if we call it.
100	$fetchipac_options = "--directory=$datdir";
101
102	$endtime = $now if ($endtime > $now);
103	$starttime = 0 if ($starttime < 0);
104	$mystarttime = &makemydailytime($starttime);
105	$myendtime = &makemydailytime($endtime);
106	%rule_firstfile = %rule_lastfile = ( );
107
108	# find out which timestamps we need to read.
109	# remember newest timestamp before starttime so we know when data for
110	# the first file starts
111	# also remember oldest timestamp after end time
112	$newest_timestamp_before_starttime = "";
113	$oldest_timestamp_after_endtime = "";
114	open(DATA, "$fetchipac $fetchipac_options --timestamps=$starttime,$endtime ".
115	"--machine-output-format\|") \|\| die "$me: cant run $fetchipac\n";
116	# the first thing is the timestamp count
117	$count=<DATA>;
118	if ($count == 0) {
119	return ();
120	}
121	while(<DATA>)
122	{
123	if (/^(.)\s(\d+)$/) {
124	my $ts = $2;
125	if ($1 eq "-") {
126	$newest_timestamp_before_starttime=$ts;
127	}
128	elsif ($1 eq "+") {
129	$oldest_timestamp_after_endtime=$ts;
130	}
131	elsif ($1 eq "*") {
132	push(@timestamps, $ts);
133	}
134	else {
135	die "$me: illegal output from $fetchipac: \"$_\"\n";
136	}
137	}
138	else {
139	die "$me: illegal output from $fetchipac: \"$_\"\n";
140	}
141	}
142	close DATA;
143
144	push(@timestamps, $oldest_timestamp_after_endtime)
145	if ($oldest_timestamp_after_endtime);
146	unshift(@timestamps, $newest_timestamp_before_starttime)
147	if ($newest_timestamp_before_starttime);
148
149	$rulenumber = 0;
150
151	# read all data we need and put the data into memory.
152	&read_data;
153
154	@days_sorted = sort keys %allDays;
155	return @days_sorted;
156	}
157	##########################
158	# END OF MAIN PROGRAM
159	##########################
160
161	# read all data (@timestmaps contains the timestamps, must be sorted!)
162	# and put the data into our global memory data
163	# structures. special care must be taken with data of the first and
164	# the last timestamps we read, since we only want data which is from our
165	# time frame. Furthermore, data from before and after this time frame
166	# must be preserved in special data structures because we might replace
167	# them (option --replace) and have to write extra data for these times
168	# then.
169	sub read_data {
170	my $run_s;
171	my $s;
172	my $i;
173	my $in_time = 0;
174	my $after_time = 0;
175
176	my $curDay = $starttime;
177
178	# feed the timestamp list to fetchipac on its stdin.
179	socketpair(CHILD, PARENT, AF_UNIX, SOCK_STREAM, PF_UNSPEC)
180	or die "socketpair: $!";
181	CHILD->autoflush(1);
182	PARENT->autoflush(1);
183	my $pid = open(CHILD, "-\|");
184	die "$me: can't fork: $!\n" unless defined $pid;
185	if ($pid == 0) {
186	# child
187	close CHILD;
188	open(FETCHIPAC, "\|$fetchipac $fetchipac_options --record "
189	."--machine-output-format")
190	or die "$me: cant exec fetchipac\n";
191
192	#this is much more efficient than the original code (Manfred Weihs)
193	# and it adds more troubles than solves (Al Zakharov)
194	if ($timestamps[0] == $newest_timestamp_before_starttime) {
195	print(FETCHIPAC $timestamps[1],"-",$timestamps[$count],"\n");
196	} else {
197	print(FETCHIPAC $timestamps[0],"-",$timestamps[$count-1],"\n");
198	}
199	close(FETCHIPAC);
200	close(PARENT);
201	exit;
202	}
203	close PARENT;
204
205	my $laststamp = undef;
206	$laststamp = $newest_timestamp_before_starttime
207	if ($newest_timestamp_before_starttime);
208	$i = 0;
209	$i++ if ($laststamp);
210	while (<CHILD>) {
211	# first line of fetchipac output: "ADD"
212	/^ADD\s*$/i or die "$me: bad line from fetchipac: $_\n";
213	# second line of fetchipac output: timestamp no_of_records
214	$_ = <CHILD> \|\| last;
215	/^(\d+)\s(\d+)$/ or die "$me: bad line from fetchipac: $_\n";
216	my $timestamp = int $1;
217	my $number_of_records = int $2;
218	my $do_collect = 1;
219
220	if ($displayMode =~ /^daily/) {
221	# increment Day aslong current timestamp is not in current Day
222	while ( ($timestamp-$curDay) > 86399) {
223	$curDay += 86400;
224	}
225	}
226	else
227	{
228	my @dummy = localtime($timestamp);
229	# increment Month aslong current timestamp is not in current Month
230	while ($curMonth < ($dummy[4]+1) \|\| $curYear<($dummy[5]+1900)) {
231	$curMonth++;
232	if ($curMonth > 12) {
233	$curMonth = 1;
234	$curYear++;
235	}
236	my $newMonth = $curYear;
237	$newMonth .= $curMonth < 10 ? "0".$curMonth."01" : $curMonth."01";
238	$newMonth .= "01";
239	$curDay = &makeunixtime($newMonth);
240	}
241	}
242
243	if ($timestamp < $starttime) {
244	# this record is too old, we dont need the data.
245	# However, the timestamp gives us a clue on the
246	# time period the next item covers.
247	$do_collect = 0;
248	}
249
250	my $irec;
251	# read each record
252	my $data = &read_data_record(CHILD, $number_of_records);
253
254	if ($do_collect && $in_time == 0) {
255	# the data is from after starttime. if it is the
256	# first one, split the data (if we know for how
257	# long this data is valid, and if $laststamp is not
258	# equal to $starttime in which case the split is
259	# redundant). If we don't have a clue about the
260	# last file time before our first file was created,
261	# we do not know how much of the file data is in our
262	# time frame. we assume everything belongs to us.
263	$in_time = 1;
264	# if ($laststamp && $laststamp != $starttime) {
265	if ($laststamp && $laststamp != $newest_timestamp_before_starttime) {
266	my $newdata = &split_data($data,
267	$laststamp, $timestamp, $starttime);
268	$glb_data_before = $data;
269	$data = $newdata;
270	$laststamp = $starttime;
271	}
272	}
273
274	if ($timestamp > $endtime) {
275	# this data is too new, but the data in it may have
276	# begun within our time frame. (if endtime eq laststamp
277	# we do a redundant split here, too - it works for now
278	# and --replace relies on it, but it is ugly.)
279	if ($after_time == 0) {
280	$after_time = 1;
281	if ($laststamp) {
282	$glb_data_after =
283	&split_data($data,$laststamp,$timestamp,$endtime);
284	} else {
285	$do_collect = 0;
286	}
287	} else {
288	$do_collect = 0; # just too new.
289	}
290	}
291
292	if ($do_collect) {
293	&collect_data($data, $i, $curDay);
294	}
295	$laststamp = $timestamp;
296	$i++;
297	}
298	close CHILD;
299	wait;
300	}
301
302	# split the data in $1 (format as from read_data) into a pair of two
303	# such data sets. The set referenced to as $1 will afterwards contain
304	# the first part of the data, another set which is returned contains
305	# the second part of the data.
306	# interpret the data as having start time=$2 and end time=$3 and split
307	# time=$4
308	sub split_data {
309	my $data = shift;
310	my $mstart = shift;
311	my $mend = shift;
312	my $msplit = shift;
313
314	# calculate factors for multiplications
315	my $ust = $mstart;
316	my $uperiod = $mend - $ust;
317	my $usplit = $msplit - $ust;
318
319	if ($uperiod < 0) {
320	# hmmm? die Daten sind rueckwaerts???
321	$uperiod = -$uperiod;
322	}
323	my $fac1;
324	if ($usplit < 0) {
325	$fac1 = 0;
326	}
327	elsif ($usplit > $uperiod) {
328	$fac1 = 1;
329	}
330	else {
331	$fac1 = $usplit / $uperiod;
332	}
333
334	# $fac1 now says us how much weight the first result has.
335	# initialize the set we will return.
336	my @ret = ( );
337
338	foreach $set (@$data) {
339	my ($rule, $bytes, $pkts) = @$set;
340	$$set[1] = int($bytes * $fac1 + 0.5);
341	$$set[2] = int($pkts * $fac1 + 0.5);
342	push(@ret, [ $rule, $bytes - $$set[1], $pkts - $$set[2] ]);
343	}
344	return \@ret;
345	}
346
347	# put data from one file into global data structures
348	# must be called in correct sorted file name order to set rules_lastfile
349	# and rules_firstfile (which are currently useless)
350	# arguments:
351	# $1=index number of file; $2 = reference to array with data from file
352	sub collect_data {
353	my($filedata, $ifile, $i, $day);
354
355	$filedata = shift;
356	$ifile=shift;
357	$day =shift;
358
359	# if day first appeared in this file, initialize its
360	# life.
361	if (!defined($allDays{$day})) {
362	return if (&init_filter_id($day));
363	$allDays{$day} = $rulenumber++;
364	}
365
366	for ($i=0; $i<=$#$filedata; $i++) {
367	my $set = $$filedata[$i];
368	my $rule = $$set[0];
369	my $bytes = $$set[1];
370	my $pkts = $$set[2];
371
372	$_ = $rule;
373	/^(.) \(.$/;
374	$_ = $1;
375	/^forwarded (.*)$/;
376	$rule = $1;
377	$allDaysBytes->{$day}{$rule} += $bytes;
378	}
379	}
380
381	# initialize data variables for a new rule - if it is new
382	sub init_filter_id {
383	my($s, $ifile) = @_;
384
385	if (!defined $allDaysBytes->{$s}) {
386	if ($displayMode =~ /^daily/) {
387	my $newDay = &makemydailytime($s);
388	$newDay =~ /^\d\d\d\d-(\d\d)-\d\d$/;
389
390	return 1 if ($1 > $curMonth && $displayMode ne "daily_multi");
391
392	$allDaysBytes->{$s}{'Day'} = $newDay;
393	}
394	else {
395	$allDaysBytes->{$s}{'Day'} = &makemymonthlytime($s);
396	}
397	$allDaysBytes->{$s}{${Traffic::blue_in}} = int(0);
398	$allDaysBytes->{$s}{${Traffic::green_in}} = int(0);
399	$allDaysBytes->{$s}{${Traffic::orange_in}} = int(0);
400	$allDaysBytes->{$s}{${Traffic::red_in}} = int(0);
401	$allDaysBytes->{$s}{${Traffic::blue_out}} = int(0);
402	$allDaysBytes->{$s}{${Traffic::green_out}} = int(0);
403	$allDaysBytes->{$s}{${Traffic::orange_out}} = int(0);
404	$allDaysBytes->{$s}{${Traffic::red_out}} = int(0);
405	}
406	return 0;
407	}
408
409	# read data record from filehandle $1
410	# number of records is $2
411	# Return value: reference to array a of length n;
412	# n is the number of rules
413	# each field in a is an array aa with 3 fields
414	# the fields in arrays aa are: [0]=name of rule; [1]=byte count;
415	# [2]=packet count
416	# function does not use global variables
417	sub read_data_record {
418	my($file, $number_of_records, $beforedata, $indata, $i, $irec);
419	my($pkts, $bytes, $rule);
420	my(@result);
421
422	$file=shift;
423	$number_of_records = shift;
424	$indata=0;
425	$beforedata=1;
426
427	for($irec = 0; $irec < $number_of_records; $irec++) {
428	$_ = <$file>;
429	chop;
430	/^\(\s(.)$/ or die "$me: bad line from fetchipac (expecting machine name): $_\n";
431	$machine_name = $1; # remember final machine name
432	while(<$file>) {
433	last if (/^\)$/); # terminating line ')'
434	/^(\d+)\s(\d+)\s\\|(.*)\\|$/
435	or die "$me: bad line from fetchipac (expecting rule item): $_\n";
436	$bytes = $1;
437	$pkts = $2;
438	$rule = $3;
439	if ($rule =~ /$rule_regex/) {
440	push(@result, [ $rule, $bytes, $pkts]);
441	}
442	}
443	}
444	# read another emtpy line (data format consistency)
445	$_ = <$file>;
446	die "$me: bad data from fetchipac (expected emtpy line): $_\n"
447	if ($_ !~ /^$/);
448	\@result;
449	}
450
451	# given a string in format YYYYMMDD[hh[mm[ss]]], make unix time
452	# use time zone offset $tzoffset (input=wall clock time, output=UTC)
453	sub makeunixtime {
454	my($y, $m, $d, $h, $i, $e);
455	$s = shift;
456
457	$h=0; $i=0; $e=0;
458	if ($s =~ /^(\d\d\d\d)(\d\d)(\d\d)/) {
459	($y, $m, $d) = ($1, $2, $3);
460	if ($s =~ /^\d\d\d\d\d\d\d\d-?(\d\d)/) {
461	$h=$1;
462	if ($s =~ /^\d\d\d\d\d\d\d\d-?\d\d(\d\d)/) {
463	$i=$1;
464	if ($s =~ /^\d\d\d\d\d\d\d\d-?\d\d\d\d(\d\d)/) {
465	$e=$1;
466	}
467	}
468	}
469	}
470	else {
471	return 0;
472	}
473
474	$y-=1970;
475	$s = (($y)*365) + int(($y+2)/4) + $moff[$m-1] + $d-1;
476	$s-- if (($y+2)%4 == 0 && $m < 3);
477	$s86400 + $h3600 + $i*60 + $e + $tzoffset;
478	}
479
480	# return the given unix time in localtime in "mydaily" time format
481	sub makemydailytime {
482	my($s)=shift;
483
484	my($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) =
485	localtime($s);
486	return sprintf("%04d-%02d-%02d", 1900+$year, $mon+1, $mday);
487	}
488
489	# return the given unix time in localtime in "mymonthly" time format
490	sub makemymonthlytime {
491	my($s)=shift;
492
493	my($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) =
494	localtime($s);
495	return sprintf("%04d-%02d", 1900+$year, $mon+1);
496	}
497
498	# EOF