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

# All rights reserved.

# This component and the accompanying materials are made available

# 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 Build environment logging

# It collects versions of various tools and Windows hotfixes and writes them to the specified XML file

# 

#

package buildenv;

use strict;

use Carp;

use lib "$FindBin::Bin/lib";

# Module Win32::TieRegistry - Set delimiter to forward slash to avoid doubling all the backslashes!

# Do not ask for ArrayValues sice we are only reading data, not changing/editing anything.

use Win32::TieRegistry( Delimiter=>"/" );

# Main

#

# Inputs

# - $iHostName        - Name of host computer (to be written into the XML file)

# - $iXMLfilePathname - Full pathname of output .XML file

#

#   note: XML file will have been named after the hostname that

#         the script was run on. See BuildEnv.pl.

#

# Description

#   Collects OS information and versions of know tools.

#   Writes resulting build environment info to specified XML file

#

sub Main

{

  my ($iHostName, $iXMLfilePathname)      = @_;

  my (%iToolList)                = &buildenv::GetToolInfo();

  my ($iWinEnvVer, %iHotFixList) = &buildenv::GetWinInfo();

  # write the same info in xml - useful for future tools

  &WriteXMLFormat($iHostName, $iXMLfilePathname, $iWinEnvVer, \%iHotFixList, \%iToolList);

}

# WriteXMLFormat

#

# Description

#   Writes build environment info to XML file

#

# Inputs

#   - $iWinVer      - scalar with info on windows version

#   - $iHotFixRef   - ref to hash containing hotfix info

#   - $iToolListRef - ref to hash containing tool info

#

# Outputs

#   Writes XML file

#

sub WriteXMLFormat

{

  use IO;

  use XML::Writer;

  # get one scalar and 2 refs to hashes

  my ($iHostName, $iXMLfilePathname, $iWinVer, $iHotFixListRef, $iToolListRef) = @_;

  my $DTD = "

    <!DOCTYPE machine_config [

    <!ELEMENT machine_config (operating_sys,tool*)>

    <!ATTLIST machine_config

      name CDATA #REQUIRED

    >

    <!ELEMENT operating_sys (hotfix*)>

    <!ATTLIST operating_sys

      name         CDATA #REQUIRED

      version      CDATA #REQUIRED

      servicepack  CDATA #REQUIRED

      buildnumber  CDATA #REQUIRED

    >

    <!ELEMENT hotfix EMPTY>

    <!ATTLIST hotfix

      name         CDATA #REQUIRED

      installdate  CDATA #REQUIRED

    >

    <!ELEMENT tool EMPTY>

    <!ATTLIST tool

      name      CDATA #REQUIRED

      version   CDATA #REQUIRED

    >

    ]> ";

  my $output = new IO::File("> $iXMLfilePathname");

  my $writer = new XML::Writer( OUTPUT => $output, DATA_MODE => 'true', DATA_INDENT => 2  );

  $writer->xmlDecl( 'UTF-8' );

  print $output $DTD;

  $writer->comment( 'machine_config  at ' . localtime() );

  $writer->startTag( 'machine_config', 'name' => $iHostName);

      # breakdown the winversion string to its component parts:

      $iWinVer =~ m/Microsoft Windows(.*)ver(.*)Service Pack(.*)Build(.*)/;

      $writer->startTag( 'operating_sys', 'name'       => 'Microsoft Windows'.$1,

                                          'version'    => $2,

                                          'servicepack'=> $3,

                                          'buildnumber'=> $4);

      foreach my $fixnum (sort keys %$iHotFixListRef)

      {

        $writer->startTag( 'hotfix', name => $fixnum, 'installdate' => $iHotFixListRef->{$fixnum} );

        $writer->endTag( );

      }

      $writer->endTag( ); # operating_sys

      foreach my $toolname (sort {uc $a cmp uc $b} keys %$iToolListRef)

      {

        $writer->startTag( 'tool', name => $toolname, 'version' => $iToolListRef->{$toolname}{'version'} );

        # Look for modules supporting the current tool (e.g Perl modules)

        if (defined $iToolListRef->{$toolname}{'modules'})

        {

            foreach my $modulename (sort {uc $a cmp uc $b} keys %{$iToolListRef->{$toolname}{'modules'}})

            {

                $writer->startTag( 'module', name => $modulename, 'version' => $iToolListRef->{$toolname}{'modules'}{$modulename} );

                $writer->endTag( );

            }

        }

        # Look for other versions of the current tool for which files exist but are not reached via default PATH (e.g ARM RVCT)

        if (defined $iToolListRef->{$toolname}{'multiver'})

        {

            foreach my $multiverdirectory (sort {uc $a cmp uc $b} keys %{$iToolListRef->{$toolname}{'multiver'}})

            {

                $writer->startTag( 'multiversion', name => $multiverdirectory, 'version' => $iToolListRef->{$toolname}{'multiver'}{$multiverdirectory} );

                $writer->endTag( );

            }

        }

        $writer->endTag( );

      }

  $writer->endTag( );     # machine_config

  $writer->end( );

}

