0byt3m1n1

Path: /data/16/.snapshot/daily.2025-03-08_0010/ftplogs/ [ Home ]
File: ftpparse6.pl
#!/usr/local/bin/perl 


#Get date using system call :-/
use Date::Calc qw(:all);
($dow, $month, $day, $time, $tzone, $year) = split /\s+/ ,`date`,6;
chomp($year);
$month = Decode_Month($month);
($year, $month, $day) = Add_Delta_YMD($year, $month, $day, 0, 0, -6);
$month = (substr((Month_to_Text($month)),0,3));
$day = " $day" if ($day < 10);
#Done with arduous date game

#Build the list of one day log files from yesterday. 
opendir LOGS, "/data/16/ftplogs/";
@FILES = readdir(LOGS);
closedir LOGS;
$day =~ s/ //;
@LOGFILES = ();
@FILES = map("$_\n",@FILES);
foreach (@FILES) {
	chomp($_); 
	my $file = $_;
	if ($file =~ /$month$day/) {
		push (@LOGFILES,$file);}}
#List built
open OUT, ">/data/16/ftplogs/FTP-Server-Summary-$month-$day.txt";
open OFFENDERS, ">/data/16/ftplogs/FTP-Offenders-Summary-$month-$day.txt";
open TIMESUM, ">/data/16/ftplogs/FTP-Time-Summary-$month-$day.txt";



#Build list of people that have redirected login to something other than root
open PATHS, "</data/16/ftplogs/noslash.txt";
	while (<PATHS>) {
	chomp($_);
	$PATHHASH{$_} = 1;
}
close PATHS;
#Done building list 

