xref: /AOO41X/main/solenv/bin/modules/installer/patch/InstallationSet.pm (revision 677600b012ebe37b797093a198c8d8edc3d08429)

#**************************************************************
#
#  Licensed to the Apache Software Foundation (ASF) under one
#  or more contributor license agreements.  See the NOTICE file
#  distributed with this work for additional information
#  regarding copyright ownership.  The ASF licenses this file
#  to you under the Apache License, Version 2.0 (the
#  "License"); you may not use this file except in compliance
#  with the License.  You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing,
#  software distributed under the License is distributed on an
#  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
#  KIND, either express or implied.  See the License for the
#  specific language governing permissions and limitations
#  under the License.
#
#**************************************************************

package installer::patch::InstallationSet;

use installer::patch::Tools;
use installer::patch::Version;
use installer::logger;

use strict;

# Call Get7Zip() to get access to the filename of the 7z executable.
my $SevenZip = undef;


=head1 NAME

    package installer::patch::InstallationSet  -  Functions for handling installation sets

=head1 DESCRIPTION

    This package contains functions for unpacking the .exe files that
    are created by the NSIS installer creator and the .cab files in
    the installation sets.

=cut




=head2 Detect7ZipOnWindows ()

    7Zip seems to be the only program able to unpack an NSIS installer.
    Search for it.

=cut

sub Detect7ZipOnWindows ()
{
    # Use 'reg query' to read registry entry from Windows registry.
    my $registry_key = "HKEY_CURRENT_USER\\\\Software\\\\7-Zip";
    my $registry_value_name = "Path";
    my $command = sprintf("reg query %s /v %s", $registry_key, $registry_value_name);
    my $response = qx($command);

    # Process the response.
    my $path_to_7zip = undef;
    if ($response =~ /\s+REG_SZ\s+([^\r\n]*)/m)
    {
        $path_to_7zip = $1;
    }

    # If that failed, then make an educated guess.
    if ( ! defined $path_to_7zip)
    {
        $path_to_7zip = "c:\\Program Files\\7-Zip\\";
    }

    # Check if the executable exists and is, well, executable.
    return undef unless -d $path_to_7zip;
    my $fullname = File::Spec->catfile($path_to_7zip, "7z.exe");
    return undef unless -f $fullname;
    return undef unless -x $fullname;

    return $fullname;
}




sub Get7Zip ()
{
    if ( ! defined $SevenZip)
    {
        if ($ENV{'OS'} eq "WNT")
        {
            $SevenZip = Detect7ZipOnWindows();
        }
        if ( ! defined $SevenZip)
        {
            # Use an empty string to avoid repeated (and failing) detections of a missing 7z.
            $SevenZip = "";
        }
    }

    return $SevenZip eq "" ? undef : $SevenZip;
}




sub UnpackExe ($$)
{
    my ($filename, $destination_path) = @_;

    $installer::logger::Info->printf("unpacking installation set to '%s'\n", $destination_path);

    # Unpack to a temporary path and change its name to the destination path
    # only when the unpacking has completed successfully.
    File::Path::make_path($destination_path);

    my $windows_filename = installer::patch::Tools::ToEscapedWindowsPath($filename);
    my $windows_destination_path = installer::patch::Tools::ToEscapedWindowsPath($destination_path);
    my $command = join(" ",
        "\"".Get7Zip()."\"",
        "x",
        "-y",
        "-o".$windows_destination_path,
        $windows_filename);
    my $result = qx($command);
    if ( ! $result)
    {
        installer::exiter::exit_program(
            "ERROR: can not unpack downloadable installation set: ".$!,
            "installer::patch::InstallationSet::UnpackExe");
    }

    # Check the existence of the .cab files.
    my $cab_filename = File::Spec->catfile($destination_path, "openoffice1.cab");
    if ( ! -f $cab_filename)
    {
        installer::logger::PrintError("cab file '%s' was not extracted from installation set\n", $cab_filename);
        return 0;
    }
    return 1;
}