# GetWinInfo

#

# Description

#   Gets Windows version. Collects information on Windows hotfixes (patches)

#

# Inputs - None

#

# Returns

#   $iWinEnv - Windows version, SP# and build

#   %iHotFixList - Installed Hotfix patch installation dates

#

sub GetWinInfo

{

    my %iHotFixList;

    my $iWinEnv = 'Windows : Unknown version';

    # Extract information from the Windows Registry - First get the OS name and version

    my %iValues;

    my $iRegKey   = 'LMachine/SOFTWARE/Microsoft/Windows NT/CurrentVersion';

    # Get data from hash set up by Win32::TieRegistry

    my $iHashRef = $Registry->{$iRegKey} or  return ($iWinEnv, %iHotFixList);

    # Check that hash element exists before referencing data. Otherwise TieRegistry will think that we want to create a new key/value

    my $iProd = (defined $iHashRef->{'/ProductName'})? $iHashRef->{'/ProductName'}: '';

    my $iVer = (defined $iHashRef->{'/CurrentVersion'})? $iHashRef->{'/CurrentVersion'}: '';

    my $iSPVer = (defined $iHashRef->{'/CSDVersion'})? $iHashRef->{'/CSDVersion'}: '';

    my $iBuild = (defined $iHashRef->{'/CurrentBuildNumber'})? $iHashRef->{'/CurrentBuildNumber'}: '';

    $iWinEnv =$iProd .' ver ' . $iVer . ' ' . $iSPVer . ' Build ' . $iBuild . "\n";

    # Next get the list of patches - First assume "Windows 2003" then "Windows 2000"

    $iRegKey   = 'LMachine/SOFTWARE/Microsoft/Updates/Windows Server 2003';

    $iHashRef = $Registry->{$iRegKey};

    unless (defined $iHashRef)

    {

        $iRegKey   = 'LMachine/SOFTWARE/Microsoft/Updates/Windows 2000';

        $iHashRef = $Registry->{$iRegKey};

        unless (defined $iHashRef)

        {

            return ($iWinEnv, %iHotFixList);

        }

    }

    foreach my $iKey0 (sort keys %$iHashRef)            # Key = service pack identifier; e.g. 'SP-1/', 'SP2/' ... Note trailing delimiter!

    {

        my $iHashRef1 = $iHashRef->{$iKey0};

        unless (ref($iHashRef1)) { next; }               # Skip occasional data item. Reference Type (if any) is 'Win32::TieRegistry'

        foreach my $iKey1 (sort keys %$iHashRef1)        # Key = hotfix reference; e.g. 'Q816093/' etc. Note trailing delimiter!

        {

            my $iHashRef2 = $iHashRef1->{$iKey1};

            unless (ref($iHashRef2)) { next; }           # Skip occasional data item. Reference Type (if any) is 'Win32::TieRegistry'

            foreach my $iKey2 (sort keys %$iHashRef2)    # Key = hotfix property; e.g. '/InstalledDate' etc. Note leading delimiter!

            {

                if ($iKey2 =~ m/^\/InstalledDate/)

                {

                    $iKey0 =~ s/\/$//;   # Remove trailing delimiter (slash) from service pack identifier

                    $iKey1 =~ s/\/$//;   # Remove trailing delimiter (slash) from hotfix reference

                    $iHotFixList{"$iKey0 $iKey1"}= $iHashRef2->{$iKey2};

                }

            }

        }

    }

    return ($iWinEnv, %iHotFixList);

}

# GetToolInfo

#

# Description

#   Collects OS information and versions of known tools.

#

# Inputs - None

#

# Returns

#   %iToolList - Tool versions

