#

# Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).

# All rights reserved.

# This component and the accompanying materials are made available

# under the terms of the License "Eclipse Public License v1.0"

# which accompanies this distribution, and is available

# at the URL "http://www.eclipse.org/legal/epl-v10.html".

#

# Initial Contributors:

# Nokia Corporation - initial contribution.

#

# Contributors:

#

# Description: 

# This module implements the MD5 version of the Evalid's compare

#

package EvalidMD5;

use strict;

use Carp;

use File::Find;

use IO::File;

use Sys::Hostname;

use FindBin;

use lib "$FindBin::Bin";

require Exporter;

use File::Basename;

use vars       qw($VERSION );

$VERSION     = 0.02;

use EvalidCompare;

# Public

# MD5Generate

#

# Inputs

# $iLeftDir - Left side directory or File containing listing of left side

# $iResultsFile - Name of file to write the list of files and MD5 checksum to

# $iExclude - Reference to array of regular expression patterns to exclude

# $iInclude - Reference to array of regular expression patterns to include

# $iListFile - Filename to read for list of files from [Optional]

# $iDumpDir - Directory to generate dump of comparison data [Optional]

#

# Outputs

#

# Description

# This function generates the MD5 checksum file

sub MD5Generate

{

  my ($iLeftDir, $iResultsFile, $iExclude, $iInclude, $iListFile, $iDumpDir) = @_;

  my (@iLeftFiles);

  # This should have been check before getting here but to be on the safe side

  # check again, as it should never overwrite or append to the file

  croak "$iResultsFile already exists" if (-e $iResultsFile);

  croak "$iListFile does exist" if ((defined($iListFile) && (!-e $iListFile)));

  if (-d $iLeftDir){

    # Make sure all the \ are / for the RegEx

    $iLeftDir =~ s/\\/\//g;

    # Make sure it does not have a / on the end

    $iLeftDir =~ s/\/$//;

    # If $iFileList is defined then use the filelist to generate @iLeftFiles

    if (defined($iListFile))

    {

      # Generate list of files

      @iLeftFiles = &FilterDir($iLeftDir,$iExclude,$iInclude, $iListFile);

    } else {

      # Generate the the directory listing

      @iLeftFiles = &FilterDir($iLeftDir,$iExclude,$iInclude);

    }

  } else {

    croak "$iLeftDir is not a directory";

  }

  # Open the results file for writing

  my ($fResultsFile) = new IO::File;

  croak "Cannot for $iResultsFile for writing" unless ($fResultsFile->open("> $iResultsFile"));

  # Write headers to the file

  print $fResultsFile "Host:".&hostname()."\n";

  print $fResultsFile "Username:".$ENV{'USERNAME'}."\n";

  print $fResultsFile "Date-Time:".scalar(localtime)."\n";

  print $fResultsFile "Version:".$VERSION."\n";

  print $fResultsFile "Directory:".$iLeftDir."\n";

  print $fResultsFile "FileList:".$iListFile."\n" if (defined($iListFile));

  print $fResultsFile "Exclusion(s):";

  foreach my $iExc (sort @$iExclude)

  {

    print $fResultsFile "$iExc ";

  }

  print $fResultsFile "\n";

  print $fResultsFile "Inclusion(s):";

  foreach my $iInc (@$iInclude)

  {

    print $fResultsFile "$iInc ";

  }

  print $fResultsFile "\n";

  print $fResultsFile "----------------\n";

  # Write out sorted list of files with MD5 Checksums

  foreach my $iFile (sort @iLeftFiles)

  {

    my ($MD5, $type) = &EvalidCompare::GenerateSignature($iLeftDir."/".$iFile, $iDumpDir);

    print $fResultsFile $iFile." TYPE=".$type." MD5=".$MD5."\n";

  }

  $fResultsFile->close;

}

# MD5Compare

#

# Inputs

# $iLeftFile - Left side File containing listing and MD5 of left side

# $iRightFile - Right side File containing listing and MD5 of right side

# $iVerbose - Verbose Flag

# $iLog - Logfile name

#

# Outputs

# %iCommon - hash relative filenames with values of file type that are in both directories and Compare results/types

