#

# 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: 

#

package EvalidCompare;

use strict;

our $VERSION = '1.00';

use IO::Handle;

use IO::File;

use Cwd;

use File::Temp qw/ tempfile tempdir /;

use File::Find;

use File::Path;

use File::Basename;

use File::Copy;

#

# Constants.

#

my %typeLookup = (

      'ARM PE-COFF executable' => 'ignore',

      'E32 EXE' => 'e32',

      'E32 DLL' => 'e32',

      'Uncompressed E32 EXE' => 'e32',

      'Uncompressed E32 DLL' => 'e32',

      'Compressed E32 EXE' => 'e32',

      'Compressed E32 DLL' => 'e32',

      'Intel DLL' => 'intel_pe',

      'Intel EXE' => 'intel_pe',

      'MSDOS EXE' => 'intel_pe',

      'Intel object' => 'intel',

      'Intel library' => 'intel',

      'ELF library' => 'elf',

      'ARM object' => 'arm',

      'ARM library' => 'arm',

      'unknown format' => 'identical',

      'Java class' => 'identical',

      'ZIP file' => 'zip',

      'Permanent File Store' => 'permanent_file_store',

      'SIS file' => 'identical',

      'MSVC database' => 'ignore',

      'MAP file' => 'map',

      'SGML file' => 'sgml',

      'Preprocessed text' => 'preprocessed_text',

      'ELF file' => 'elf',

      'Unknown COFF object' => 'identical',

      'Unknown library' => 'identical',

      'chm file' => 'chm_file',

	  'Header file' => 'header',

     );

# %TEMPDIR% and %FILE% are magic words for the expandor

# they will be replaced with suitable values when used

# they also enabled an order of expandor arguments where the filename is not last

my %typeHandler = (

      e32 => {reader => 'elf2e32 --dump --e32input=', filter => \&Elf2E32Filter},

      arm => {reader => 'nm --no-sort', filter => \&NmFilter, retry => 1, relative_paths => 1},

      elf => {reader => 'elfdump -i', filter => \&ElfDumpFilter, rawretry => 1},

      intel => {reader => '%EPOCROOT%epoc32\gcc_mingw\bin\nm --no-sort', filter => \&NmFilter, rawretry => 1, relative_paths => 1, skipstderr => 1},

      intel_pe => {reader => 'pe_dump', filter => \&FilterNone, rawretry => 1},

	  zip => {reader => '"'.$FindBin::Bin.'/unzip" -l -v', filter => \&UnzipFilter, rawretry => 1},

      map => {filter => \&MapFilter, skipblanks => 1},

      sgml => {filter => \&SgmlFilter},

      preprocessed_text => {filter => \&PreprocessedTextFilter},

      permanent_file_store => {reader => 'pfsdump -c -v', filter => \&PermanentFileStoreFilter, rawretry => 1, relative_paths => 1},

      ignore => {filter => \&FilterAll},

      chm_file => {expandor => 'hh -decompile %TEMPDIR% %FILE%', rawretry => 1},

	  header => {filter => \&FilterCVSTags},

     );

#

# Globals.

#

my $log;

my $verbose;

my $toRoot;

my $dumpDir;

undef $dumpDir;

#

# Public.

#

sub CompareFiles {

  my $file1 = shift;

  my $file2 = shift;

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

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

  # Try binary compare first (to keep semantics the same as evalid)...

  if (DoCompareFiles($file1, $file2, 'unknown format')) {

    return 1,'identical';

  }

  my $type = IdentifyFileType($file1);

  if ($typeLookup{$type} eq 'identical') {

    return 0,$type; # We already know a binary compare is going to return false.

  }

  return DoCompareFiles($file1, $file2, $type),$type;

}

sub GenerateSignature {

  my $file = shift;

  $dumpDir = shift;

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

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

  my $md5;

  if (eval "require Digest::MD5") { # Prefer Digest::MD5, if available.

    $md5 = Digest::MD5->new();

  } elsif (eval "require MD5") { # Try old version of MD5, if available.

    $md5 = new MD5;

  } elsif (eval "require Digest::Perl::MD5") { # Try Perl (Slow) version of MD5, if available.

    $md5 = Digest::Perl::MD5->new();

  } else {

    die "Error: Cannot load any MD5 Modules";

  }

  my $type = IdentifyFileType($file);

  WriteFilteredData($file, $type, $md5);

  return $md5->hexdigest(), $type;

}