#

sub GetToolInfo

{

    my %iToolList;

    my $iToolName;

    GetPerlInfo(\%iToolList);

    GetMetrowerksInfo(\%iToolList);

    GetArmInfo(\%iToolList);

    GetJavaInfo(\%iToolList);

    # Location of reltools is assumed to be C:\Apps\RelTools\

    $iToolName = 'RelTools';

    my $iRelToolsVerTxt = 'C:\\Apps\\RelTools\\Version.txt';

    $iToolList{$iToolName}{'version'} = 'Unknown';

    if (-e $iRelToolsVerTxt)

    {

        my @iReltools = `type $iRelToolsVerTxt 2>&1`;

        # Get RelTools version (must start with numeric value). Assumed to be in first line of file

        if ($iReltools[0] =~ m/(^[0-9]{0,2}[0-9]{0,2}.*)(\n$)/) {

            $iToolList{$iToolName}{'version'} = $1;

        }

    }

    # Perforce Client (Typical output "Rev. P4/NTX86/2003.2/56831 (2004/04/13).")

    my $iToolNameVer = 'Perforce version';

    my $iToolNameRel = 'Perforce release';

    my @iP4Env = `P4 -V 2>&1`;

    $iToolList{$iToolNameVer}{'version'} =  'Unknown';

    $iToolList{$iToolNameRel}{'version'} =  'Unknown';

    foreach (@iP4Env)

    {

        if (m/Rev\.\s+(\S+)\s+\((.+)\)/)

        {

            $iToolList{$iToolNameVer}{'version'} =  $1;

            $iToolList{$iToolNameRel}{'version'} =  $2;

        }

    }

    # NSIS Compiler

    $iToolName = 'NSIS version';

    my @iNSIS_ver = `MakeNSIS.exe /VERSION 2>&1`;

    $iToolList{$iToolName}{'version'} =  'Unknown';

    if ($iNSIS_ver[0] =~ m/v(\d+\.\d+)/i)

    {

        $iToolList{$iToolName}{'version'} =  $1;

    }

    # PsKill utility (SysInternals)

    # PsKill v1.11 - Terminates processes on local or remote systems

    $iToolName = 'PsKill';

    my @iPSKillVer = `PsKill 2>&1`;

    $iToolList{$iToolName}{'version'} = 'Unknown';

    foreach (@iPSKillVer)

    {

        if (m/PsKill v(\d+\.\d+)/) { $iToolList{$iToolName}{'version'} =  $1; last;}

    }

    GetSophosInfo(\%iToolList);    # Sophos Anti-virus

    GetMcAfeeInfo(\%iToolList);    # McAfee Anti-virus

    GetGPGInfo(\%iToolList);       # GPG (Command line encryption program)

    GetWinTapInfo(\%iToolList);    # Win-TAP

    return %iToolList;  

}

# GetPerlInfo

#

# Description

#   Gets Perl Version (currently usually 5.6.1 or, on a few special machines, 5.8.7)

#   If Perl is found, we go on to list Perl Modules using "PPM query" but under Perl Version

#

# Inputs - Reference to Tool List hash (for return of data)

#

# Outputs - Data returned via supplied hashref

#

sub GetPerlInfo