=head2 UnpackCab($cab_filename, $destination_path)

    Unpacking the cabinet file inside an .exe installation set is a
    three step process because there is no directory information stored
    inside the cab file.  This has to be taken from the 'File' and
    'Directory' tables in the .msi file.

    1. Setup the directory structure of all files in the cab from the 'File' and 'Directory' tables in the msi.

    2. Unpack the cab file.

    3. Move the files to their destination directories.

=cut
sub UnpackCab ($$$)
{
    my ($cab_filename, $msi, $destination_path) = @_;

    # Step 1
    # Extract the directory structure from the 'File' and 'Directory' tables in the given msi.
    $installer::logger::Info->printf("setting up directory tree\n");
    my $file_table = $msi->GetTable("File");
    my $file_map = $msi->GetFileMap();

    # Step 2
    # Unpack the .cab file to a temporary path.
    my $temporary_destination_path = $destination_path . ".tmp";
    if ( -d $temporary_destination_path)
    {
        # Temporary directory already exists => cab file has already been unpacked (flat), nothing to do.
        printf("%s exists\n", $temporary_destination_path);
        $installer::logger::Info->printf("cab file has already been unpacked to flat structure\n");
    }
    else
    {
        UnpackCabFlat($cab_filename, $temporary_destination_path, $file_table);
    }

    # Step 3
    # Move the files to their destinations.
    File::Path::make_path($destination_path);
    $installer::logger::Info->printf("moving files to their directories\n");
    my $directory_map = $msi->GetDirectoryMap();
    my $office_menu_folder_name = $directory_map->{'INSTALLLOCATION'}->{'target_long_name'};
    my $count = 0;
    foreach my $file_row (@{$file_table->GetAllRows()})
    {
        my $unique_name = $file_row->GetValue('File');
        my $file_item = $file_map->{$unique_name};
        my $directory_item = $file_item->{'directory'};
        my $long_file_name = $file_item->{'long_name'};
        my $full_name = $directory_item->{'full_source_long_name'};
        # Strip away the leading OfficeMenuFolder part.
        $full_name =~ s/^$office_menu_folder_name\///;
        my $flat_filename = File::Spec->catfile($temporary_destination_path, $unique_name);
        my $dir_path = File::Spec->catfile($destination_path, $full_name);
        my $dir_filename = File::Spec->catfile($dir_path, $long_file_name);

        if ( ! -d $dir_path)
        {
            File::Path::make_path($dir_path);
        }

        $installer::logger::Lang->printf("moving %s to %s\n", $flat_filename, $dir_filename);
        File::Copy::move($flat_filename, $dir_filename)
            || die("can not move file ".$flat_filename.":".$!);

        ++$count;
    }

    # Cleanup.  Remove the temporary directory.  It should be empty by now.
    rmdir($temporary_destination_path);
}




=head2 UnpackCabFlat ($cab_filename, $destination_path, $file_table)

    Unpack the flat file structure of the $cab_filename to $destination_path.

    In order to detect and handle an incomplete (arborted) previous
    extraction, the cab file is unpacked to a temprorary directory
    that after successful extraction is renamed to $destination_path.

=cut
sub UnpackCabFlat ($$$)
{
    my ($cab_filename, $destination_path, $file_table) = @_;

    # Unpack the .cab file to a temporary path (note that
    # $destination_path may alreay bee a temporary path). Using a
    # second one prevents the lengthy flat unpacking to be repeated
    # when another step fails.

    $installer::logger::Info->printf("unpacking cab file\n");
    File::Path::make_path($destination_path);
    my $windows_cab_filename = installer::patch::Tools::ToEscapedWindowsPath($cab_filename);
    my $windows_destination_path = installer::patch::Tools::ToEscapedWindowsPath($destination_path);
    my $command = join(" ",
        "\"".Get7Zip()."\"",
        "x", "-o".$windows_destination_path,
        $windows_cab_filename,
        "-y");
    open my $cmd, $command."|";
    my $extraction_count = 0;
    my $file_count = $file_table->GetRowCount();
    while (<$cmd>)
    {
        my $message = $_;
        chomp($message);
        ++$extraction_count;
        printf("%4d/%4d  %3.2f%%   \r",
            $extraction_count,
            $file_count,
            $extraction_count*100/$file_count);
    }
    close $cmd;
}