# %iDiff - hash relative filenames with values of file type and directory side infomation

#

# Description

sub MD5Compare

{

  my ($iLeftFile) = shift;

  my ($iRightFile) = shift;

  my ($iVerbose) = defined($_[0]) ? shift : 0;

  my ($iLog) = defined($_[0]) ? shift : *STDOUT;

  my (%iCommon, %iDiff);

  my (%iLeftFiles, %iRightFiles);

  my (%iLeftHeaders, %iRightHeaders);

  # Backup check the files are available to read.

  croak "$iLeftFile is not a file" unless (-f $iLeftFile);

  croak "$iRightFile is not a file" unless(-f $iRightFile);

  #Read the files

  &ReadMD5File($iLeftFile, \%iLeftFiles, \%iLeftHeaders);

  &ReadMD5File($iRightFile, \%iRightFiles, \%iRightHeaders);

  # Check Critical headers

  foreach my $iHeader (sort keys %iLeftHeaders)

  {

    # Warning is certain headers are not identical

    if ($iHeader =~ /^Version|Exclusion\(s\)|Inclusion\(s\)/)

    {

      print $iLog "WARNING:$iHeader is different\n" if ($iLeftHeaders{$iHeader} ne $iRightHeaders{$iHeader});

    }

  }

  # A Hash is used to combine the two directory listing using the filename as the key

  my %iCombinedFiles;

  # Enter the files from the left side listing and check the right side critical header are the same

  # Note all filenames are turned to lower case as this is designed to only wotk on Windows

  foreach my $iFile (sort keys %iLeftFiles)

  {

    $iCombinedFiles{$iFile} = "Left";

  }

  # Enter the files from the right side listing

  # Note all filenames are turned to lower case as this is designed to only wotk on Windows

  foreach my $iFile (sort keys %iRightFiles)

  {

    # Check to see if any entry for this file exists on the left side

    if ((defined ($iCombinedFiles{$iFile})) && ( $iCombinedFiles{$iFile} eq "Left"))

    {

      # Yes, so add to the Common set

      # Check if the MD5 checksum matches

      # The [0] element is the file type

      if ($iLeftFiles{$iFile}[0] ne $iRightFiles{$iFile}[0])

      {

        $iCommon{$iFile} = [$iLeftFiles{$iFile}[0]." to ".$iRightFiles{$iFile}[0], "Type Changed"]; 

      } elsif ($iLeftFiles{$iFile}[1] eq $iRightFiles{$iFile}[1]) {

        $iCommon{$iFile} = [$iLeftFiles{$iFile}[0],"OK"];

      } else {

        $iCommon{$iFile} = [$iLeftFiles{$iFile}[0],"Different"];

      }

      # The filename key is not needed any more as both sides have been processed, so delete the hash entry

      delete $iCombinedFiles{$iFile};

    } elsif (!defined($iCombinedFiles{$iFile})) {

      # No, the key is not defined, so this filename is only in the right side

      $iDiff{$iFile} = [$iRightFiles{$iFile}[0],"Right"];

      # The filename key is not needed any more as both sides have been processed, so delete the hash entry

      delete $iCombinedFiles{$iFile};

    }

  }

  # Add the files left in the hash to the Left side only list

  foreach my $iFile (sort keys %iCombinedFiles)

  {

    $iDiff{$iFile} = [$iLeftFiles{$iFile}[0],"Left"];

  }

  # Return References to the Arrays

  return (\%iCommon, \%iLeftHeaders, \%iRightHeaders, \%iDiff);

}

# FilterDir

#

# Inputs

# $iDir - Directory to process

# $iExclude - Reference to array of regular expression patterns to exclude

# $iInclude - Reference to array of regular expression patterns to include

# $iListFile - Filename to read for list of files from [Optional]

#

# Outputs

# @iFinalFileList - Filtered list relative filenames

#

# Description

# This function produces a filtered list of filenames in the specified directory or from file

sub FilterDir