{

    my $iToolList = shift;

# Typical output from "Perl -v"

# This is perl, v5.6.1 built for MSWin32-x86-multi-thread

# (with 1 registered patch, see perl -V for more detail)

#

# Copyright 1987-2001, Larry Wall

#

# Binary build 635 provided by ActiveState Corp. http://www.ActiveState.com

# Built 15:34:21 Feb  4 2003

#

    my $iToolName = 'Perl';

    my $iVersion;

    my $iBuildNum;

    my @iRetData     = `perl -v 2>&1`;

    $iToolList->{$iToolName}{'version'} = 'Unknown';

    foreach (@iRetData)

    {	# Analyse output from "Perl -v"

        if (m/ (version\s+|v)([0-9]{0,2}\.[0-9]{0,3}[_\.][0-9]{0,2})/)

        {

            if ($iVersion) {  print "ERROR: Perl Version redefined as $2.\n"; last; }	# Error? Can't have version defined twice!?

            $iVersion = $2;

            my $iMatchStr = '^([-\\w]+)\\s+\\[([.\\d]+)\\s*\\]';

            my @iRetData     = `ppm query 2>&1`;				# Ask PPM for a list of modules

            if ($iRetData[0] =~ m/No query result sets -- provide a query term\./i) # This is the response from Perl v5.8.7. Try new-style query!

            {

                $iMatchStr = '([\\-\\w]+)\\s+\\[([\\.\\d]+\w?)([\\~\\]])';

                `ppm set fields \"name version\" 2>&1`;			# Specified required fields. CAUTION: PPM remembers settings from previous "PPM query" call

                @iRetData     = `ppm query * 2>&1`;				# Ask PPM for a list of modules

            }

            foreach (@iRetData)

            {	# Analyse list of modules 

                if (m/$iMatchStr/)

                {

                    $iToolList->{$iToolName}{'modules'}{$1} = ($3 eq '~')? $2 . $3: $2;

                }

            }

            # Check for Inline-Java (which somehow escapes the attention of PPM

            my $iModuleName = 'Inline-Java';

            $iToolList->{$iToolName}{'modules'}{$iModuleName} = GetPerlModuleInfo($iModuleName);

            # Check for XML-DOM (earlier installations also escaped PPM)

            $iModuleName = 'XML-DOM';

            unless (defined $iToolList->{$iToolName}{'modules'}{$iModuleName})

            {

                $iToolList->{$iToolName}{'modules'}{$iModuleName} = GetPerlModuleInfo($iModuleName);

            }

        }

        elsif (m/Binary\s+build\s+(\d+)/i)

        {

          if ($iBuildNum) { print "ERROR: Perl Build Number  redefined as $1.\n"; last; }	# Error? Can't have build defined twice!?

          $iBuildNum = $1;

        }

    }       # End foreach (@iRetData)

    # We have already set $iToolList->{$iToolName}{'version'} = 'Unknown';

    # So if $iVersion is still undefined, leave well alone! Eventually return 'Unknown'.

    if ($iVersion)        # Found version. Have we got a Build Number?

    {

        unless($iBuildNum) { $iBuildNum = 'Build unknown'; }

        $iToolList->{$iToolName}{'version'} = "$iVersion [$iBuildNum]";

    }

    # Next look for "Multiple Versions"

    # For example "\\LON-ENGBUILD54\C$\Apps\Perl.5.10.0"

    my $iAppsRoot = 'C:\Apps';

    my $iPerlExe  = 'bin\Perl.exe';

    my $iAppsDirs = ReadDirectory($iAppsRoot);      # Get arrayref

    unless (defined $iAppsDirs)

    {

        print "ERROR:  Failed to read Apps Directory.\n";

        return;

    }

    foreach my $iAppsDir (@$iAppsDirs)

    {

        if ($iAppsDir =~ m/^Perl\.(\d.*)/i)

        {

            my $iMultiVer = $1;

            $iAppsDir = uc $iAppsDir;       # Source is a Windows directory name, which could be in any case

            $iToolList->{$iToolName}{'multiver'}{$iMultiVer} =  'Unknown';

            $iVersion = '';

            $iBuildNum = '';

            my @iPerlExeRet = `$iAppsRoot\\$iAppsDir\\$iPerlExe -v`;

            foreach (@iPerlExeRet)

            {

                if (m/ (version\s+|v)([0-9]{0,2}\.[0-9]{0,3}[_\.][0-9]{0,2})/)

                { 

                    if ($iVersion) { print "ERROR: Perl Version  redefined as $2.\n"; last; }	# Error? Can't have version defined twice!?

                    $iVersion =  $2;

                }

                elsif (m/Binary\s+build\s+(\d+)/i)

                {

                    if ($iBuildNum) { print "ERROR: Perl Build Number  redefined as $1.\n"; last; }	# Error? Can't have build defined twice!?

                    $iBuildNum = $1;

                }

            }

            # We have already set $iToolList->{$iToolName}{'multiver'}{$iMultiVer} = 'Unknown';

            # So if $iVersion is still undefined, leave well alone! Eventually return 'Unknown'.

            if ($iVersion)        # Found version. Have we got a Build Number?

            {

                unless($iBuildNum) { $iBuildNum = 'Build unknown'; }

                $iToolList->{$iToolName}{'multiver'}{$iMultiVer} = "$iVersion [$iBuildNum]";

            }

        }

    }       # End foreach my $iAppsDir (@$iAppsDirs)

}

