xref: /trunk/main/solenv/bin/modules/installer/archivefiles.pm (revision 86e1cf34)

#**************************************************************
#
#  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::archivefiles;

use Archive::Zip qw( :ERROR_CODES :CONSTANTS );
use installer::converter;
use installer::existence;
use installer::exiter;
use installer::files;
use installer::globals;
use installer::logger;
use installer::pathanalyzer;
use installer::systemactions;

#################################################################
# Changing the name for files with flag RENAME_TO_LANGUAGE
#################################################################

sub put_language_into_name
{
	my ( $oldname, $onelanguage ) = @_;

	my $newname = "";

	my $filename = "";
	my $extension = "";

	if ( $oldname =~ /en-US/ )	# files, that contain the language in the file name
	{
		$newname = $oldname;
		$newname =~ s/en-US/$onelanguage/;
	}
	else	# files, that do not contain the language in the file name
	{
		if ( $oldname =~ /^\s*(.*)(\..*?)\s*$/ )	# files with extension
		{
			$filename = $1;
			$extension = $2;
		}
		else
		{
			$filename = $oldname;
			$extension = "";
		}

		$newname = $1 . "_" . $onelanguage . $2;
	}

	return $newname;
}

#################################################################
# Converting patchfiles string into array
#################################################################

sub get_patch_file_list
{
	my ( $patchfilestring ) = @_;

	$patchfilestring =~ s/^\s*\(?//;
	$patchfilestring =~ s/\)?\s*$//;
	$patchfilestring =~ s/^\s*\///;
	$patchfilestring =~ s/^\s*\\//;

	my $patchfilesarray = installer::converter::convert_stringlist_into_array_without_linebreak_and_quotes(\$patchfilestring, ",");

	return $patchfilesarray;
}

#################################################################
# Reading all executables in the "manifest.xml"
#################################################################