foreach (@LOGFILES){
	chomp($_);
	$hostname = (split /\./ ,$_)[0];
	push(@HOSTS,$hostname);
	@FAIL = ();
	@OK = ();
	@OKLOGIN = ();
	@OKUPLOAD = ();
	@OKDLOAD = ();
	@OKCHMOD = ();
	@OKDELETE = ();
	@OKMKDIR = ();
	@OKRENAME = ();
	@OKRMDIR = ();
	@FLLOGIN = ();
	@FLUPLOAD = ();
	@FLDLOAD = ();
	@FLCHMOD = ();
	@FLDELETE = ();
	@FLMKDIR = ();
	@FLRENAME = ();
	@FLRMDIR = ();

	@FAIL = `grep "FAIL " /data/16/ftplogs/$_`;
	#$totfl = @FAIL;
	#$FAIL{$hostname} = $totfl;
	@OK = `grep "OK " /data/16/ftplogs/$_`;
	$totok = @OK;
	$OK{$hostname} = $totok;

	foreach (@OK) {
        	if ($_ =~ /LOGIN/) {
			first($_,\@OKLOGIN,\@ALLOKlogin,\@ALLOKlogintime,\@ICAFEOKlogin);
			$okNlogincnt = @OKLOGIN;
			$okNiclogincnt = @ICAFEOKlogin;
			$OKlogin{$hostname} = $okNlogincnt;}
		elsif ($_ =~ /UPLOAD/) {
			first($_,\@OKUPLOAD,\@ALLOKupload,\@ALLOKuploadtime,\@ICAFEOKupload);
			$okNuploadcnt = @OKUPLOAD;
			$okNicuploadcnt = @ICAFEOKupload;
			$OKupload{$hostname} = $okNuploadcnt;}
		elsif ($_ =~ /DOWNLOAD/) {
			first($_,\@OKDLOAD,\@ALLOKdnload,\@ALLOKdnloadtime,\@ICAFEOKdnload);
			$okNdnloadcnt = @OKDLOAD;
			$okNicdnloadcnt = @ICAFEOKdnload;
			$OKdnload{$hostname} = $okNdnloadcnt;}
		elsif ($_ =~ /CHMOD/) {
			first($_,\@OKCHMOD,\@ALLOKchmod,\@ALLOKchmodtime,\@ICAFEOKchmod);
			$okNchmodcnt = @OKCHMOD;
			$okNicchmodcnt = @ICAFEOKchmod;
			$OKchmod{$hostname} = $okNchmodcnt;}
		elsif ($_ =~ /DELETE/) {
			first($_,\@OKDELETE,\@ALLOKdelete,\@ALLOKdeletetime,\@ICAFEOKdelete);
			$okNdeletecnt = @OKDELETE;
			$okNicdeletecnt = @ICAFEOKdelete;
			$OKdelete{$hostname} = $okNdeletecnt;}
		elsif ($_ =~ /MKDIR/) {
			first($_,\@OKMKDIR,\@ALLOKmkdir,\@ALLOKmkdirtime,\@ICAFEOKmkdir);
			$okNmkdircnt = @OKMKDIR;
			$okNicmkdircnt = @ICAFEOKmkdir;
			$OKmkdir{$hostname} = $okNmkdircnt;}
		elsif ($_ =~ /RENAME/) {
			first($_,\@OKRENAME,\@ALLOKrename,\@ALLOKrenametime,\@ICAFEOKrename);
			$okNrenamecnt = @OKRENAME;
			$okNicrenamecnt = @ICAFEOKrename;
			$OKrename{$hostname} = $okNrenamecnt;}
		elsif ($_ =~ /RMDIR/) {
			first($_,\@OKRMDIR,\@ALLOKrmdir,\@ALLOKrmdirtime,\@ICAFEOKrmdir);
			$okNrmdircnt = @OKRMDIR;
			$okNicrmdircnt = @ICAFEOKrmdir;
			$OKrmdir{$hostname} = $okNrmdircnt;}
		}
		@OK = ();
	
	foreach (@FAIL) {
		if ($_ =~ /LOGIN/) {
			if ($_ !~ /%/) {
				$badun = cleanbatch($_);
				$badun = (split /\;/, ,$badun)[1];
				push(@BADUNAME, $badun);}
			elsif ($_ =~ /%/) {
				first($_,\@FLLOGIN,\@ALLFLlogin,\@ALLFLlogintime,\@ICAFEFLlogin);
				$flNlogincnt = @FLLOGIN;
				$flNiclogincnt = @ICAFEFLlogin;
				$FLlogin{$hostname} = $flNlogincnt;}
			}
		elsif ($_ =~ /UPLOAD/) {
			$count = pathtest($_);
			if ($count eq 1 ) {
				$rootpath = cleanbatch($_);
				push(@FLUProot, $rootpath);
				$fluprootcnt = @FLUProot;}
			elsif ($count gt 1) {
				first($_,\@FLUPLOAD,\@ALLFLupload,\@ALLFLuploadtime,\@ICAFEFLupload);
				$flNuploadcnt = @FLUPLOAD;
				$flNicuploadcnt = @ICAFEFLupload;
				$FLupload{$hostname} = $flNuploadcnt;}}
		elsif ($_ =~ /CHMOD/) {
			$count = pathtest($_);
			if ($count eq 1) {
				$rootpath = cleanbatch($_);
				push(@FLCHroot, $rootpath);
				$flchrootcnt = @FLCHroot;}
			elsif ($count gt 1){
				first($_,\@FLCHMOD,\@ALLFLchmod,\@ALLFLchmodtime,\@ICAFEFLchmod);
				$flNchmodcnt = @FLCHMOD;
				$flNicchmodcnt = @ICAFEFLchmod;
				$FLchmod{$hostname} = $flNchmodcnt;}}
		elsif ($_ =~ /DELETE/) {
			$count = pathtest($_);
			if ($count eq 1) {
				$rootpath = cleanbatch($_);
				push(@FLDEroot, $rootpath);
				$flderootcnt = @FLDEroot;}
			elsif ($count gt 1) {
				first($_,\@FLDELETE,\@ALLFLdelete,\@ALLFLdeletetime,\@ICAFEFLdelete);
				$flNdeletecnt = @FLDELETE;
				$flNicdeletecnt = @ICAFEFLdelete;
				$FLdelete{$hostname} = $flNdeletecnt;}}
		elsif ($_ =~ /DOWNLOAD/) {
			$count = pathtest($_);
			if ($count eq 1) {
				$rootpath = cleanbatch($_);
				push(@FLDLroot, $rootpath);
				$fldlrootcnt = @FLDLroot;}
			elsif ($count gt 1) {
				first($_,\@FLDLOAD,\@ALLFLdnload,\@ALLFLdnloadtime,\@ICAFEFLdnload);
				$flNdnloadcnt = @FLDLOAD;
				$flNicdnloadcnt = @ICAFEFLdnload;
				$FLdnload{$hostname} = $flNdnloadcnt;}}
		elsif ($_ =~ /MKDIR/) {
			$count = pathtest($_);
			if ($count eq 1) {
				$rootpath = cleanbatch($_);
				push(@FLMKroot, $rootpath);
				$flmkrootcnt = @FLMKroot;}
			elsif ($count gt 1) {
				first($_,\@FLMKDIR,\@ALLFLmkdir,\@ALLFLmkdirtime,\@ICAFEFLmkdir);
				$flNmkdircnt = @FLMKDIR;
				$flNicmkdircnt = @ICAFEFLmkdir;
				$FLmkdir{$hostname} = $flNmkdircnt;}}
		elsif ($_ =~ /RENAME/) {
			$count = pathtest($_);
			if ($count eq 1) {
				$rootpath = cleanbatch($_);
				push(@FLRNroot, $rootpath);
				$flrnrootcnt = @FLRNroot;}
			elsif ($count gt 1) {
				first($_,\@FLRENAME,\@ALLFLrename,\@ALLFLrenametime,\@ICAFEFLrename);
				$flNrenamecnt = @FLRENAME;
				$flNicrenamecnt = @ICAFEFLrename;
				$FLrename{$hostname} = $flNrenamecnt;}}
		elsif ($_ =~ /RMDIR/) {
			$count = pathtest($_);
			if ($count eq 1) {
				$rootpath = cleanbatch($_);
				push(@FLRMroot, $rootpath);
				$flrmrootcnt = @FLRMroot;}
			elsif ($count gt 1) {
				first($_,\@FLRMDIR,\@ALLFLrmdir,\@ALLFLrmdirtime,\@ICAFEFLrmdir);
				$flNrmdircnt = @FLRMDIR;
				$flNicrmdircnt = @ICAFEFLrmdir;
				$FLrmdir{$hostname} = $flNrmdircnt;}}
	}
	@FAIL = ();
	%PATHHASH = ();
}