#

# Private.

#

sub IdentifyFileType {

  my $file = shift;

  open (FILE, $file) or die "Error: Couldn't open \"$file\" for reading: $!\n";

  binmode (FILE);

  my $typeBuf;

  read (FILE, $typeBuf, 512);

  close (FILE);

  my ($uid1, $uid2, $uid3, $checksum) = unpack "V4", $typeBuf;

  # NB. Need to use the s modifier so that '.' will match \x0A

  if ($typeBuf =~ /^.\x00\x00\x10.{12}EPOC.{8}(....).{12}(.)..(.)/s) {

    # E32 Image file with a 0x100000?? UID1

    # $2 is the flag field indicating an EXE or a DLL

    # $3 is the flag byte indicating compressable executables

    # $1 is the format field indicating compression type

    # See e32tools\inc\e32image.h

    #

    my $typename = "E32 EXE";

    if ((ord $2) & 0x1) {

      $typename = "E32 DLL";

    }

    if ((ord $3) >= 0x1) {

    if ((ord $1) != 0) {

        $typename = "Compressed $typename";

    }

    else {

        $typename = "Uncompressed $typename";

    }

    }

    return $typename;

  }

  if ($typeBuf =~ /^\x4D\x5A.{38}\x00{20}(....)/s) {

    # A standard 64-byte MS-DOS header with e_magic == IMAGE_DOS_SIGNATURE

    # $1 is e_lfanew, which we expect to point to a COFF header

    my $offset = unpack "V",$1;

    if ($offset + 24 <= length $typeBuf) {

      $typeBuf = substr $typeBuf, $offset;

    }

    else {

      open FILE, $file or die "Error: Couldn't open \"$file\" for reading: $!\n";

      binmode FILE;

      seek FILE, $offset, 0;

      read FILE, $typeBuf, 512;

      close FILE;

    }

    if ($typeBuf =~ /^PE\0\0\x4c\x01.{16}(..)/s) {

      # A PE signature "PE\0\0" followed by a COFF header with

      # machine type IMAGE_FILE_MACHINE_I386

      # $1 is the characteristics field

      #

      if ((unpack "v",$1) & 0x2000) {

    return "Intel DLL";

      }

      else {

    return "Intel EXE";

      }

    }

  elsif($typeBuf =~ /^PE\0\0\0\x0a/) {

  # A PE signature "PE\0\0" followed by ARM COFF file magic value 0xA00

    return "ARM PE-COFF executable";

  }

    else {

      return "MSDOS EXE";

    }

  }

  if ($typeBuf =~ /^(\x4c\x01|\x00\x0A).(\x00|\x01).{4}...\x00/s) {

    # COFF header with less than 512 sections and a symbol table

    # at an offset no greater than 0x00ffffff

    if ($1 eq "\x4c\x01") {

      return "Intel object";

    }

    elsif ($1 eq "\x00\x0A") {

      return "ARM object";

    }

    else {

      return "Unknown COFF object";

    }

  }

  if ($typeBuf =~ /^!<arch>\x0A(.{48}([0-9 ]{9})\x60\x0A(......))/s) {

    # library - could be MARM or WINS

    $typeBuf = $1;

    my $member_start = 8;

    open (FILE, $file) or die "Error: Couldn't open \"$file\" for reading: $!\n";

    binmode (FILE);

    while ($typeBuf =~ /^.{48}([0-9 ]{9}).\x60\x0A(......)/s) {

      # $1 is the size of the archive member, $2 is first 6 bytes of the file

      # There may be several different sorts of file in the archive, and we

      # need to scan through until we find a type we recognize:

      # $2 == 0x0A00 would be ARM COFF, 0x014C would be Intel COFF

      if ($2 =~ /^\x00\x0A/) {

  close FILE;

  return "ARM library";

      }

      if ($2 =~ /^\x4C\x01/) {

  close FILE;

  return "Intel library";

      }

	  my $elfBuf =  $2;

      if ($2 =~ /^\x7F\x45\x4C\x46/) {

  close FILE;

		my $dataEncodingLib = substr($elfBuf, 5, 6);

		if ( $dataEncodingLib =~ /^\x02/) {	

			# e_ident[EI_DATA] == 2 (Data Encoding ELFDATA2MSB - big endian)

			# this is not supported by Elfdump hence it is treated as 'unknown format'

		return 'unknown library';

		}

		else {

		return "ELF library";

		}

	 }

      $member_start += 60 + $1;

      if ($member_start & 0x1) {

        $member_start += 1;  # align to multiple of 2 bytes

      }

      seek FILE, $member_start, 0;

      read FILE, $typeBuf, 512;

    }

    close FILE;

    return "Unknown library";

  }

  if ($typeBuf =~ /^\xCA\xFE\xBA\xBE/) {

    # Java class file - should have match as a straight binary comparison

    return "Java class";

  }

  if ($typeBuf =~ /^PK\x03\x04/) {

    # ZIP file

    return "ZIP file";

  }

  if ($uid1 && $uid1==0x10000050) {

    # Permanent File Store

    return "Permanent File Store";

  }

  if ($uid1 && $uid2 && $uid3 && $checksum && $uid3==0x10000419) {

    if (($uid1==0x100002c3 && $uid2==0x1000006d && $checksum==0x128ca96f)  # narrow

  ||  ($uid1==0x10003b0b && $uid2==0x1000006d && $checksum==0x75e21a1d)  # unicode

  ||  ($uid1==0x10009205 && $uid2==0x10003a12 && $checksum==0x986a0c25)) # new format

      {

      # SIS file

      return "SIS file";

      }

  }

  if ($typeBuf =~ /^Microsoft [^\x0A]+ [Dd]atabase/s) {

    return "MSVC database";

  }

  if ($typeBuf =~ /^\S.+ needed due to / || $typeBuf =~ /^Archive member included.*because of file/) {

    # GCC MAP file

    return "MAP file";

  }

  if ($typeBuf =~ /Preferred load address is/) {

    # Developer Studio MAP file

    return "MAP file";

  }

  if ($typeBuf =~ /^Address\s+Size\s+Name\s+Subname\s+Module/) {

    # CodeWarrior MAP file

    return "MAP file";

  }

  if ($typeBuf =~ /^ARM Linker,/) {

    # RVCT MAP file

    return "MAP file";

  }

  if ($typeBuf =~ /<!DOCTYPE/i) {

    # XML or HTML file - need to ignore javadoc generation dates

    return "SGML file";

  }

  if ($typeBuf =~ /^# 1 ".*"(\x0D|\x0A)/s) {

    # Output of CPP

    return "Preprocessed text";

  }

  if ($typeBuf =~ /^\x7F\x45\x4C\x46/) {

	my $dataEncoding = substr($typeBuf, 5, 6);

	if ( $dataEncoding =~ /^\x02/) {	

	  # e_ident[EI_DATA] == 2 (Data Encoding ELFDATA2MSB - big endian)

	  # this is not supported by Elfdump hence it is treated as 'unknown format'

	   return 'unknown format';

	}

	else {

		return "ELF file";;

	}

   }

  if ($typeBuf =~/^ITSF/) {

    # chm file

    return "chm file";

  }

  if ($file =~ m/\.(iby|h|hby|hrh|oby|rsg|cpp)$/i) {

    return "Header file";

  }

  if ($file =~ /distribution\.policy$/i) {

	return "Distribution Policy"

  }

  return 'unknown format';

}