{

  my ($iDir,$iExclude,$iInclude, $iListFile) = @_;

  my (@iFileList, @iFinalFileList, $iFileName);

  if(defined($iListFile))

  {

    open LIST, "$iListFile" or croak "Cannot open $iListFile\n";

    while(<LIST>)

    {

      next if /^\s+$/;  # skip blank lines 

      my $iFileName = $iDir."/".$_;

      chomp $iFileName; # Remove new line

      if(-e $iFileName)

      {

        # The listed file exists add to the @iFileList

        push @iFileList, $iFileName;

      } else {

        print "Warning: Cannot find $iFileName\n";

      }

    }

    close LIST;

  } else {

    # Produce full filelist listing without directory names

    find sub { push @iFileList, $File::Find::name if (!-d) ;}, $iDir;

  }

  foreach my $iFile ( @iFileList)

  {

    my $iExcludeFile = 0;

    # Remove the specified directory path from the front of the filename

    $iFile =~ s#^$iDir/##;

    # Process all Exclude RegEx to see if this file matches

    foreach my $iExcludeRegEx (@$iExclude)

    {

      if ($iFile =~ /$iExcludeRegEx/i)

      {

        # Mark this file to be excluded from the final list

        $iExcludeFile = 1;

      }

    }

    # Process all Include RegEx to see if this file matches

    foreach my $iIncludeRegEx (@$iInclude)

    {

      if ($iFile =~ /$iIncludeRegEx/i)

      {

        # Mark this file to be Included in the final list

        $iExcludeFile = 0;

      }

    }

    # Added the file to the final list based on the flag

    push @iFinalFileList, lc($iFile) unless $iExcludeFile;

  }

  return @iFinalFileList;

}

# MD5ComparePrint

#

# Inputs

# $iCommon - Reference to Hash of common file names and the result the comparision

# $iLeftHeaders - Reference to Hash contain the left side

# $iRightHeaders - Reference to Hash contain the right side

# $iDiff - Reference to Hash of relative filenames with values of file type and left/right directory side

# $iLog - Logfile name

#

# Outputs

#

# Description

# This function prints the output of a Compare

sub MD5ComparePrint

{

  my ($iCommon) = shift;

  my ($iLeftHeaders) = shift;

  my ($iRightHeaders) = shift;

  my ($iDiff) = shift;

  my ($iLog) = shift;

  my ($iFailed) = 0; # Count of the failed comparisions

  my ($iPassed) = 0; # Count of the Passed comparisions

  my ($iLeft) = 0; # Count of the Passed comparisions

  my ($iRight) = 0; # Count of the Passed comparisions

  my ($sec, $min, $hour, $mday, $mon, $year) = localtime(time);

  printf $iLog "\n----------------\n%02d:%02d %02d/%02d/%04d\n", $hour, $min, $mday, $mon+1, $year+1900;

  print $iLog "evalid\nLeft Side=$ARGV[0]\nRight Side=$ARGV[1]\n";

  print $iLog "\nLeft side information\n";

  foreach my $iHeader (sort keys %$iLeftHeaders)

  {

    print $iLog $iHeader.":".$$iLeftHeaders{$iHeader}."\n";

  }

  print $iLog "\nRight side information\n";

  foreach my $iHeader (sort keys %$iRightHeaders)

  {

    print $iLog $iHeader.":".$$iRightHeaders{$iHeader}."\n";

  }

  print $iLog "\n";

  foreach my $iFile (sort keys %$iCommon)

  {

    if ($$iCommon{$iFile}[1] eq "OK")

    {

      print $iLog "Passed:$iFile (".$$iCommon{$iFile}[0].")\n";

      $iPassed++;

    }

  }

  print $iLog "\n";

  foreach my $iFile (sort keys %$iCommon)

  {

    if ($$iCommon{$iFile}[1] eq "Type Changed")

    {

      print $iLog "Type Changed:$iFile (".$$iCommon{$iFile}[0].")\n";

      $iFailed++;

    }

  }

  print $iLog "\n";

  foreach my $iFile (sort keys %$iCommon)

  {

    if ($$iCommon{$iFile}[1] eq "Different")

    {

      print $iLog "Failed:$iFile (".$$iCommon{$iFile}[0].")\n";

      $iFailed++;

    }

  }

  print $iLog "\n";

  foreach my $iFile (sort keys %$iDiff)

  {

    if ($$iDiff{$iFile}[1] eq "Left")

    {

      print $iLog "Missing Left:$iFile (".$$iDiff{$iFile}[0].")\n";

      $iLeft++;

    }

  }

  print $iLog "\n";

  foreach my $iFile (sort keys %$iDiff)

  {

    if ($$iDiff{$iFile}[1] eq "Right")

    {

      print $iLog "Missing Right:$iFile (".$$iDiff{$iFile}[0].")\n";

      $iRight++;

    }

  }

  print $iLog "\n\nSummary\n";

  print $iLog "Total files processed=".($iPassed+$iFailed+$iRight+$iLeft)."\n";

  print $iLog "Files Passed=$iPassed\n";

  print $iLog "Files Failed=$iFailed\n";

  print $iLog "Missing Files in Left=".$iRight."\n";

  print $iLog "Missing Files in Right=".$iLeft."\n";

  return ($iFailed);

}