#This is where we add up all the failed events for the platform.. This can't be done via @FAIL since that includes the wrong uname failures
$FAIL{FAIL} = 0; 
foreach (@HOSTS) {
	$FAIL{FAIL} = ($FAIL{FAIL} + $FLrmdir{$_} + $FLrename{$_} + $FLlogin{$_} + $FLupload{$_} + $FLchmod{$_} + $FLdelete{$_} + $FLdnload{$_} + $FLmkdir{$_});}

#This is where we add up all the failed events by metric. This is used for calculating percentages.
$FAIL{FLrmdir} = 0;
$FAIL{FLrename} = 0;
$FAIL{FLlogin} = 0;
$FAIL{FLupload} = 0;
$FAIL{FLchmod} = 0;
$FAIL{FLdelete} = 0;
$FAIL{FLdnload} = 0;
$FAIL{FLmkdir} = 0;

foreach (@HOSTS) {
	$FAIL{FLrmdir} = $FAIL{FLrmdir} + $FLrmdir{$_};
	$FAIL{FLrename} = $FAIL{FLrename} + $FLrename{$_};
	$FAIL{FLlogin} = $FAIL{FLlogin} + $FLlogin{$_};
	$FAIL{FLupload} = $FAIL{FLupload} + $FLupload{$_};
	$FAIL{FLchmod} = $FAIL{FLchmod} + $FLchmod{$_};
	$FAIL{FLdelete} = $FAIL{FLdelete} + $FLdelete{$_};
	$FAIL{FLdnload} = $FAIL{FLdnload} + $FLdnload{$_};
	$FAIL{FLmkdir} = $FAIL{FLmkdir} + $FLmkdir{$_};
	}
#This is where we sum up ALL the failures per host.
foreach (@HOSTS) {
	$FAIL{$_} = ($FLrmdir{$_} + $FLrename{$_} + $FLlogin{$_} + $FLupload{$_} + $FLchmod{$_} + $Fldelete{$_} + $FLdnload{$_} + $FL{$FLmkdir});}

print "$FAIL{FLrmdir}\n";
print "$FAIL{FLrename}\n";
print "$FAIL{FLlogin}\n";
print "$FAIL{FLupload}\n";
print "$FAIL{FLchmod}\n";
print "$FAIL{FLdelete}\n";
print "$FAIL{FLdnload}\n";
print "$FAIL{FLmkdir}\n";

@LOGINcnt = ();
count_unique(\@ALLOKlogin,\@LOGINcnt,"good non-unique login count of");
$okNlogincnt = $LOGINcnt[0];
$okUlogincnt = $LOGINcnt[1];
count_uniq_ic(\@ICAFEOKlogin,\@LOGINcnt);
$okNiclogincnt = $LOGINcnt[2];
$okUiclogincnt = $LOGINcnt[3];
@LOGINcnt = ();

@UPLOADcnt = ();
count_unique(\@ALLOKupload,\@UPLOADcnt,"good non-unique upload count of");
$okNuploadcnt = $UPLOADcnt[0];
$okUuploadcnt = $UPLOADcnt[1];
count_uniq_ic(\@ICAFEOKupload,\@UPLOADcnt);
$okNicuploadcnt = $UPLOADcnt[2];
$okUicuploadcnt = $UPLOADcnt[3];
@UPLOADcnt = ();

@DLOADcnt = ();
count_unique(\@ALLOKdnload,\@DLOADcnt,"good non-unique dload count of");
$okNdnloadcnt = @DLOADcnt[0];
$okUdnloadcnt = @DLOADcnt[1];
count_uniq_ic(\@ICAFEOKdnload,\@DLOADcnt);
$okNicdnloadcnt = @DLOADcnt[2];
$okUicdnloadcnt = @DLOADcnt[3];
@DLOADcnt = ();

@CHMODcnt = ();
count_unique(\@ALLOKchmod,\@CHMODcnt,"good non-unique chmod count of");
$okNchmodcnt = @CHMODcnt[0];
$okUchmodcnt = @CHMODcnt[1];
count_uniq_ic(\@ICAFEOKchmod,\@CHMODcnt);
$okNicchmodcnt = @CHMODcnt[2];
$okUicchmodcnt = @CHMODcnt[3];
@CHMODcnt = ();