=head GetUnpackedExePath ($version, $is_current_version, $language, $package_format, $product)

    Convenience function that returns where a downloadable installation set is extracted to.

=cut
sub GetUnpackedExePath ($$$$$)
{
    my ($version, $is_current_version, $language, $package_format, $product) = @_;

    my $path = GetUnpackedPath($version, $is_current_version, $language, $package_format, $product);
    return File::Spec->catfile($path, "unpacked");
}




=head GetUnpackedCabPath ($version, $is_current_version, $language, $package_format, $product)

    Convenience function that returns where a cab file is extracted
    (with injected directory structure from the msi file) to.

=cut
sub GetUnpackedCabPath ($$$$$)
{
    my ($version, $is_current_version, $language, $package_format, $product) = @_;

    my $path = GetUnpackedPath($version, $is_current_version, $language, $package_format, $product);
    return File::Spec->catfile($path, "unpacked");
}




=head2 GetUnpackedPath($version, $is_current_version, $language, $package_format, $product)

    Internal function for creating paths to where archives are unpacked.

=cut
sub GetUnpackedPath ($$$$$)
{
    my ($version, $is_current_version, $language, $package_format, $product) = @_;

    return File::Spec->catfile(
        $ENV{'SRC_ROOT'},
        "instsetoo_native",
        $ENV{'INPATH'},
        $product,
        $package_format,
        installer::patch::Version::ArrayToDirectoryName(
            installer::patch::Version::StringToNumberArray($version)),
        installer::languages::get_normalized_language($language));
}




sub GetMsiFilename ($$)
{
    my ($path, $version) = @_;

    my $no_dot_version = installer::patch::Version::ArrayToNoDotName(
        installer::patch::Version::StringToNumberArray(
            $version));
    return File::Spec->catfile(
        $path,
        "openoffice" . $no_dot_version . ".msi");
}




sub GetCabFilename ($$)
{
    my ($path, $version) = @_;

    return File::Spec->catfile(
        $path,
        "openoffice1.cab");
}




=head2 Download($language, $release_data, $filename)

    Download an installation set to $filename.  The URL for the
    download is taken from $release_data, a snippet from the
    instsetoo_native/data/releases.xml file.

