solenv/bin/modules/installer/archivefiles.pm

   1 #*************************************************************************
   2 #
   3 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4 #
   5 # Copyright 2008 by Sun Microsystems, Inc.
   6 #
   7 # OpenOffice.org - a multi-platform office productivity suite
   8 #
   9 # $RCSfile: archivefiles.pm,v $
  10 #
  11 # $Revision: 1.18 $
  12 #
  13 # This file is part of OpenOffice.org.
  14 #
  15 # OpenOffice.org is free software: you can redistribute it and/or modify
  16 # it under the terms of the GNU Lesser General Public License version 3
  17 # only, as published by the Free Software Foundation.
  18 #
  19 # OpenOffice.org is distributed in the hope that it will be useful,
  20 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  21 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22 # GNU Lesser General Public License version 3 for more details
  23 # (a copy is included in the LICENSE file that accompanied this code).
  24 #
  25 # You should have received a copy of the GNU Lesser General Public License
  26 # version 3 along with OpenOffice.org.  If not, see
  27 # <http://www.openoffice.org/license.html>
  28 # for a copy of the LGPLv3 License.
  29 #
  30 #*************************************************************************
  31
  32 package installer::archivefiles;
  33
  34 use Archive::Zip qw( :ERROR_CODES :CONSTANTS );
  35 use installer::converter;
  36 use installer::existence;
  37 use installer::exiter;
  38 use installer::files;
  39 use installer::globals;
  40 use installer::logger;
  41 use installer::pathanalyzer;
  42 use installer::systemactions;
  43
  44 #################################################################
  45 # Changing the name for files with flag RENAME_TO_LANGUAGE
  46 #################################################################
  47
  48 sub put_language_into_name
  49 {
  50     my ( $oldname, $onelanguage ) = @_;
  51
  52     my $newname = "";
  53
  54     my $filename = "";
  55     my $extension = "";
  56
  57     if ( $oldname =~ /^\s*(.*)(\..*?)\s*$/ )    # files with extension
  58     {
  59         $filename = $1;
  60         $extension = $2;
  61     }
  62     else
  63     {
  64         $filename = $oldname;
  65         $extension = "";
  66     }
  67
  68     $newname = $1 . "_" . $onelanguage . $2;
  69
  70     return $newname;
  71 }
  72
  73 #################################################################
  74 # Converting patchfiles string into array
  75 #################################################################
  76
  77 sub get_patch_file_list
  78 {
  79     my ( $patchfilestring ) = @_;
  80
  81     $patchfilestring =~ s/^\s*\(?//;
  82     $patchfilestring =~ s/\)?\s*$//;
  83     $patchfilestring =~ s/^\s*\///;
  84     $patchfilestring =~ s/^\s*\\//;
  85
  86     my $patchfilesarray = installer::converter::convert_stringlist_into_array_without_linebreak_and_quotes(\$patchfilestring, ",");
  87
  88     return $patchfilesarray;
  89 }
  90
  91 #################################################################
  92 # Analyzing files with flag ARCHIVE
  93 #################################################################
  94
  95 sub resolving_archive_flag
  96 {
  97     my ($filesarrayref, $additionalpathsref, $languagestringref, $loggingdir) = @_;
  98
  99     if ( $installer::globals::debug ) { installer::logger::debuginfo("installer::archivefiles::resolving_archive_flag : $#{$filesarrayref} : $#{$additionalpathsref} : $$languagestringref : $loggingdir"); }
 100
 101     my @newallfilesarray = ();
 102
 103     my ($systemcall, $returnvalue, $infoline);
 104
 105     my $unziplistfile = $loggingdir . "unziplist_" . $installer::globals::build . "_" . $installer::globals::compiler . "_" . $$languagestringref . ".txt";
 106
 107     my $platformunzipdirbase = installer::systemactions::create_directories("zip", $languagestringref);
 108     push(@installer::globals::removedirs, $platformunzipdirbase);
 109
 110     installer::logger::include_header_into_logfile("Files with flag ARCHIVE:");
 111
 112     my $repeat_unzip = 0;
 113     my $maxcounter = 0;
 114
 115     for ( my $i = 0; $i <= $#{$filesarrayref}; $i++ )
 116     {
 117         if ( $repeat_unzip ) { $i--; }  # decreasing the counter
 118
 119         my $onefile = ${$filesarrayref}[$i];
 120         my $styles = "";
 121
 122         if ( $onefile->{'Styles'} ) { $styles = $onefile->{'Styles'}; }
 123
 124         if ( $styles =~ /\bARCHIVE\b/ )         # copying, unzipping and changing the file list
 125         {
 126             my $iscommonfile = 0;
 127             my $sourcepath = $onefile->{'sourcepath'};
 128
 129             if ( $sourcepath =~ /\Q$installer::globals::separator\E\bcommon$installer::globals::productextension\Q$installer::globals::separator\E/ )   # /common/ or /common.pro/
 130             {
 131                 $iscommonfile = 1;
 132             }
 133
 134             my $use_internal_rights = 0;
 135             if ( $styles =~ /\bUSE_INTERNAL_RIGHTS\b/ ) { $use_internal_rights = 1; }   # using the rights used inside the zip file
 136
 137             my $rename_to_language = 0;
 138             if ( $styles =~ /\bRENAME_TO_LANGUAGE\b/ ) { $rename_to_language = 1; }     # special handling for renamed files (scriptitems.pm)
 139
 140             # mechanism to select files from an archive files
 141             my $select_files = 0;
 142             my $selectlistfiles = "";
 143             my @keptfiles = ();
 144             if ( $onefile->{'Selectfiles'} )
 145             {
 146                 $select_files = 1;
 147                 $selectlistfiles = get_patch_file_list( $onefile->{'Selectfiles'} );
 148                 $infoline = "Selected file list defined at file: $onefile->{'Name'} :\n";
 149                 push( @installer::globals::logfileinfo, $infoline);
 150                 for ( my $k = 0; $k <= $#{$selectlistfiles}; $k++ )
 151                 {
 152                     $infoline = "\"${$selectlistfiles}[$k]\"\n";
 153                     push( @installer::globals::logfileinfo, $infoline);
 154                 }
 155             }
 156
 157             if ( $onefile->{'Selectfiles'} ) { $onefile->{'Selectfiles'} = ""; } # Selected files list no longer required
 158
 159             # mechanism to define patch files inside an archive files
 160             my $select_patch_files = 0;
 161             my $patchlistfiles = "";
 162             my @keptpatchflags = ();
 163             if (( $styles =~ /\bPATCH\b/ ) && ( $onefile->{'Patchfiles'} ) && ( $installer::globals::patch ))
 164             {
 165                 $select_patch_files = 1; # special handling if a Patchlist is defined
 166                 $patchlistfiles = get_patch_file_list( $onefile->{'Patchfiles'} );
 167                 $infoline = "Patch file list defined at file: $onefile->{'Name'} :\n";
 168                 push( @installer::globals::logfileinfo, $infoline);
 169                 for ( my $k = 0; $k <= $#{$patchlistfiles}; $k++ )
 170                 {
 171                     $infoline = "\"${$patchlistfiles}[$k]\"\n";
 172                     push( @installer::globals::logfileinfo, $infoline);
 173                 }
 174             }
 175
 176             if ( $onefile->{'Patchfiles'} ) { $onefile->{'Patchfiles'} = ""; } # Patch file list no longer required
 177
 178             # creating directories
 179
 180             my $onelanguage = $onefile->{'specificlanguage'};
 181
 182             # files without language into directory "00"
 183
 184             if ($onelanguage eq "") { $onelanguage = "00"; }
 185
 186             my $unzipdir;
 187
 188             # if ($iscommonfile) { $unzipdir = $commonunzipdirbase . $installer::globals::separator . $onelanguage . $installer::globals::separator; }
 189             # else { $unzipdir = $platformunzipdirbase . $installer::globals::separator . $onelanguage . $installer::globals::separator; }
 190
 191             $unzipdir = $platformunzipdirbase . $installer::globals::separator . $onelanguage . $installer::globals::separator;
 192
 193             installer::systemactions::create_directory($unzipdir);      # creating language specific subdirectories
 194
 195             my $onefilename = $onefile->{'Name'};
 196             $onefilename =~ s/\./\_/g;          # creating new directory name
 197             $onefilename =~ s/\//\_/g;          # only because of /letter/fontunxpsprint.zip, the only zip file with path
 198             $unzipdir = $unzipdir . $onefilename . $installer::globals::separator;
 199
 200             if ( $installer::globals::dounzip ) { installer::systemactions::create_directory($unzipdir); }      # creating subdirectories with the names of the zipfiles
 201
 202             my $zip = Archive::Zip->new();
 203             if ( $zip->read($sourcepath) != AZ_OK )
 204             {
 205                 $infoline = "ERROR: Could not unzip $sourcepath\n";
 206                 push( @installer::globals::logfileinfo, $infoline);
 207             }
 208
 209             my $counter = 0;
 210             my $contains_dll = 0;
 211             foreach my $member ( $zip->memberNames() )
 212             {
 213                 $counter++;
 214                 if ( $member =~ /.dll\s*$/ ) { $contains_dll = 1; }
 215             }
 216
 217             if (! ( $counter > 0 ))     # the zipfile is empty
 218             {
 219                 $infoline = "ERROR: Could not unzip $sourcepath\n";
 220                 push( @installer::globals::logfileinfo, $infoline);
 221
 222             }
 223             else
 224             {
 225                 if ( $installer::globals::dounzip )                     # really unpacking the files
 226                 {
 227                     if ( $zip->extractTree("", $unzipdir) != AZ_OK ) { installer::exiter::exit_program("ERROR: $infoline", "resolving_archive_flag"); }
 228
 229                     if (( $^O =~ /cygwin/i ) && ( $contains_dll ))
 230                     {
 231                         # Make dll's executable
 232                         $systemcall = "cd $unzipdir; find . -name \\*.dll -exec chmod 775 \{\} \\\;";
 233                         $returnvalue = system($systemcall);
 234                         $infoline = "Systemcall: $systemcall\n";
 235                         push( @installer::globals::logfileinfo, $infoline);
 236
 237                         if ($returnvalue)
 238                         {
 239                             $infoline = "ERROR: Could not execute \"$systemcall\"!\n";
 240                             push( @installer::globals::logfileinfo, $infoline);
 241                         }
 242                     }
 243
 244                     if ( ! $installer::globals::iswindowsbuild )
 245                     {
 246                         # Setting unix rights to "775" for all created directories inside the package
 247
 248                         $systemcall = "cd $unzipdir; find . -type d -exec chmod 775 \{\} \\\;";
 249                         $returnvalue = system($systemcall);
 250                         $infoline = "Systemcall: $systemcall\n";
 251                         push( @installer::globals::logfileinfo, $infoline);
 252
 253                         if ($returnvalue)
 254                         {
 255                             $infoline = "ERROR: Could not execute \"$systemcall\"!\n";
 256                             push( @installer::globals::logfileinfo, $infoline);
 257                         }
 258                     }
 259                 }
 260
 261                 my $zipfileref = \@zipfile;
 262                 my $unziperror = 0;
 263
 264                 foreach my $zipname ( $zip->memberNames() )
 265                 {
 266                     # Format from Archive:::Zip :
 267                     # dir1/
 268                     # dir1/so7drawing.desktop
 269
 270                     # some directories and files (from the help) start with "./simpress.idx"
 271
 272                     $zipname =~ s/^\s*\.\///;
 273
 274                     if ($installer::globals::iswin and $^O =~ /MSWin/i) { $zipname =~ s/\//\\/g; }
 275
 276                     if ( $zipname =~ /\Q$installer::globals::separator\E\s*$/ ) # slash or backslash at the end characterizes a directory
 277                     {
 278                         $zipname = $zipname . "\n";
 279                         push(@{$additionalpathsref}, $zipname);
 280
 281                         # Also needed here:
 282                         # Name
 283                         # Language
 284                         # ismultilingual
 285                         # Basedirectory
 286
 287                         # This is not needed, because the list of all directories for the
 288                         # epm list file is generated from the destination directories of the
 289                         # files included in the product!
 290                     }
 291                     else
 292                     {
 293                         my %newfile = ();
 294                         %newfile = %{$onefile};
 295                         $newfile{'Name'} = $zipname;
 296                         my $destination = $onefile->{'destination'};
 297                         installer::pathanalyzer::get_path_from_fullqualifiedname(\$destination);
 298                         $newfile{'destination'} = $destination . $zipname;
 299                         $newfile{'sourcepath'} = $unzipdir . $zipname;
 300                         $newfile{'zipfilename'} = $onefile->{'Name'};
 301                         $newfile{'zipfilesource'} = $onefile->{'sourcepath'};
 302                         $newfile{'zipfiledestination'} = $onefile->{'destination'};
 303
 304                         if (( $use_internal_rights ) && ( ! $installer::globals::iswin ))
 305                         {
 306                             my $value = sprintf("%o", (stat($newfile{'sourcepath'}))[2]);
 307                             $newfile{'UnixRights'} = substr($value, 3);
 308                             $infoline = "Setting unix rights for \"$newfile{'sourcepath'}\" to \"$newfile{'UnixRights'}\"\n";
 309                             push( @installer::globals::logfileinfo, $infoline);
 310                         }
 311
 312                         if ( $select_files )
 313                         {
 314                             if ( ! installer::existence::exists_in_array($zipname,$selectlistfiles) )
 315                             {
 316                                 $infoline = "Removing from ARCHIVE file $onefilename: $zipname\n";
 317                                 push( @installer::globals::logfileinfo, $infoline);
 318                                 next; # ignoring files, that are not included in $selectlistfiles
 319                             }
 320                             else
 321                             {
 322                                 $infoline = "Keeping from ARCHIVE file $onefilename: $zipname\n";
 323                                 push( @installer::globals::logfileinfo, $infoline);
 324                                 push( @keptfiles, $zipname); # collecting all kept files
 325                             }
 326                         }
 327
 328                         if ( $select_patch_files )
 329                         {
 330                             # Is this file listed in the Patchfile list?
 331                             # $zipname (filename including path in zip file has to be listed in patchfile list
 332
 333                             if ( ! installer::existence::exists_in_array($zipname,$patchlistfiles) )
 334                             {
 335                                 $newfile{'Styles'} =~ s/\bPATCH\b//;    # removing the flag PATCH
 336                                 $newfile{'Styles'} =~ s/\,\s*\,/\,/;
 337                                 $newfile{'Styles'} =~ s/\(\s*\,/\(/;
 338                                 $newfile{'Styles'} =~ s/\,\s*\)/\)/;
 339                                 # $infoline = "Removing PATCH flag from: $zipname\n";
 340                                 # push( @installer::globals::logfileinfo, $infoline);
 341                             }
 342                             else
 343                             {
 344                                 # $infoline = "Keeping PATCH flag at: $zipname\n";
 345                                 # push( @installer::globals::logfileinfo, $infoline);
 346                                 push( @keptpatchflags, $zipname); # collecting all PATCH flags
 347                             }
 348                         }
 349
 350                         if ( $rename_to_language )
 351                         {
 352                             my $newzipname = put_language_into_name($zipname, $onelanguage);
 353                             my $oldfilename = $unzipdir . $zipname;
 354                             my $newfilename = $unzipdir . $newzipname;
 355
 356                             installer::systemactions::copy_one_file($oldfilename, $newfilename);
 357
 358                             $newfile{'Name'} = $newzipname;
 359                             $newfile{'destination'} = $destination . $newzipname;
 360                             $newfile{'sourcepath'} = $unzipdir . $newzipname;
 361
 362                             $infoline = "RENAME_TO_LANGUAGE: Using $newzipname instead of $zipname!\n";
 363                             push( @installer::globals::logfileinfo, $infoline);
 364                         }
 365
 366                         my $sourcefiletest = $unzipdir . $zipname;
 367                         if ( ! -f $sourcefiletest )
 368                         {
 369                             $infoline = "ATTENTION: Unzip failed for $sourcefiletest!\n";
 370                             push( @installer::globals::logfileinfo, $infoline);
 371                             $unziperror = 1;
 372                         }
 373
 374                         # only adding the new line into the files array, if not in repeat modus
 375
 376                         if ( ! $repeat_unzip ) { push(@newallfilesarray, \%newfile); }
 377                     }
 378                 }
 379
 380                 # Comparing the content of @keptfiles and $selectlistfiles
 381                 # Do all files from the list of selected files are stored in @keptfiles ?
 382                 # @keptfiles contains only files included in $selectlistfiles. But are all
 383                 # files from $selectlistfiles included in @keptfiles?
 384
 385                 if ( $select_files )
 386                 {
 387                     my $number = $#{$selectlistfiles} + 1;
 388                     $infoline = "SELECTLIST: Number of files in file selection list: $number\n";
 389                     push( @installer::globals::logfileinfo, $infoline);
 390                     $number = $#keptfiles + 1;
 391                     $infoline = "SELECTLIST: Number of kept files: $number\n";
 392                     push( @installer::globals::logfileinfo, $infoline);
 393
 394                     for ( my $k = 0; $k <= $#keptfiles; $k++ )
 395                     {
 396                         $infoline = "KEPT FILES: $keptfiles[$k]\n";
 397                         push( @installer::globals::logfileinfo, $infoline);
 398                     }
 399
 400                     my @warningfiles = ();
 401
 402                     for ( my $k = 0; $k <= $#{$selectlistfiles}; $k++ )
 403                     {
 404                         if ( ! installer::existence::exists_in_array(${$selectlistfiles}[$k],\@keptfiles) )
 405                         {
 406                             push(@warningfiles, ${$selectlistfiles}[$k]);
 407                         }
 408                     }
 409
 410                     for ( my $k = 0; $k <= $#warningfiles; $k++ )
 411                     {
 412                         $infoline = "WARNING: $warningfiles[$k] not included in install set (does not exist in zip file)!\n";
 413                         push( @installer::globals::logfileinfo, $infoline);
 414                     }
 415
 416                 }
 417
 418                 # Comparing the content of @keptpatchflags and $patchlistfiles
 419                 # Do all files from the patch list have a PATCH flag ?
 420                 # @keptpatchflags contains only files included in $patchlistfiles. But are all
 421                 # files from $patchlistfiles included in @keptpatchflags?
 422
 423                 if ( $select_patch_files )
 424                 {
 425                     my $number = $#{$patchlistfiles} + 1;
 426                     $infoline = "PATCHLIST: Number of files in patch list: $number\n";
 427                     push( @installer::globals::logfileinfo, $infoline);
 428                     $number = $#keptpatchflags + 1;
 429                     $infoline = "PATCHLIST: Number of kept PATCH flags: $number\n";
 430                     push( @installer::globals::logfileinfo, $infoline);
 431
 432                     for ( my $k = 0; $k <= $#keptpatchflags; $k++ )
 433                     {
 434                         $infoline = "KEPT PATCH FLAGS: $keptpatchflags[$k]\n";
 435                         push( @installer::globals::logfileinfo, $infoline);
 436                     }
 437
 438                     my @warningfiles = ();
 439
 440                     for ( my $k = 0; $k <= $#{$patchlistfiles}; $k++ )
 441                     {
 442                         if ( ! installer::existence::exists_in_array(${$patchlistfiles}[$k],\@keptpatchflags) )
 443                         {
 444                             push(@warningfiles, ${$patchlistfiles}[$k]);
 445                         }
 446                     }
 447
 448                     for ( my $k = 0; $k <= $#warningfiles; $k++ )
 449                     {
 450                         $infoline = "WARNING: $warningfiles[$k] did not keep PATCH flag (does not exist in zip file)!\n";
 451                         push( @installer::globals::logfileinfo, $infoline);
 452                     }
 453                 }
 454
 455                 if ( $unziperror )
 456                 {
 457                     installer::logger::print_warning( "Repeating to unpack $sourcepath! \n" );
 458                     $infoline = "ATTENTION: Repeating to unpack $sourcepath !\n";
 459                     push( @installer::globals::logfileinfo, $infoline);
 460                     $repeat_unzip = 1;
 461                     $maxcounter++;
 462
 463                     if ( $maxcounter == 5 )     # exiting the program
 464                     {
 465                         installer::exiter::exit_program("ERROR: Failed to unzip $sourcepath !", "resolving_archive_flag");
 466                     }
 467                 }
 468                 else
 469                 {
 470                     $infoline = "Info: $sourcepath unpacked without problems !\n";
 471                     push( @installer::globals::logfileinfo, $infoline);
 472                     $repeat_unzip = 0;
 473                     $maxcounter = 0;
 474                 }
 475             }
 476         }
 477         else            # nothing to do here, no zipped file (no ARCHIVE flag)
 478         {
 479             push(@newallfilesarray, $onefile);
 480         }
 481     }
 482
 483     $infoline = "\n";
 484     push( @installer::globals::logfileinfo, $infoline);
 485
 486     return \@newallfilesarray;
 487 }
 488
 489
 490 1;