@DELETEcnt = ();
count_unique(\@ALLOKdelete,\@DELETEcnt,"good non-unique delete count of");
$okNdeletecnt = @DELETEcnt[0];
$okUdeletecnt = @DELETEcnt[1];
count_uniq_ic(\@ICAFEOKdelete,\@DELETEcnt);
$okNicdeletecnt = @DELETEcnt[2];
$okUicdeletecnt = @DELETEcnt[3];
@DELETEcnt = ();

@MKDIRcnt = ();
count_unique(\@ALLOKmkdir,\@MKDIRcnt,"good non-unique mkdir count of");
$okNmkdircnt = @MKDIRcnt[0];
$okUmkdircnt = @MKDIRcnt[1];
count_uniq_ic(\@ICAFEOKmkdir,\@MKDIRcnt);
$okNicmkdircnt = @MKDIRcnt[2];
$okUicmkdircnt = @MKDIRcnt[3];
@MKDIRcnt = ();

@RENAMEcnt = ();
count_unique(\@ALLOKrename,\@RENAMEcnt,"good non-unique rename count of");
$okNrenamecnt = @RENAMEcnt[0];
$okUrenamecnt = @RENAMEcnt[1];
count_uniq_ic(\@ICAFEOKrename,\@RENAMEcnt);
$okNicrenamecnt = @RENAMEcnt[2];
$okUicrenamecnt = @RENAMEcnt[3];
@RENAMEcnt = ();

@RMDIRcnt = ();
count_unique(\@ALLOKrmdir,\@RMDIRcnt,"good non-unique rmdir count of");
$okNrmdircnt = @RMDIRcnt[0];
$okUrmdircnt = @RMDIRcnt[1];
count_uniq_ic(\@ICAFEOKrmdir,\@RMDIRcnt);
$okNicrmdircnt = @RMDIRcnt[2];
$okUicrmdircnt = @RMDIRcnt[3];
@RMDIRcnt = ();


@LOGINcnt = ();
count_uniq_ic(\@BADUNAME,\@LOGINcnt);
$badNlogin = @LOGINcnt[0];
$badUlogin = @LOGINcnt[1];
@LOGINcnt = ();


@LOGINcnt = ();
count_unique(\@ALLFLlogin,\@LOGINcnt,"failed non-unique login count of");
$flNlogincnt = @LOGINcnt[0];
$flUlogincnt = @LOGINcnt[1];
count_uniq_ic(\@ICAFEFLlogin,\@LOGINcnt);
$flNiclogincnt = $LOGINcnt[2];
$flUiclogincnt = $LOGINcnt[3];
@LOGINcnt = ();


@UPLOADcnt = ();
count_unique(\@ALLFLupload,\@UPLOADcnt,"failed non-unique upload count of");
$flNuploadcnt = @UPLOADcnt[0];
$flUuploadcnt = @UPLOADcnt[1];
count_uniq_ic(\@ICAFEFLupload,\@UPLOADcnt);
$flNicuploadcnt = $UPLOADcnt[2];
$flUicuploadcnt = $UPLOADcnt[3];
@UPLOADcnt = ();

@DLOADcnt = ();
count_unique(\@ALLFLdnload,\@DLOADcnt,"failed non-unique dnloads count of");
$flNdnloadcnt = @DLOADcnt[0];
$flUdnloadcnt = @DLOADcnt[1];
count_uniq_ic(\@ICAFEFLdload,\@DLOADcnt);
$flUicdnloadcnt = @DLOADcnt[2];
$flUicdnloadcnt = @DLOADcnt[3];
@DLOADcnt = ();

@CHMODcnt = ();
count_unique(\@ALLFLchmod,\@CHMODcnt,"failed non-unique chmod count of");
$flNchmodcnt = @UPLOADcnt[0];
$flUchmodcnt = @UPLOADcnt[1];
count_uniq_ic(\@ICAFEFLchmod,\@CHMODcnt);
$flNicchmodcnt = @CHMODcnt[2];
$flUicchmodcnt = @CHMODcnt[3];
@CHMODcnt = ();

@DELETEcnt = ();
count_unique(\@ALLFLdelete,\@DELETEcnt,"failed non-unique delete count of");
$flNdeletecnt = @DELETEcnt[0];
$flUdeletecnt = @DELETEcnt[1];
count_uniq_ic(\@ICAFEFLdelete,\@DELETEcnt);
$flNicdeletecnt = @DELETEcnt[2];
$flUicdeletecnt = @DELETEcnt[3];
@DELETEcnt = ();

@MKDIRcnt = ();
count_unique(\@ALLFLmkdir,\@MKDIRcnt,"failed non-unique mkdir count of");
$flNmkdircnt = @MKDIRcnt[0];
$flUmkdircnt = @MKDIRcnt[1];
count_uniq_ic(\@ICAFEFLmkdir,\@MKDIRcnt);
$flNicmkdircnt = @MKDIRcnt[2];
$flUicmkdircnt = @MKDIRcnt[3];
@MKDIRcnt = ();