=cut
sub Download ($$$)
{
    my ($language, $release_data, $filename) = @_;

    my $url = $release_data->{'URL'};
    $release_data->{'URL'} =~ /^(.*)\/([^\/]+)$/;
    my ($location, $basename) = ($1,$2);

    $installer::logger::Info->printf("downloading %s\n", $basename);
    $installer::logger::Info->printf("    from '%s'\n", $location);
    my $filesize = $release_data->{'file-size'};
    if (defined $filesize)
    {
        $installer::logger::Info->printf("    expected size is %d\n", $filesize);
    }
    else
    {
        $installer::logger::Info->printf("    file size is not yet known\n");
    }
    my $temporary_filename = $filename . ".part";
    my $resume_size = 0;

    # Prepare checksum.
    my $checksum = undef;
    my $checksum_type = $release_data->{'checksum-type'};
    my $checksum_value = $release_data->{'checksum-value'};
    my $digest = undef;
    if ( ! defined $checksum_value)
    {
        # No checksum available.  Skip test.
    }
    elsif ($checksum_type eq "sha256")
    {
        $digest = Digest->new("SHA-256");
    }
    elsif ($checksum_type eq "md5")
    {
        $digest = Digest->new("md5");
    }
    else
    {
        installer::logger::PrintError(
            "checksum type %s is not supported.  Supported checksum types are: sha256,md5\n",
            $checksum_type);
        return 0;
    }

    # Download the extension.
    open my $out, ">$temporary_filename";
    binmode($out);

    my $mode = $|;
    my $handle = select STDOUT;
    $| = 1;
    select $handle;

    my $agent = LWP::UserAgent->new();
    $agent->timeout(120);
    $agent->show_progress(0);
    my $last_was_redirect = 0;
    my $bytes_read = 0;
    $agent->add_handler('response_redirect'
        => sub{
            $last_was_redirect = 1;
            return;
        });
    $agent->add_handler('response_data'
        => sub{
            if ($last_was_redirect)
            {
                $last_was_redirect = 0;
                # Throw away the data we got so far.
                $digest->reset() if defined $digest;
                close $out;
                open $out, ">$temporary_filename";
                binmode($out);
            }
            my($response,$agent,$h,$data)=@_;
            print $out $data;
            $digest->add($data) if defined $digest;
            $bytes_read += length($data);
            if (defined $filesize)
            {
                printf("read %*d / %d  %d%%  \r",
                    length($filesize),
                    $bytes_read,
                    $filesize,
                    $bytes_read*100/$filesize);
            }
            else
            {
                printf("read %6.2f MB\r", $bytes_read/(1024.0*1024.0));
            }
            });
    my $response;
    if ($resume_size > 0)
    {
        $response = $agent->get($url, 'Range' => "bytes=$resume_size-");
    }
    else
    {
        $response = $agent->get($url);
    }
    close $out;

    $handle = select STDOUT;
    $| = $mode;
    select $handle;

    $installer::logger::Info->print("                                        \r");

    if ($response->is_success())
    {
        if ( ! defined $digest
            || $digest->hexdigest() eq $checksum_value)
        {
            $installer::logger::Info->print("download was successfull\n");
            if ( ! rename($temporary_filename, $filename))
            {
                installer::logger::PrintError("can not rename '%s' to '%s'\n", $temporary_filename, $filename);
                return 0;
            }
            else
            {
                return 1;
            }
        }
        else
        {
            installer::logger::PrintError("%s checksum is wrong\n", $checksum_type);
            return 0;
        }
    }
    else
    {
        installer::logger::PrintError("there was a download error\n");
        return 0;
    }
}




=head2 ProvideDownloadSet ($version, $language, $package_format)

    Download an installation set when it is not yet present to
    $ENV{'TARFILE_LOCATION'}.  Verify the downloaded file with the
    checksum that is extracted from the
    instsetoo_native/data/releases.xml file.

=cut
sub ProvideDownloadSet ($$$)
{
    my ($version, $language, $package_format) = @_;

    my $release_item = installer::patch::ReleasesList::Instance()->{$version}->{$package_format}->{$language};
    return undef unless defined $release_item;

    # Get basename of installation set from URL.
    $release_item->{'URL'} =~ /^(.*)\/([^\/]+)$/;
    my ($location, $basename) = ($1,$2);

    # Is the installation set already present in ext_sources/ ?
    my $need_download = 0;
    my $ext_sources_filename = File::Spec->catfile(
        $ENV{'TARFILE_LOCATION'},
        $basename);
    if ( ! -f $ext_sources_filename)
    {
        $installer::logger::Info->printf("download set is not in ext_sources/ (%s)\n", $ext_sources_filename);
        $need_download = 1;
    }
    else
    {
        $installer::logger::Info->printf("download set exists at '%s'\n", $ext_sources_filename);
        if (defined $release_item->{'checksum-value'}
            && $release_item->{'checksum-type'} eq 'sha256')
        {
            $installer::logger::Info->printf("checking SHA256 checksum\n");
            my $digest = Digest->new("SHA-256");
            open my $in, "<", $ext_sources_filename;
            $digest->addfile($in);
            close $in;
            if ($digest->hexdigest() ne $release_item->{'checksum-value'})
            {
                $installer::logger::Info->printf("    mismatch\n", $ext_sources_filename);
                $need_download = 1;
            }
            else
            {
                $installer::logger::Info->printf("    match\n");
            }
        }
    }

    if ($need_download)
    {
        if ( ! installer::patch::InstallationSet::Download(
            $language,
            $release_item,
            $ext_sources_filename))
        {
            return 0;
        }
        if ( ! -f $ext_sources_filename)
        {
            $installer::logger::Info->printf("download set could not be downloaded\n");
            return 0;
        }
    }

    return $ext_sources_filename;
}