sub WriteFilteredData {

  my $file = shift;

  my $type = shift;

  my $md5 = shift;

  my $dumpDirExpandedFile = shift;

  my (@dumpDirBuffer);

  unless (exists $typeLookup{$type}) {

    die "Invalid file type \"$type\"";

  }

  $type = $typeLookup{$type};

  # Check to see if this file type requires expanding first

  if (exists $typeHandler{$type}->{expandor})

  {

    my $expandor = $typeHandler{$type}->{expandor};

    # Create two temporary directories

    my $tempdir = tempdir ( "EvalidExpand_XXXXXX", DIR => File::Spec->tmpdir, CLEANUP => 1);

    # Build the Expandor commandline

    $expandor =~ s/%TEMPDIR%/$tempdir/g;

    $expandor =~ s/%FILE%/$file/g;

    # Expand files

    my $output = `$expandor 2>&1`;

    print($log "Expanding using $expandor output was:-\n$output") if ($verbose);

    if ($? > 0)

    {

      print ($log "$expandor exited with $?") if ($verbose);

      # set type to be identical for retry if raw

      if ($typeHandler{$type}->{rawretry} == 1)

      {

        $type = 'identical';

      } else {

        print "ERROR: failed to start $expandor (" .($?). ") - reporting failure\n";

      }

    } else {    

      # Process all files in $tempdir

      my @FileList;

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

      foreach my $expandfile (@FileList)

      {

	  my $dumpDirExpandedFilename = "";

      if ($dumpDir)

      	{

	  	$dumpDirExpandedFilename = $expandfile;

		$dumpDirExpandedFilename =~ s/^.*EvalidExpand_\w+//;

	  	$dumpDirExpandedFilename = $file.$dumpDirExpandedFilename;

      	}

      my $type = IdentifyFileType($expandfile);

      &WriteFilteredData($expandfile, $type, $md5, $dumpDirExpandedFilename);

      }

    }

  }  elsif ($type ne 'identical') {

    unless (exists $typeHandler{$type}) {

      die "Invalid comparison type \"$type\"";

    }

    my $reader = $typeHandler{$type}->{reader};

    my $filter = $typeHandler{$type}->{filter};

    my $retry = $typeHandler{$type}->{retry} || 0;

    my $rawretry = $typeHandler{$type}->{rawretry} || 0;

	my $skipblanks = $typeHandler{$type}->{skipblanks} || 0;

    my $relativePaths = $typeHandler{$type}->{relative_paths} || 0;

    my $dosPaths = $typeHandler{$type}->{dos_paths} || 0;

	my $skipstderr = $typeHandler{$type}->{skipstderr} || 0;

	my $redirectstd = "2>&1";

	if ($skipstderr) {

		$redirectstd = "2>NUL";

	}

    if ($relativePaths) {

      $file = RelativePath($file);

    }

    if ($dosPaths) {

      $file =~ s/\//\\/g;       # convert to DOS-style backslash separators

    }

    my $raw;

    if ($reader) {

      $raw = IO::File->new("$reader \"$file\" $redirectstd |") or die "Error: Couldn't run \"$reader $file\": $!\n";

    }

    else {

      $raw = IO::File->new("$file") or die "Error: Couldn't open \"$file\": $!\n";

    }

    while (my $line = <$raw>) {

      &$filter(\$line);

	  next if $skipblanks and $line =~ /^\s*$/;

      $md5->add($line);

      push @dumpDirBuffer, $line if ($dumpDir);

    }

    Drain($raw);

    $raw->close();

    # Retry once if reader failed and reader has retry specified

    if ((($?>>8) != 0) && ($retry == 1))

    {

      print "Warning: $reader failed (" .($?>>8). ") on $file - retrying\n";

      # Reset MD5

      $md5->reset;

      undef @dumpDirBuffer if ($dumpDir);

      $raw = IO::File->new("$reader \"$file\" $redirectstd |") or die "Error: Couldn't run \"$reader $file\": $!\n";

      while (my $line = <$raw>)

      {

        &$filter(\$line);

		next if $skipblanks and $line =~ /^\s*$/;

        $md5->add($line);

        push @dumpDirBuffer, $line if ($dumpDir);

      }

      Drain($raw);

      $raw->close();

      if (($?>>8) != 0)

      {

        print "Error: $reader failed again (" .($?>>8) .") on $file - reporting failure\n";

      }

    }

    # Retry as raw if specified

    if (($?>>8) != 0) {

      if ($rawretry)

      {

          if ($reader =~ /^pfsdump/) { 

              print "Warning: $reader failed (". ($?>>8) .") on file $file - retrying as raw binary\n";

          }

          else {

              print "Info: something wrong to execute $reader (". ($?>>8) .") on file $file - retrying as raw binary\n";

          }

          # Set type to be identical so it will try it as a raw binary stream

          $type = 'identical';

      } else {

        print "Error: $reader failed (". ($?>>8) .") on file $file - not retrying as raw binary\n";

      }

    }

  }

  if ($type eq 'identical') {

    # Reset md5 as it might have been used in reader section

    $md5->reset;

	undef @dumpDirBuffer if ($dumpDir);

    # Treat 'identical' as a special case - no filtering, just write raw binary stream.

    my $raw = IO::File->new($file) or die "Error: Couldn't open \"$file\" for reading: $!\n";

    binmode($raw);

    my $buf;

    while ($raw->read($buf, 4096)) {

      $md5->add($buf);

    }