@RENAMEcnt = ();
count_unique(\@ALLFLrename,\@RENAMEcnt,"failed non-unique rename count of");
$flNrenamecnt = @RENAMEcnt[0];
$flUrenamecnt = @RENAMEcnt[1];
count_uniq_ic(\@ICAFEFLrename,\@RENAMEcnt);
$flNicrenamecnt = @RENAMEcnt[2];
$flUicrenamecnt = @RENAMEcnt[3];
@RENAMEcnt = ();

@RMDIRcnt = ();
count_unique(\@ALLFLrmdir,\@RMDIRcnt,"failed non-unique rmdir count of");
$flNrmdircnt = @RMDIRcnt[0];
$flUrmdircnt = @RMDIRcnt[1];
count_uniq_ic(\@ICAFEFLrmdir,\@RMDIRcnt);
$flNicrmdircnt = @RMDIRcnt[2];
$flUicrmdircnt = @RMDIRcnt[3];
@RMDIRcnt = ();


print TIMESUM "Total of	$badNlogin	login attempts excluded due to	$badUlogin	invalid accounts (wrong username format)  being repeatedly tried\n";
print TIMESUM "\n";
print TIMESUM "metric	Num excluded due to customer permissions	Failed non-unique	OK Non-unique	Failed unique	OK unique	Failed IC non-unique	OK IC non-unique	Failed IC unique	OK IC unique\n";
print TIMESUM "Logins:	0	$flNlogincnt	$okNlogincnt	$flUlogincnt	$okUlogincnt	$flNiclogincnt	$okNiclogincnt	$flUiclogincnt	$okUiclogincnt\n";
print TIMESUM "Upload:	$fluprootcnt	$flNuploadcnt	$okNuploadcnt	$flUuploadcnt	$okUuploadcnt	$flNicuploadcnt	$okNicuploadcnt	$flUicuploadcnt	$okUicuploadcnt\n";
print TIMESUM "Dnload:	$fldlrootcnt	$flNdnloadcnt	$okNdnloadcnt	$flUdnloadcnt	$okUdnloadcnt	$flNicdnloadcnt	$okNicdnloadcnt	$flUicdnloadcnt	$okUicdnloadcnt\n";
print TIMESUM "Chmods:	$flchrootcnt	$flNchmodcnt	$okNchmodcnt	$flUchmodcnt	$okUchmodcnt	$flNicchmodcnt	$okNicchmodcnt	$flUicchmodcnt	$okUicchmodcnt\n";
print TIMESUM "Delete:	$flderootcnt	$flNdeletecnt	$okNdeletecnt	$flUdeletecnt	$okUdeletecnt	$flNicdeletecnt	$okNicdeletecnt	$flUicdeletecnt	$okUicdeletecnt\n";
print TIMESUM "Mkdirs:	$flmkrootcnt	$flNmkdircnt	$okNmkdircnt	$flUmkdircnt	$okUmkdircnt	$flNicmkdircnt	$okNicmkdircnt	$flUicmkdircnt	$okUicmkdircnt\n";
print TIMESUM "Rename:	$flrnrootcnt	$flNrenamecnt	$okNrenamecnt	$flUrenamecnt	$okUrenamecnt	$flNicrenamecnt	$okNicrenamecnt	$flUicrenamecnt	$okUicrenamecnt\n";
print TIMESUM "Rmdirs:	$flrmrootcnt	$flNrmdircnt	$okNrmdircnt	$flUrmdircnt	$okUrmdircnt	$flNicrmdircnt	$okNicrmdircnt	$flUicrmdircnt	$okUicrmdircnt\n";
print TIMEUM "\n";

@TIMES = ("00:00", "00:10", "00:20", "00:30", "00:40", "00:50", "01:00", "01:10", "01:20", "01:30", "01:40", "01:50", "02:00", "02:10", "02:20", "02:30", "02:40", "02:50", "03:00", "03:10", "03:20", "03:30", "03:40", "03:50", "04:00", "04:10", "04:20", "04:30", "04:40", "04:50", "05:00", "05:10", "05:20", "05:30", "05:40", "05:50", "06:00", "06:10", "06:20", "06:30", "06:40", "06:50", "07:00", "07:10", "07:20", "07:30", "07:40", "07:50", "08:00", "08:10", "08:20", "08:30", "08:40", "08:50", "09:00", "09:10", "09:20", "09:30", "09:40", "09:50", "10:00", "10:10", "10:20", "10:30", "10:40", "10:50", "11:00", "11:10", "11:20", "11:30", "11:40", "11:50", "12:00", "12:10", "12:20", "12:30", "12:40", "12:50", "13:00","13:00", "13:10", "13:20", "13:30", "13:40", "13:50", "14:00", "14:10", "14:20", "14:30", "14:40", "14:50", "15:00", "15:10", "15:20", "15:30", "15:40", "15:50", "16:00", "16:10", "16:20", "16:30", "16:40", "16:50", "17:00", "17:10", "17:20", "17:30", "17:40", "17:50", "18:00", "18:10", "18:20", "18:30", "18:40", "18:50", "19:00", "19:10", "19:20", "19:30", "19:40", "19:50", "20:00", "20:10", "20:20", "20:30", "20:40", "20:50", "21:00", "21:10", "21:20", "21:30", "21:40", "21:50", "22:00", "22:10", "22:20", "22:30", "22:40", "22:50", "23:00", "23:10", "23:20", "23:30", "23:40", "23:50");