sub ProvideUnpackedExe ($$$$$)
{
    my ($version, $is_current_version, $language, $package_format, $product_name) = @_;

    # Check if the exe has already been unpacked.
    my $unpacked_exe_path = installer::patch::InstallationSet::GetUnpackedExePath(
        $version,
        $is_current_version,
        $language,
        $package_format,
        $product_name);
    my $unpacked_exe_flag_filename = File::Spec->catfile($unpacked_exe_path, "__exe_is_unpacked");
    my $exe_is_unpacked = -f $unpacked_exe_flag_filename;

    if ($exe_is_unpacked)
    {
        # Yes, exe has already been unpacked.  There is nothing more to do.
        $installer::logger::Info->printf("downloadable installation set has already been unpacked to\n");
        $installer::logger::Info->printf("    %s\n", $unpacked_exe_path);
        return 1;
    }
    elsif ($is_current_version)
    {
        # For the current version the exe is created from the unpacked
        # content and both are expected to be already present.

        # In order to have the .cab and its unpacked content in one
        # directory and don't interfere with the creation of regular
        # installation sets, we copy the unpacked .exe into a separate
        # directory.

        my $original_path = File::Spec->catfile(
            $ENV{'SRC_ROOT'},
            "instsetoo_native",
            $ENV{'INPATH'},
            $product_name,
            $package_format,
            "install",
            $language);
        $installer::logger::Info->printf("creating a copy\n");
        $installer::logger::Info->printf("    of %s\n", $original_path);
        $installer::logger::Info->printf("    at %s\n", $unpacked_exe_path);
        File::Path::make_path($unpacked_exe_path) unless -d $unpacked_exe_path;
	my ($file_count,$directory_count) = CopyRecursive($original_path, $unpacked_exe_path);
	return 0 if ( ! defined $file_count);
        $installer::logger::Info->printf("    copied %d files in %d directories\n",
	    $file_count,
	    $directory_count);

        installer::patch::Tools::touch($unpacked_exe_flag_filename);

        return 1;
    }
    else
    {
        # No, we have to unpack the exe.

        # Provide the exe.
        my $filename = installer::patch::InstallationSet::ProvideDownloadSet(
            $version,
            $language,
            $package_format);

        # Unpack it.
        if (defined $filename)
        {
            if (installer::patch::InstallationSet::UnpackExe($filename, $unpacked_exe_path))
            {
                $installer::logger::Info->printf("downloadable installation set has been unpacked to\n");
                $installer::logger::Info->printf("    %s\n", $unpacked_exe_path);

                installer::patch::Tools::touch($unpacked_exe_flag_filename);

                return 1;
            }
        }
        else
        {
            installer::logger::PrintError("could not provide .exe installation set at '%s'\n", $filename);
        }
    }

    return 0;
}




sub CopyRecursive ($$)
{
    my ($source_path, $destination_path) = @_;

    return (undef,undef) unless -d $source_path;

    my @todo = ([$source_path, $destination_path]);
    my $file_count = 0;
    my $directory_count = 0;
    while (scalar @todo > 0)
    {
	my ($source,$destination) = @{shift @todo};

	next if ! -d $source;
	File::Path::make_path($destination);
	++$directory_count;

	# Read list of files in the current source directory.
	opendir( my $dir, $source);
	my @files = readdir $dir;
	closedir $dir;

	# Copy all files and push all directories to @todo.
	foreach my $file (@files)
	{
	    next if $file =~ /^\.+$/;

	    my $source_file = File::Spec->catfile($source, $file);
	    my $destination_file = File::Spec->catfile($destination, $file);
	    if ( -f $source_file)
	    {
		File::Copy::copy($source_file, $destination_file);
		++$file_count;
	    }
	    elsif ( -d $source_file)
	    {
		push @todo, [$source_file, $destination_file];
	    }
	}
    }

    return ($file_count, $directory_count);
}