sub get_all_executables_from_manifest
{
	my ($unzipdir, $manifestfile, $executable_files_in_extensions) = @_;

	my $is_executable = 0;

	for ( my $i = 0; $i <= $#{$manifestfile}; $i++ )
	{
		my $line = ${$manifestfile}[$i];

		if ( $line =~ /\"application\/vnd\.sun\.star\.executable\"/ ) { $is_executable = 1; }

		if (( $line =~ /manifest\:full\-path=\"(.*?)\"/ ) && ( $is_executable ))
		{
			my $filename = $unzipdir . $installer::globals::separator . $1;
			# making only slashes for comparison reasons
			$filename =~ s/\\/\//g;
			$executable_files_in_extensions->{$filename} = 1;
		}

		if ( $line =~ /\/\>/ ) { $is_executable = 0; }
	}
}

#################################################################
# Reading the "manifest.xml" in extensions and determine, if
# there are executable files
#################################################################

sub collect_all_executable_files_in_extensions
{
	my ($unzipdir, $executable_files_in_extensions) = @_;

	$unzipdir =~ s/\Q$installer::globals::separator\E\s*$//;

	my $manifestfilename = $unzipdir . $installer::globals::separator . "META-INF" . $installer::globals::separator . "manifest.xml";

	if ( -f $manifestfilename )
	{
		my $manifestfile = installer::files::read_file($manifestfilename);
		get_all_executables_from_manifest($unzipdir, $manifestfile, $executable_files_in_extensions);
	}
}

#################################################################
# Analyzing files with flag ARCHIVE
#################################################################

sub resolving_archive_flag
{
	my ($filesarrayref, $additionalpathsref, $languagestringref, $loggingdir) = @_;

	if ( $installer::globals::debug ) { installer::logger::debuginfo("installer::archivefiles::resolving_archive_flag : $#{$filesarrayref} : $#{$additionalpathsref} : $$languagestringref : $loggingdir"); }

	my @newallfilesarray = ();

	my ($systemcall, $returnvalue, $infoline);

	my $unziplistfile = $loggingdir . "unziplist_" . $installer::globals::build . "_" . $installer::globals::compiler . "_" . $$languagestringref . ".txt";

	my $platformunzipdirbase = installer::systemactions::create_directories("zip", $languagestringref);
	push(@installer::globals::removedirs, $platformunzipdirbase);

	installer::logger::include_header_into_logfile("Files with flag ARCHIVE:");

	my $repeat_unzip = 0;
	my $maxcounter = 0;

	for ( my $i = 0; $i <= $#{$filesarrayref}; $i++ )
	{
		if ( $repeat_unzip ) { $i--; }	# decreasing the counter

		my $onefile = ${$filesarrayref}[$i];
		my $styles = "";

		if ( $onefile->{'Styles'} ) { $styles = $onefile->{'Styles'}; }

		if ( $styles =~ /\bARCHIVE\b/ )		# copying, unzipping and changing the file list
		{
			my $iscommonfile = 0;
			my $sourcepath = $onefile->{'sourcepath'};

			if ( $sourcepath =~ /\Q$installer::globals::separator\E\bcommon$installer::globals::productextension\Q$installer::globals::separator\E/ )	# /common/ or /common.pro/
			{
				$iscommonfile = 1;
			}

			my $use_internal_rights = 0;
			if ( $styles =~ /\bUSE_INTERNAL_RIGHTS\b/ ) { $use_internal_rights = 1; }	# using the rights used inside the zip file

			my $rename_to_language = 0;
			if ( $styles =~ /\bRENAME_TO_LANGUAGE\b/ ) { $rename_to_language = 1; }	# special handling for renamed files (scriptitems.pm)

			my %executable_files_in_extensions = ();
			my $set_executable_privileges = 0;  # setting privileges for exectables is required for oxt files
			if ( $onefile->{'Name'} =~ /\.oxt\s*$/ ) { $set_executable_privileges = 1; }

			# mechanism to select files from an archive files
			my $select_files = 0;
			my $selectlistfiles = "";
			my @keptfiles = ();
			if ( $onefile->{'Selectfiles'} )
			{
				$select_files = 1;
				$selectlistfiles = get_patch_file_list( $onefile->{'Selectfiles'} );
                $installer::logging::Lang->printf("Selected file list defined at file: %s :\n", $onefile->{'Name'});
                foreach my $line (@$selectlistfiles)
				{
                    $installer::logging::Lang->printf("\"%s\"\n", $line);
				}
			}

			if ( $onefile->{'Selectfiles'} ) { $onefile->{'Selectfiles'} = ""; } # Selected files list no longer required

			# mechanism to define patch files inside an archive files
			my $select_patch_files = 0;
			my $patchlistfiles = "";
			my @keptpatchflags = ();
			if (( $styles =~ /\bPATCH\b/ ) && ( $onefile->{'Patchfiles'} ) && ( $installer::globals::patch ))
			{
				$select_patch_files = 1; # special handling if a Patchlist is defined
				$patchlistfiles = get_patch_file_list( $onefile->{'Patchfiles'} );
                $installer::logger::Lang->printf("Patch file list defined at file: %s :\n", $onefile->{'Name'});
				foreach my $line (@$patchlistfiles)
				{
                    $installer::logger::Lang->printf("\"%s\"\n", $line);
				}
			}

			if ( $onefile->{'Patchfiles'} ) { $onefile->{'Patchfiles'} = ""; } # Patch file list no longer required

			# creating directories

			my $onelanguage = $onefile->{'specificlanguage'};

			# files without language into directory "00"

			if ($onelanguage eq "") { $onelanguage = "00"; }

			my $unzipdir;

			# if ($iscommonfile) { $unzipdir = $commonunzipdirbase . $installer::globals::separator . $onelanguage . $installer::globals::separator; }
			# else { $unzipdir = $platformunzipdirbase . $installer::globals::separator . $onelanguage . $installer::globals::separator; }

			$unzipdir = $platformunzipdirbase . $installer::globals::separator . $onelanguage . $installer::globals::separator;

			installer::systemactions::create_directory($unzipdir);	# creating language specific subdirectories

			my $onefilename = $onefile->{'Name'};
			$onefilename =~ s/\./\_/g;		# creating new directory name
			$onefilename =~ s/\//\_/g;		# only because of /letter/fontunxpsprint.zip, the only zip file with path
			$unzipdir = $unzipdir . $onefilename . $installer::globals::separator;

			if ( $installer::globals::dounzip ) { installer::systemactions::create_directory($unzipdir); }	# creating subdirectories with the names of the zipfiles

			my $zip = Archive::Zip->new();
			if ( $zip->read($sourcepath) != AZ_OK )
			{
                $installer::logger::Lang->printf("ERROR: Could not unzip %s\n", $sourcepath);
			}

			my $counter = 0;
			my $contains_dll = 0;
			foreach my $member ( $zip->memberNames() )
			{
				$counter++;
				if ( $member =~ /.dll\s*$/ ) { $contains_dll = 1; }
			}

			if (! ( $counter > 0 ))	# the zipfile is empty
			{
                $installer::logger::Lang->printf("ERROR: Could not unzip %s\n", $sourcepath);
			}
			else
			{
				if ( $installer::globals::dounzip )			# really unpacking the files
				{
					if ( $zip->extractTree("", $unzipdir) != AZ_OK )
                    {
                        installer::exiter::exit_program("ERROR: can not unzip ".$sourcepath, "resolving_archive_flag");
                    }

					if (( $^O =~ /cygwin/i ) && ( $contains_dll ))
					{
						# Make dll's executable
						$systemcall = "cd $unzipdir; find . -name \\*.dll -exec chmod 775 \{\} \\\;";
						$returnvalue = system($systemcall);
						$installer::logger::Lang->printf("Systemcall: %s\n", $systemcall);

						if ($returnvalue)
						{
							$installer::logger::Lang->printf("ERROR: Could not execute \"\"!\n", $systemcall);
						}
					}

					if ( ! $installer::globals::iswindowsbuild )
					{
						# Setting unix rights to "775" for all created directories inside the package

						$systemcall = "cd $unzipdir; find . -type d -exec chmod 775 \{\} \\\;";
						$returnvalue = system($systemcall);
                        $installer::logger::Lang->printf("Systemcall: %s\n", $systemcall);
						if ($returnvalue)
						{
                            $installer::logger::Lang->printf("ERROR: Could not execute \"\"!\n", $systemcall);
						}
					}

					# Selecting names of executable files in extensions
					if ( $set_executable_privileges )
					{
						collect_all_executable_files_in_extensions($unzipdir, \%executable_files_in_extensions);
					}
				}

				my $zipfileref = \@zipfile;
				my $unziperror = 0;

				foreach my $zipname ( $zip->memberNames() )
				{
					# Format from Archive:::Zip :
					# dir1/
					# dir1/so7drawing.desktop

					# some directories and files (from the help) start with "./simpress.idx"

					$zipname =~ s/^\s*\.\///;

					if ($installer::globals::iswin and $^O =~ /MSWin/i) { $zipname =~ s/\//\\/g; }

					if ( $zipname =~ /\Q$installer::globals::separator\E\s*$/ )	# slash or backslash at the end characterizes a directory
					{
						$zipname = $zipname . "\n";
						push(@{$additionalpathsref}, $zipname);

						# Also needed here:
						# Name
						# Language
						# ismultilingual
						# Basedirectory

						# This is not needed, because the list of all directories for the
						# epm list file is generated from the destination directories of the
						# files included in the product!
					}
					else
					{
						my %newfile = ();
						%newfile = %{$onefile};
						$newfile{'Name'} = $zipname;
						my $destination = $onefile->{'destination'};
						installer::pathanalyzer::get_path_from_fullqualifiedname(\$destination);
						$newfile{'destination'} = $destination . $zipname;
						$newfile{'sourcepath'} = $unzipdir . $zipname;
						$newfile{'zipfilename'} = $onefile->{'Name'};
						$newfile{'zipfilesource'} = $onefile->{'sourcepath'};
						$newfile{'zipfiledestination'} = $onefile->{'destination'};

						if (( $use_internal_rights ) && ( ! $installer::globals::iswin ))
						{
							my $value = sprintf("%o", (stat($newfile{'sourcepath'}))[2]);
							$newfile{'UnixRights'} = substr($value, 3);
                            $installer::logger::Lang->printf(
                                "Setting unix rights for \"%s\" to \"%s\"\n",
                                $newfile{'sourcepath'},
                                $newfile{'UnixRights'});
						}

						if ( $set_executable_privileges )
						{
							# All paths to executables are saved in the hash %executable_files_in_extensions
							my $compare_path = $newfile{'sourcepath'};
							$compare_path =~ s/\\/\//g;  # contains only slashes for comparison reasons
							if ( exists($executable_files_in_extensions{$compare_path}) )
							{
								$newfile{'UnixRights'} = "775";
                                $installer::logger::Lang->printf(
                                    "Executable in Extension: Setting unix rights for \"%s\" to \"%s\"\n",
                                    $newfile{'sourcepath'},
                                    $newfile{'UnixRights'});
							}
						}

						if ( $select_files )
						{
							if ( ! installer::existence::exists_in_array($zipname,$selectlistfiles) )
							{
                                $installer::logger::Lang->printf("Removing from ARCHIVE file %s: %s\n",
                                    $onefilename,
                                    $zipname);
								next; # ignoring files, that are not included in $selectlistfiles
							}
							else
							{
                                $installer::logger::Lang->printf("Keeping from ARCHIVE file %s: \n",
                                    $onefilename,
                                    $zipname);
								push( @keptfiles, $zipname); # collecting all kept files
							}
						}

						if ( $select_patch_files )
						{
							# Is this file listed in the Patchfile list?
							# $zipname (filename including path in zip file has to be listed in patchfile list

							if ( ! installer::existence::exists_in_array($zipname,$patchlistfiles) )
							{
								$newfile{'Styles'} =~ s/\bPATCH\b//;	# removing the flag PATCH
								$newfile{'Styles'} =~ s/\,\s*\,/\,/;
								$newfile{'Styles'} =~ s/\(\s*\,/\(/;
								$newfile{'Styles'} =~ s/\,\s*\)/\)/;
							}
							else
							{
								push( @keptpatchflags, $zipname); # collecting all PATCH flags
							}
						}

						if ( $rename_to_language )
						{
							my $newzipname = put_language_into_name($zipname, $onelanguage);
							my $oldfilename = $unzipdir . $zipname;
							my $newfilename = $unzipdir . $newzipname;

							installer::systemactions::copy_one_file($oldfilename, $newfilename);

							$newfile{'Name'} = $newzipname;
							$newfile{'destination'} = $destination . $newzipname;
							$newfile{'sourcepath'} = $unzipdir . $newzipname;

                            $installer::logger::Lang->printf("RENAME_TO_LANGUAGE: Using %s instead of %s!\n",
                                $newzipname,
                                $zipname);
						}

						my $sourcefiletest = $unzipdir . $zipname;
						if ( ! -f $sourcefiletest )
						{
                            $installer::logger::Lang->printf("ATTENTION: Unzip failed for %s!\n", $sourcefiletest);
							$unziperror = 1;
						}

						# only adding the new line into the files array, if not in repeat modus

						if ( ! $repeat_unzip ) { push(@newallfilesarray, \%newfile); }
					}
				}

				# Comparing the content of @keptfiles and $selectlistfiles
				# Do all files from the list of selected files are stored in @keptfiles ?
				# @keptfiles contains only files included in $selectlistfiles. But are all
				# files from $selectlistfiles included in @keptfiles?

				if ( $select_files )
				{
                    $installer::logger::Lang->printf("SELECTLIST: Number of files in file selection list: %d\n",
                        scalar @$selectlistfiles);
                    $installer::logger::Lang->printf("SELECTLIST: Number of kept files: %d\n",
                        scalar @keptfiles);

					foreach my $name (@keptfiles)
					{
                        $installer::logger::Lang->printf("KEPT FILES: %s\n", $name);
					}

					foreach my $name (@$selectlistfiles)
					{
						if ( ! installer::existence::exists_in_array($name,\@keptfiles) )
						{
                            $installer::logger::Lang->printf(
                                "WARNING: %s not included in install set (does not exist in zip file)!\n",
                                $name);;
						}
					}
				}

				# Comparing the content of @keptpatchflags and $patchlistfiles
				# Do all files from the patch list have a PATCH flag ?
				# @keptpatchflags contains only files included in $patchlistfiles. But are all
				# files from $patchlistfiles included in @keptpatchflags?

				if ( $select_patch_files )
				{
                    $installer::logger::Lang->printf("PATCHLIST: Number of files in patch list: %d\n",
                        scalar @$patchlistfiles);
                    $installer::logger::Lang->printf("PATCHLIST: Number of kept PATCH flags: %d\n",
                        scalar @keptpatchflags);

					foreach my $flag (@keptpatchflags)
					{
                        $installer::logger::Lang->printf("KEPT PATCH FLAGS: %s\n",
                            $flag);
					}

					foreach my $name (@$patchlistfiles)
					{
						if ( ! installer::existence::exists_in_array($name,\@keptpatchflags) )
						{
                            $installer::logger::Lang->printf(
                                "WARNING: %s did not keep PATCH flag (does not exist in zip file)!\n",
                                $name);
                        }
					}
				}

				if ( $unziperror )
				{
					installer::logger::print_warning( "Repeating to unpack $sourcepath! \n" );
                    $installer::logger::Lang->printf("ATTENTION: Repeating to unpack %s!\n", $sourcepath);
					$repeat_unzip = 1;
					$maxcounter++;

					if ( $maxcounter == 5 )	# exiting the program
					{
						installer::exiter::exit_program("ERROR: Failed to unzip $sourcepath !", "resolving_archive_flag");
					}
				}
				else
				{
                    $installer::logger::Lang->printf("Info: %s unpacked without problems !\n", $sourcepath);
					$repeat_unzip = 0;
					$maxcounter = 0;
				}
			}
		}
		else		# nothing to do here, no zipped file (no ARCHIVE flag)
		{
			push(@newallfilesarray, $onefile);
		}
	}

    $installer::logger::Lang->print("\n");

	return \@newallfilesarray;
}


1;