#This is where we get a total of ALL things that failed and their breakdown by 10min interval
%bulkfail = ();
@bulkfailcnt = ();
bulk_time(\%bulkfail,\@bulkfailcnt,@ALLFLlogintime, @ALLFLuploadtime, @ALLFLdnloadtime, @ALLFLmkdirtime, @ALLFLrenametime, @ALLFLchmodtime, @ALLFLdeletetime, @ALLFLrmdirtime);
$allfailedcnt = $bulkfailcnt[0];
#Dont lose track of bulkfail hash or count

#This is where we get a total of ALL successes and their breakdown by 10min interval
%bulkok = (); 
@bulkokcnt = ();
bulk_time(\%bulkok,\@bulkokcnt,@ALLOKlogintime, @ALLOKuploadtime, @ALLOKdnloadtime, @ALLOKmkdirtime, @ALLOKrenametime, @ALLOKchmodtime, @ALLOKdeletetime, @ALLOKrmdirtime);
$allokcnt = $bulkokcnt[0];
#Dont lose track of  the hash or the count ^


@blah = ();
#This is where we sum successes and failures by component and by 10min interval. 
$allfaillogincnt = @ALLFLlogintime;
$allfailuploadcnt = @ALLFLuploadtime;
$allfaildnloadcnt = @ALLFLdnloadtime;
$allfailmkdircnt = @ALLFLmkdirtime;
$allfailrenamecnt = @ALLFLrenametime;
$allfailchmodtime = @ALLFLchmodtime;
$alltaildeletecnt = @ALLFLdeletetime;
$allfailrmdircnt = @ALLFLrmdirtime;
%FLlogintimes = ();
fillhash(\%FLlogintimes);
%FLuploadtimes = ();
fillhash(\%FLuploadtimes);
%FLdnloadtimes =();
fillhash(\%FLdnloadtimes);
%FLmkdirtimes = ();
fillhash(\%FLmkdirtimes);
%FLrenametimes = ();
fillhash(\%FLrenametimes);
%FLchmodtimes = ();
fillhash(\%FLchmodtimes);
%FLdeletetimes = ();
fillhash(\%FLdeletetimes);
%FLrmdirtimes =();
fillhash(\%FLrmdirtimes);
metric_bytime(\%FLlogintimes,@ALLFLlogintime);
metric_bytime(\%FLuploadtimes,@ALLFLuploadtime);
metric_bytime(\%FLdnloadtimes,@ALLFLdnloadtime);
metric_bytime(\%FLmkdirtimes,@ALLFLmkdirtime);
metric_bytime(\%FLrenametimes,@ALLFLrenametime);
metric_bytime(\%FLchmodtimes,\@blah,@ALLFLchmodtime);
metric_bytime(\%FLdeletetimes,\@blah,@ALLFLdeletetime);
metric_bytime(\%FLrmdirtimes,\@blah,@ALLFLrmdirtime);

$alloklogincnt = @ALLOKlogintime;
$allokuploadcnt = @ALLOKuploadtime;
$allokdnloadcnt = @ALLOKdnloadtime;
$allokmkdircnt = @ALLOKmkdirtime;
$allokrenamecnt = @ALLOKrenametime;
$allokchmodtime = @ALLOKchmodtime;
$allokdeletecnt = @ALLOKdeletetime;
$allokrmdircnt = @ALLOKrmdirtime;
%OKlogintimes = ();
fillhash(\%OKlogintimes);
%OKuploadtimes = ();
fillhash(\%OKuploadtimes);
%OKdnloadtimes =();
fillhash(\%OKdnloadtimes);
%OKmkdirtimes = ();
fillhash(\%OKmkdirtimes);
%OKrenametimes = ();
fillhash(\%OKrenametimes);
%OKchmodtimes = ();
fillhash(\%OKchmodtimes);
%OKdeletetimes = ();
fillhash(\%OKdeletetimes);
%OKrmdirtimes =();
fillhash(\%OKrmdirtimes);
metric_bytime(\%OKlogintimes,\@blah,@ALLOKlogintime);
metric_bytime(\%OKuploadtimes,\@blah,@ALLOKuploadtime);
metric_bytime(\%OKdnloadtimes,\@blah,@ALLOKdnloadtime);
metric_bytime(\%OKmkdirtimes,\@blah,@ALLOKmkdirtime);
metric_bytime(\%OKrenametimes,\@blah,@ALLOKrenametime);
metric_bytime(\%OKchmodtimes,\@blah,@ALLOKchmodtime);
metric_bytime(\%OKdeletetimes,\@blah,@ALLOKdeletetime);
metric_bytime(\%OKrmdirtimes,\@blah,@ALLOKrmdirtime);