# GetPerlModuleInfo

#

# Description

#   Gets Version for the specified Perl Module 

#

# Inputs - Name of Module 

#

# Retuens - Version text

#

sub GetPerlModuleInfo

{

    my $iModuleName = shift;

    my $iVerTxt = 'Unknown';

    $iModuleName =~ s/-/::/;

    if (eval "require $iModuleName;")

    {

        no strict 'refs';

        $iVerTxt = ${$iModuleName . "::VERSION"};

        use strict;

    }

    return $iVerTxt;

}

# GetMetrowerksInfo

#

# Description

#   Gets Metrowerks Compiler and Linker Versions

#

# Inputs - Reference to Tool List hash (for return of data)

#

# Outputs - Data returned via supplied hashref

#

sub GetMetrowerksInfo

{

    my $iToolList = shift;

    # First get the version of the default Compiler (MWCCSym2), as located by the "permanent" PATH etc.

    my $iToolNameCC = 'Metrowerks Compiler';

    $iToolList->{$iToolNameCC}{'version'} = 'Unknown';

    my @iCCRet     = `mwccsym2 -version 2>&1`;

    foreach (@iCCRet)

    {

        if (m/Version(.*)(\n$)/)

        {

            $iToolList->{$iToolNameCC}{'version'} =  $1;

            last;

        }

    }

    # Now get the version of the default Linker (MWLDSym2), as located by the "permanent" PATH etc.

    my $iToolNameLD = 'Metrowerks Linker';

    my @iLDEnv     = `mwldsym2 -version 2>&1`;

    $iToolList->{$iToolNameLD}{'version'} = 'Unknown';

    foreach (@iLDEnv) 

    {

        if (m/Version(.*)(\n$)/) 

        { 

            $iToolList->{$iToolNameLD}{'version'} =  $1;

            last;

        }

    }

    # Next look for "Multiple Versions"

    # For example "\\LON-ENGBUILD54\C$\Apps\Metrowerks\OEM3.1.1\Symbian_Tools\Command_Line_Tools\mwccsym2.exe"

    my $iMWksRoot = 'C:\Apps\Metrowerks';

    my $iMWksCC   = 'Symbian_Tools\Command_Line_Tools\mwccsym2.exe';

    my $iMWksLD   = 'Symbian_Tools\Command_Line_Tools\mwldsym2.exe';

    my $iMWksDirs = ReadDirectory($iMWksRoot);      # Get arrayref

    unless (defined $iMWksDirs)

    {

        print "ERROR:  Failed to read Metrowerks Root Directory.\n";

        return;

    }

    foreach my $iMWksDir (@$iMWksDirs)

    {

        if ($iMWksDir =~ m/^OEM\d+\.\d+/i)

        {

            $iMWksDir = uc $iMWksDir;       # Source is a Windows directory name, which could be in any case

            my @iMWksCCRet = `$iMWksRoot\\$iMWksDir\\$iMWksCC`;

            $iToolList->{$iToolNameCC}{'multiver'}{$iMWksDir} =  'Unknown';

            foreach my $iLine(@iMWksCCRet)

            {

                if ($iLine =~ m/Version(.*)(\n$)/i)

                { 

                    $iToolList->{$iToolNameCC}{'multiver'}{$iMWksDir} =  $1;

                    last;

                }

            }

            my @iMWksLDRet = `$iMWksRoot\\$iMWksDir\\$iMWksLD`;

            $iToolList->{$iToolNameLD}{'multiver'}{$iMWksDir} =  'Unknown';

            foreach my $iLine(@iMWksLDRet)

            {

                if ($iLine =~ m/Version(.*)(\n$)/i)

                { 

                    $iToolList->{$iToolNameLD}{'multiver'}{$iMWksDir} =  $1;

                    last;

                }

            }

        }

    }       # End foreach my $iMWksDir (@$iMWksDirs)

}

# GetArmInfo

#

# Description

#   Looks for directories below C:\Apps\ARM which might contain versions of RVCT compiler etc.

#

# Inputs - Reference to Tool List hash (for return of data)

#

# Outputs - Data returned via supplied hashref

#

sub GetArmInfo

{

    my $iToolList = shift;

    my $iToolName = 'Arm CC';

    # First get the version of the default ARMCC, as located by the "permanent" PATH etc.

    $iToolList->{$iToolName}{'version'} = 'Unknown';