# NameOnly

# 

# Inputs

# $filename - may contain path and file extension

#

# Outputs

# $nameOnly - filename without extension and path

#

# Description

# This routine is used to extract the name of the file

# only from a filename that may include a path and file extension

# 

sub NameOnly

{

  my ($filename) = @_;

  my $nameOnly = basename($filename);

  $nameOnly =~ s/(\w+.*)\.\w+$/$1/;

  return $nameOnly;

}

# MD5CompareZipDel

#

# Inputs

# $iCommon - Reference to Hash of common file names and the result the comparision

# $iDiff - Reference to Hash of relative filenames with values of file type and left/right directory side

# $iLeft - filename of Left side directory

# $iRight - filename of Right side directory

#

# Outputs

#

# Description

# This function prints the output of a Compare results in a format ready for creating the a

# Zip and batch file to upgrade the left side to the equivalent of the right side.

sub MD5CompareZipDel

{

  my ($iCommon) = shift;

  my ($iDiff) = shift;

  my ($iLeft) = shift;

  my ($iRight) = shift;

  # Build a suitable name for outputfiles based on input filenames

  $iLeft = NameOnly($iLeft);

  $iRight = NameOnly($iRight);

  my ($iBasename) = $iLeft."_to_".$iRight;

  open DELLIST, ">del_$iBasename.bat";

  open ZIPLIST, ">zip_$iBasename.log";

  open ZIPBAT, ">zip_$iBasename.bat";

  foreach my $iFile (sort keys %$iCommon)

  {

    if (($$iCommon{$iFile}[1] eq "Different") || ($$iCommon{$iFile}[1] eq "Type Changed"))

    {

      print ZIPLIST "$iFile\n";

    }

  }

  foreach my $iFile (sort keys %$iDiff)

  {

    if ($$iDiff{$iFile}[1] eq "Right")

    {

      print ZIPLIST "$iFile\n";

    } else {

      # DEL needs the / to be \

      $iFile =~ s/\//\\/g;

      print DELLIST "del /F $iFile\n";

    }

  }

  print ZIPBAT "zip $iBasename.zip -@<zip_$iBasename.log\n";

  close DELLIST;

  close ZIPLIST;

  close ZIPBAT;

}

# Private

# ReadMD5File

#

# Inputs

# $iResultsFile - Results filename to process

# $iResults - Reference to Results Hash

# $iHeaders - Reference to Headers Hash

#

# Outputs

#

# Description

# This function reads the conntent of the MD5 File in to a Hash

sub ReadMD5File

{

  my ($iResultsFile, $iResults, $iHeaders) = @_;

  # Open the results file for reading

  open (INPUT, "$iResultsFile") or croak "Cannot for $iResultsFile for reading";

  while (<INPUT>)

  {

    if (/^(\S+?):(.*)/)

    {

      $$iHeaders{$1} = $2;

    } elsif (/^(\S+?)\sTYPE=(.*?)\sMD5=(.*)/){

      $$iResults{$1} = [$2,$3];

    }

  }

  close INPUT;

}

1;