print TIMESUM "\n";
print TIMESUM "\n";
print TIMESUM "Summary of failures and successes by time\n";
print TIMESUM "Failure count:		$allfailedcnt\n";
print TIMESUM "Success count:		$allokcnt\n";
print TIMESUM "Time	Failures	Successes\n";
foreach (@TIMES) {
	print TIMESUM "$_	$bulkfail{$_}	$bulkok{$_}\n";
	}
print TIMESUM "\n";

print TIMESUM "Times	Logins Failed	Logins Succeeded	Uploads Failed	Uploads Succeeded	Dnloads Failed	Dnloads OK	Failed Mkdir	Mkdir OK	Rename Failed	Rename OK	Chmod Failed	Chmod OK	Delete Failed	Delete OK	Rmdir Failed	Rmdir OK\n";
foreach (@TIMES) {
	print TIMESUM "$_	$FLlogintimes{$_}	$OKlogintimes{$_}	$FLuploadtimes{$_}	$OKuploadtimes{$_}	$FLdnloadtimes{$_}	$OKdnloadtimes{$_}	$FLmkdirtimes{$_}	$OKmkdirtimes{$_}	$FLrenametimes{$_}	$OKrenametimes{$_}	$FLchmodtimes{$_}	$OKchmodtimes{$_}	$FLdeletetimes{$_}	$OKdeletetimes{$_}	$FLrmdirtimes{$_}	$OKrmdirtimes{$_}\n";
	}


print OUT "Metric	";
foreach (@HOSTS) {
	print OUT "$_	"
	}
print OUT "\n";
server_okoutput("OK","FAIL","Tot' Successes:	","all events");
server_okoutput("OKlogin","FLlogin","Good Logins:	","logins");
server_okoutput("OKupload","FLupload","Good Uploads:	","uploads");
server_okoutput("OKdnload","FLdnload","Good downloads:	","downloads");
server_okoutput("OKchmod","FLchmod","Good chmods:	","chmods");
server_okoutput("OKdelete","FLdelete","Good deletes:	","deletes");
server_okoutput("OKmkdir","FLmkdir","Good mkdirs:	","mkdirs");
server_okoutput("OKrename","FLrename","Good renames:	","renames");
server_okoutput("OKrmdir","FLrmdir","Good rmdirs:	","rmdirs");
print OUT "\n";
server_failoutput("FAIL","Total Failures:	");
server_failoutput("FLlogin","Failed logins:	");
server_failoutput("FLupload","Failed Uploads:	");
server_failoutput("FLdnload","Failed Downloads:	");
server_failoutput("FLchmod","Failed Chmods:	");
server_failoutput("FLdelete","Failed Deletes:	");
server_failoutput("FLmkdir","Failed mkdirs:	");
server_failoutput("FLrename","Failed Renames:	");
server_failoutput("FLrmdir","Failed rmdirs:	");

sub first {
	my $string = shift;
	my $ALLstring = shift;
	my $ALLuname = shift;
	my $ALLtime = shift;
	my $ICAFE = shift;
	if (($string =~ /DOWNLOAD/) || ($string =~ /UPLOAD/)) {
		$string = cleanupdn($string);}
	else {
		$string = cleanbatch($string);}
	if ($string =~ /205.178.191.39/) {
		push(@$ICAFE, $string);}
	elsif ($string !~ /205.178.191.39/ ) {
		push(@$ALLstring, $string);
		push(@$ALLuname, (split /\;/, ,$string)[1]);
		push(@$ALLtime, (split /\;/, ,$string)[0]);}
}