sub CheckLocalCopy ($$$$)
{
    my ($version, $language, $package_format, $product_name) = @_;

    # Compare creation times of the original .msi and its copy.

    my $original_path = File::Spec->catfile(
        $ENV{'SRC_ROOT'},
        "instsetoo_native",
        $ENV{'INPATH'},
        $product_name,
        $package_format,
        "install",
        $language);

    my $copy_path = installer::patch::InstallationSet::GetUnpackedExePath(
        $version,
        1,
        $language,
        $package_format,
        $product_name);

    my $msi_basename = "openoffice"
        . installer::patch::Version::ArrayToNoDotName(
            installer::patch::Version::StringToNumberArray($version))
        . ".msi";

    my $original_msi_filename = File::Spec->catfile($original_path, $msi_basename);
    my $copied_msi_filename = File::Spec->catfile($copy_path, $msi_basename);

    my @original_msi_stats = stat($original_msi_filename);
    my @copied_msi_stats = stat($copied_msi_filename);
    my $original_msi_mtime = $original_msi_stats[9];
    my $copied_msi_mtime = $copied_msi_stats[9];

    if (defined $original_msi_mtime
        && defined $copied_msi_mtime
        && $original_msi_mtime > $copied_msi_mtime)
    {
        # The installation set is newer than its copy.
        # Remove the copy.
        $installer::logger::Info->printf(
            "removing copy of installation set (version %s) because it is out of date\n",
            $version);
        File::Path::remove_tree($copy_path);
    }
}




=head2 ProvideUnpackedCab

    1a. Make sure that a downloadable installation set is present.
    1b. or that a freshly built installation set (packed and unpacked is present)
    2. Unpack the downloadable installation set
    3. Unpack the .cab file.

    The 'Provide' in the function name means that any step that has
    already been made is not made again.

=cut
sub ProvideUnpackedCab ($$$$$)
{
    my ($version, $is_current_version, $language, $package_format, $product_name) = @_;

    if ($is_current_version)
    {
        # For creating patches we maintain a copy of the unpacked .exe.  Make sure that that is updated when
        # a new installation set has been built.
        CheckLocalCopy($version, $language, $package_format, $product_name);
    }

    # Check if the cab file has already been unpacked.
    my $unpacked_cab_path = installer::patch::InstallationSet::GetUnpackedCabPath(
        $version,
        $is_current_version,
        $language,
        $package_format,
        $product_name);
    my $unpacked_cab_flag_filename = File::Spec->catfile($unpacked_cab_path, "__cab_is_unpacked");
    my $cab_is_unpacked = -f $unpacked_cab_flag_filename;

    if ($cab_is_unpacked)
    {
        # Yes. Cab was already unpacked. There is nothing more to do.
        $installer::logger::Info->printf("cab has already been unpacked to\n");
        $installer::logger::Info->printf("    %s\n", $unpacked_cab_path);

        return 1;
    }
    else
    {
        # Make sure that the exe is unpacked and the cab file exists.
        ProvideUnpackedExe($version, $is_current_version, $language, $package_format, $product_name);

        # Unpack the cab file.
        my $unpacked_exe_path = installer::patch::InstallationSet::GetUnpackedExePath(
                $version,
                $is_current_version,
                $language,
                $package_format,
                $product_name);
        my $msi = new installer::patch::Msi(
                installer::patch::InstallationSet::GetMsiFilename($unpacked_exe_path, $version),
                $version,
                $is_current_version,
                $language,
                $product_name);

        my $cab_filename = installer::patch::InstallationSet::GetCabFilename(
            $unpacked_exe_path,
            $version);
        if ( ! -f $cab_filename)
        {
             # Cab file does not exist.
            installer::logger::PrintError(
                "could not find .cab file at '%s'.  Extraction of .exe seems to have failed.\n",
                $cab_filename);
            return 0;
        }

        if (installer::patch::InstallationSet::UnpackCab(
            $cab_filename,
            $msi,
            $unpacked_cab_path))
        {
            $installer::logger::Info->printf("unpacked cab file '%s'\n", $cab_filename);
            $installer::logger::Info->printf("    to '%s'\n", $unpacked_cab_path);

            installer::patch::Tools::touch($unpacked_cab_flag_filename);

            return 1;
        }
        else
        {
            return 0;
        }
    }
}
1;