sub cleanbatch {
	($time, $site, $ip) = (split /\s+/, ,$_[0])[3,7,11];
	for ($time, $site, $ip)  {
	s/\[//;
	s/\]//;
	s/"//g;
	s/,//g;
	s/\\//g;}
	$time = (substr($time,0,4));
	$_[0] = "$time;$site;$ip";
	}

sub cleanupdn {
	($first, $second) = split /,/ ,$_[0],2;
	($time, $site, $ip) = ((split /\s+/, ,$first)[3,7,11]);
	($second_a, $second_b) = split /",/ ,$second,2;
	($bytes, $speed) = split /,/ ,$second_b,2;
	if ($bytes =~ /Kbyte/) {
		$speed = $bytes;
		$bytes = 0;}
	for ($site, $ip, $bytes, $speed) {
		s/\[//;
		s/\]//;
		s/"//g;
		s/bytes//;
		s/Kbyte\/sec//;
		s/\s//g;}
	$time = (substr($time,0,4));
	$_[0] = "$time;$site;$ip;$bytes;$speed";
}	

sub server_okoutput {
	$label = $_[2];
	$metric = $_[3];
	$okhash = $_[0];
	$flhash = $_[1];
	print OUT "$label";
	foreach (@HOSTS) {
       		print OUT "$$okhash{$_}	";}
	print OUT "\n";
	print OUT "This host's percentage failure rate for $metric	";
	foreach (@HOSTS) {
		if (($$flhash{$_} + $$okhash{$_}) > 0) {
			$percent = 100 * ($$flhash{$_} / ($$flhash{$_} + $$okhash{$_}));}
		else {
			$percent = 0;}
		printf OUT  "%2d%	", $percent;}
	print OUT "\n";
	}

sub server_failoutput {
	$label = $_[1];
	$hash = $_[0];
	print OUT "$label";
	foreach (@HOSTS) {
		print OUT "$$hash{$_}	";}
	print OUT "\n";
	print OUT "This host as a percentage of the platform's $_[1]";
	foreach (@HOSTS) {
		$percent = 100 * ($$hash{$_}/$FAIL{$hash});
		printf OUT "%2d%	", $percent;}
	print OUT "\n";
	}

sub count_unique {
    my $ARRAY = shift;
    my $COUNT = shift;
    my $breakouttext = shift;
    my @RESULTS = ();
    my $uniqcnt = 0;
    $uniqcnt = @$ARRAY;
    push(@$COUNT, $uniqcnt);
    my $cnt = 0;
    my %count;
	map { $count{$_}++ } @$ARRAY;
	@RESULTS = (map {"${count{$_}}	from	$_"} sort keys(%count));
	$cnt = @RESULTS;
	push(@$COUNT, $cnt);
	@$ARRAY = @RESULTS;
	@RESULTS = sort{$b <=> $a} @RESULTS;
	print OFFENDERS "$breakouttext	$RESULTS[0]\n";
	print OFFENDERS "$breakouttext	$RESULTS[1]\n";
	print OFFENDERS "$breakouttext	$RESULTS[2]\n";
	print OFFENDERS "$breakouttext	$RESULTS[3]\n";
	print OFFENDERS "$breakouttext	$RESULTS[4]\n";
	print OFFENDERS "$breakouttext	$RESULTS[5]\n";
	print OFFENDERS "$breakouttext	$RESULTS[6]\n";
	print OFFENDERS "$breakouttext	$RESULTS[7]\n";
	print OFFENDERS "$breakouttext	$RESULTS[8]\n";
	print OFFENDERS "$breakouttext	$RESULTS[9]\n";
	print OFFENDERS "$breakouttext	$RESULTS[10]\n";
	print OFFENDERS "\n";
	print OFFENDERS "\n";
}

sub count_uniq_ic {
	my $ARRAY = shift;
	my $COUNT = shift;
	my @RESULTS = ();
	my $uniqcnt = 0;
	$uniqcnt = @$ARRAY;
	push(@$COUNT, $uniqcnt);
	my $cnt = 0;
	my %count;
		map { $count{$_}++ } @$ARRAY;
		@RESULTS = (map {"${count{$_}}  from    $_"} sort keys(%count));
		$cnt = @RESULTS;
		push(@$COUNT, $cnt);
}

sub bulk_time {
	my $timehash = shift;
	my $counts = shift;
    	my @ARRAY = @_;
	my @RESULTS = ();
	my %count;
	$totnonuniq = @ARRAY;
	push(@$counts, $totnonuniq);
	map { $count{$_}++ } @ARRAY;
	$z =0;
	@RESULTS = (map {"$_$z ${count{$_}}"} sort keys(%count));
	foreach (@RESULTS) {
		($time, $cnttime) = split /\s+/ ,$_,2;
		$timehash->{$time} = $cnttime;
		}
}

sub metric_bytime {
	my $timehash = shift;
	my @ARRAY = @_;
	my @RESULTS = ();
	my %count;
	$totnonuniq = @ARRAY;
	push(@$counts, $totnonuniq);
	map { $count{$_}++ } @ARRAY;
	$z =0;
	@RESULTS = (map {"$_$z ${count{$_}}"} sort keys(%count));
	foreach (@RESULTS) {
		($time, $cnttime) = split /\s+/ ,$_,2;
		$timehash->{$time} = $cnttime;
		}
}	

sub fillhash {
	my $timehash = shift;
	foreach (@TIMES) {
		$timehash->{$_} = 0;
		}
		}
sub pathtest {
	$unamepart = $_[0];
	$testpart = $_[0];
	
	if (($unamepart =~ /UPLOAD/) || ($unamepart =~ /DOWNLOAD/)) {
		$unamepart = cleanupdn($unamepart)}
	else {
		$unamepart = cleanbatch($unamepart);}
	
	$uname = (split /\;/, ,$unamepart)[1];
	$uname = (split /%/, ,$uname)[1];

	if ($PATHHASH{$uname} == 1) {
		$count = 2.33;
		return $count;}
	elsif ($PATHHASH{$uname} ne 1) {
		$testpart = (split /\d\"\,\s\"/, ,$_)[1];
        	$testpart = (split /\s/, ,$testpart)[0];
		$count = @{[$testpart =~ /\//g]};
		return $count;}}