solenv/bin/modules/installer/epmfile.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: epmfile.pm,v $
  10 #
  11 # $Revision: 1.87 $
  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::epmfile;
  33
  34 use Cwd;
  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::packagelist;
  42 use installer::pathanalyzer;
  43 use installer::remover;
  44 use installer::scriptitems;
  45 use installer::systemactions;
  46 use installer::worker;
  47 use POSIX;
  48
  49 ############################################################################
  50 # Reading the package map to find Solaris package names for
  51 # the corresponding abbreviations
  52 ############################################################################
  53
  54 sub read_packagemap
  55 {
  56     my ($allvariables, $includepatharrayref, $languagesarrayref) = @_;
  57
  58     my $packagemapname = "";
  59     if ( $allvariables->{'PACKAGEMAP'} ) { $packagemapname = $allvariables->{'PACKAGEMAP'}; }
  60     if ( $packagemapname eq "" ) { installer::exiter::exit_program("ERROR: Property PACKAGEMAP must be defined!", "read_packagemap"); }
  61
  62     my $infoline = "\n\nCollected abbreviations and package names:\n";
  63     push(@installer::globals::logfileinfo, $infoline);
  64
  65     # Can be a comma separated list. All files have to be found in include pathes
  66     my $allpackagemapnames = installer::converter::convert_stringlist_into_hash(\$packagemapname, ",");
  67     foreach my $onepackagemapname ( keys %{$allpackagemapnames} )
  68     {
  69         my $packagemapref = installer::scriptitems::get_sourcepath_from_filename_and_includepath(\$onepackagemapname, $includepatharrayref, 0);
  70
  71         if ( $$packagemapref eq "" ) { installer::exiter::exit_program("ERROR: Could not find package map file \"$onepackagemapname\" (propery PACKAGEMAP)!", "read_packagemap"); }
  72
  73         my $packagemapcontent = installer::files::read_file($$packagemapref);
  74
  75         for ( my $i = 0; $i <= $#{$packagemapcontent}; $i++ )
  76         {
  77             my $line = ${$packagemapcontent}[$i];
  78
  79             if ( $line =~ /^\s*\#/ ) { next; }  # comment line
  80             if ( $line =~ /^\s*$/ ) { next; }  # empty line
  81
  82             if ( $line =~ /^\s*(.*?)\t(.*?)\s*$/ )
  83             {
  84                 my $abbreviation = $1;
  85                 my $packagename = $2;
  86                 installer::packagelist::resolve_packagevariables(\$abbreviation, $allvariables, 0);
  87                 installer::packagelist::resolve_packagevariables(\$packagename, $allvariables, 0);
  88
  89                 # Special handling for language strings %LANGUAGESTRING
  90
  91                 if (( $abbreviation =~ /\%LANGUAGESTRING/ ) || ( $packagename =~ /\%LANGUAGESTRING/ ))
  92                 {
  93                     foreach my $onelang ( @{$languagesarrayref} )
  94                     {
  95                         my $local_abbreviation = $abbreviation;
  96                         my $local_packagename = $packagename;
  97                         $local_abbreviation =~ s/\%LANGUAGESTRING/$onelang/g;
  98                         $local_packagename =~ s/\%LANGUAGESTRING/$onelang/g;
  99
 100                         # Logging all abbreviations and packagenames
 101                         $infoline = "$onelang : $local_abbreviation : $local_packagename\n";
 102                         push(@installer::globals::logfileinfo, $infoline);
 103
 104                         if ( exists($installer::globals::dependfilenames{$local_abbreviation}) )
 105                         {
 106                             installer::exiter::exit_program("ERROR: Packagename for  Solaris package $local_abbreviation already defined ($installer::globals::dependfilenames{$local_abbreviation})!", "read_packagemap");
 107                         }
 108                         else
 109                         {
 110                             $installer::globals::dependfilenames{$local_abbreviation} = $local_packagename;
 111                         }
 112                     }
 113                 }
 114                 else
 115                 {
 116                     # Logging all abbreviations and packagenames
 117                     $infoline = "$abbreviation : $packagename\n";
 118                     push(@installer::globals::logfileinfo, $infoline);
 119
 120                     if ( exists($installer::globals::dependfilenames{$abbreviation}) )
 121                     {
 122                         installer::exiter::exit_program("ERROR: Packagename for  Solaris package $abbreviation already defined ($installer::globals::dependfilenames{$abbreviation})!", "read_packagemap");
 123                     }
 124                     else
 125                     {
 126                         $installer::globals::dependfilenames{$abbreviation} = $packagename;
 127                     }
 128                 }
 129             }
 130             else
 131             {
 132                 my $errorline = $i + 1;
 133                 installer::exiter::exit_program("ERROR: Wrong syntax in file \"$onepackagemapname\" (line $errorline)!", "read_packagemap");
 134             }
 135         }
 136     }
 137
 138     $infoline = "\n\n";
 139     push(@installer::globals::logfileinfo, $infoline);
 140
 141 }
 142
 143 ############################################################################
 144 # The header file contains the strings for the epm header in all languages
 145 ############################################################################
 146
 147 sub get_string_from_headerfile
 148 {
 149     my ($searchstring, $language, $fileref) = @_;
 150
 151     my $returnstring  = "";
 152     my $onestring  = "";
 153     my $englishstring  = "";
 154     my $foundblock = 0;
 155     my $foundstring = 0;
 156     my $foundenglishstring = 0;
 157     my $englishidentifier = "01";
 158
 159     $searchstring = "[" . $searchstring . "]";
 160
 161     for ( my $i = 0; $i <= $#{$fileref}; $i++ )
 162     {
 163         my $line = ${$fileref}[$i];
 164
 165         if ( $line =~ /^\s*\Q$searchstring\E\s*$/ )
 166         {
 167             $foundblock = 1;
 168             my $counter = $i + 1;
 169
 170             $line = ${$fileref}[$counter];
 171
 172             # Beginning of the next block oder Dateiende
 173
 174             while ((!($line =~ /^\s*\[\s*\w+\s*\]\s*$/ )) && ( $counter <= $#{$fileref} ))
 175             {
 176                 if ( $line =~ /^\s*\Q$language\E\s+\=\s*\"(.*)\"\s*$/ )
 177                 {
 178                     $onestring = $1;
 179                     $foundstring = 1;
 180                     last;
 181                 }
 182
 183                 if ( $line =~ /^\s*\Q$englishidentifier\E\s+\=\s*\"(.*)\"\s*$/ )
 184                 {
 185                     $englishstring = $1;
 186                     $foundenglishstring = 1;
 187                 }
 188
 189                 $counter++;
 190                 $line = ${$fileref}[$counter];
 191             }
 192         }
 193     }
 194
 195     if ( $foundstring )
 196     {
 197         $returnstring = $onestring;
 198     }
 199     else
 200     {
 201         if ( $foundenglishstring )
 202         {
 203             $returnstring = $englishstring;
 204         }
 205         else
 206         {
 207             installer::exiter::exit_program("ERROR: No string found for $searchstring in epm header file (-h)", "get_string_from_headerfile");
 208         }
 209     }
 210
 211     return \$returnstring;
 212 }
 213
 214 ##########################################################
 215 # Filling the epm file with directories, files and links
 216 ##########################################################
 217
 218 sub put_directories_into_epmfile
 219 {
 220     my ($directoriesarrayref, $epmfileref, $allvariables, $packagerootpath) = @_;
 221     my $group = "bin";
 222
 223     if ( $installer::globals::islinuxbuild )
 224     {
 225         $group = "root";
 226     }
 227
 228     for ( my $i = 0; $i <= $#{$directoriesarrayref}; $i++ )
 229     {
 230         my $onedir = ${$directoriesarrayref}[$i];
 231         my $dir = "";
 232
 233         if ( $onedir->{'Dir'} ) { $dir = $onedir->{'Dir'}; }
 234
 235         # if (!($dir =~ /\bPREDEFINED_/ ))
 236         if ((!($dir =~ /\bPREDEFINED_/ )) || ( $dir =~ /\bPREDEFINED_PROGDIR\b/ ))
 237         {
 238             my $hostname = $onedir->{'HostName'};
 239
 240             # not including simple directory "/opt"
 241             # if (( $allvariables->{'SETSTATICPATH'} ) && ( $hostname eq $packagerootpath )) { next; }
 242
 243             my $line = "d 755 root $group $hostname -\n";
 244
 245             push(@{$epmfileref}, $line)
 246         }
 247     }
 248 }
 249
 250 sub put_files_into_epmfile
 251 {
 252     my ($filesinproductarrayref, $epmfileref) = @_;
 253
 254     for ( my $i = 0; $i <= $#{$filesinproductarrayref}; $i++ )
 255     {
 256         my $onefile = ${$filesinproductarrayref}[$i];
 257
 258         my $unixrights = $onefile->{'UnixRights'};
 259         my $destination = $onefile->{'destination'};
 260         my $sourcepath = $onefile->{'sourcepath'};
 261
 262         my $filetype = "f";
 263         my $styles = "";
 264         if ( $onefile->{'Styles'} ) { $styles = $onefile->{'Styles'}; }
 265         if ( $styles =~ /\bCONFIGFILE\b/ ) { $filetype = "c"; }
 266
 267         my $group = "bin";
 268         if ( $installer::globals::islinuxbuild ) { $group = "root"; }
 269         if (( $installer::globals::issolarisbuild ) && ( $onefile->{'SolarisGroup'} )) { $group = $onefile->{'SolarisGroup'}; }
 270
 271         my $line = "$filetype $unixrights root $group $destination $sourcepath\n";
 272
 273         push(@{$epmfileref}, $line);
 274     }
 275 }
 276
 277 sub put_links_into_epmfile
 278 {
 279     my ($linksinproductarrayref, $epmfileref) = @_;
 280     my $group = "bin";
 281
 282     if ( $installer::globals::islinuxbuild )
 283     {
 284         $group = "root";
 285     }
 286
 287
 288     for ( my $i = 0; $i <= $#{$linksinproductarrayref}; $i++ )
 289     {
 290         my $onelink = ${$linksinproductarrayref}[$i];
 291         my $destination = $onelink->{'destination'};
 292         my $destinationfile = $onelink->{'destinationfile'};
 293
 294         my $line = "l 000 root $group $destination $destinationfile\n";
 295
 296         push(@{$epmfileref}, $line)
 297     }
 298 }
 299
 300 sub put_unixlinks_into_epmfile
 301 {
 302     my ($unixlinksinproductarrayref, $epmfileref) = @_;
 303     my $group = "bin";
 304
 305     if ( $installer::globals::islinuxbuild ) { $group = "root"; }
 306
 307     for ( my $i = 0; $i <= $#{$unixlinksinproductarrayref}; $i++ )
 308     {
 309         my $onelink = ${$unixlinksinproductarrayref}[$i];
 310         my $destination = $onelink->{'destination'};
 311         my $target = $onelink->{'Target'};
 312
 313         my $line = "l 000 root $group $destination $target\n";
 314
 315         push(@{$epmfileref}, $line)
 316     }
 317 }
 318
 319 ###############################################
 320 # Creating epm header file
 321 ###############################################
 322
 323 sub create_epm_header
 324 {
 325     my ($variableshashref, $filesinproduct, $languagesref, $onepackage) = @_;
 326
 327     my @epmheader = ();
 328
 329     my ($licensefilename, $readmefilename);
 330
 331     my $foundlicensefile = 0;
 332     my $foundreadmefile = 0;
 333
 334     my $line = "";
 335     my $infoline = "";
 336
 337     # %product OpenOffice.org Software
 338     # %version 2.0
 339     # %description A really great software
 340     # %copyright 1999-2003 by OOo
 341     # %vendor OpenOffice.org
 342     # %license /test/replace/01/LICENSE01
 343     # %readme /test/replace/01/README01
 344     # %requires foo
 345     # %provides bar
 346
 347     # The first language in the languages array determines the language of license and readme file
 348
 349     my $searchlanguage = ${$languagesref}[0];
 350
 351     # using the description for the %product line in the epm list file
 352
 353     my $productnamestring = $onepackage->{'description'};
 354     installer::packagelist::resolve_packagevariables(\$productnamestring, $variableshashref, 0);
 355     if ( $variableshashref->{'PRODUCTEXTENSION'} ) { $productnamestring = $productnamestring . " " . $variableshashref->{'PRODUCTEXTENSION'}; }
 356
 357     $line = "%product" . " " . $productnamestring . "\n";
 358     push(@epmheader, $line);
 359
 360     # Determining the release version
 361     # This release version has to be listed in the line %version : %version versionnumber releasenumber
 362
 363     # if ( $variableshashref->{'PACKAGEVERSION'} ) { $installer::globals::packageversion = $variableshashref->{'PACKAGEVERSION'}; }
 364     if ( ! $onepackage->{'packageversion'} ) { installer::exiter::exit_program("ERROR: No packageversion defined for package: $onepackage->{'module'}!", "create_epm_header"); }
 365     $installer::globals::packageversion = $onepackage->{'packageversion'};
 366     installer::packagelist::resolve_packagevariables(\$installer::globals::packageversion, $variableshashref, 0);
 367     if ( $variableshashref->{'PACKAGEREVISION'} ) { $installer::globals::packagerevision = $variableshashref->{'PACKAGEREVISION'}; }
 368
 369     $line = "%version" . " " . $installer::globals::packageversion . "\n";
 370     push(@epmheader, $line);
 371
 372     $line = "%release" . " " . $installer::globals::packagerevision . "\n";
 373     if ( $installer::globals::islinuxrpmbuild ) { $line = "%release" . " " . $installer::globals::buildid . "\n"; }
 374     push(@epmheader, $line);
 375
 376     # Description, Copyright and Vendor are multilingual and are defined in
 377     # the string file for the header file ($headerfileref)
 378
 379     my $descriptionstring = $onepackage->{'description'};
 380     installer::packagelist::resolve_packagevariables(\$descriptionstring, $variableshashref, 0);
 381     $line = "%description" . " " . $descriptionstring . "\n";
 382     push(@epmheader, $line);
 383
 384     my $copyrightstring = $onepackage->{'copyright'};
 385     installer::packagelist::resolve_packagevariables(\$copyrightstring, $variableshashref, 0);
 386     $line = "%copyright" . " " . $copyrightstring . "\n";
 387     push(@epmheader, $line);
 388
 389     my $vendorstring = $onepackage->{'vendor'};
 390     installer::packagelist::resolve_packagevariables(\$vendorstring, $variableshashref, 0);
 391     $line = "%vendor" . " " . $vendorstring . "\n";
 392     push(@epmheader, $line);
 393
 394     # License and Readme file can be included automatically from the file list
 395
 396     if ( $installer::globals::iswindowsbuild )
 397     {
 398         $licensefilename = "license.txt";
 399         $readmefilename = "readme.txt";
 400     }
 401     else
 402     {
 403         $licensefilename = "LICENSE";
 404         $readmefilename = "README";
 405     }
 406
 407     if (( $installer::globals::languagepack )   # in language packs the files LICENSE and README are removed, because they are not language specific
 408         || ( $variableshashref->{'NO_README_IN_ROOTDIR'} ))
 409     {
 410         if ( $installer::globals::iswindowsbuild )
 411         {
 412             $licensefilename = "license_$searchlanguage.txt";
 413             $readmefilename = "readme_$searchlanguage.txt";
 414         }
 415         else
 416         {
 417             $licensefilename = "LICENSE_$searchlanguage";
 418             $readmefilename = "README_$searchlanguage";
 419         }
 420     }
 421
 422     my $license_in_package_defined = 0;
 423
 424     if ( $installer::globals::issolarisbuild )
 425     {
 426         if ( $onepackage->{'solariscopyright'} )
 427         {
 428             $licensefilename = $onepackage->{'solariscopyright'};
 429             $license_in_package_defined = 1;
 430         }
 431     }
 432
 433     # searching for and readme file
 434
 435     for ( my $i = 0; $i <= $#{$filesinproduct}; $i++ )
 436     {
 437         my $onefile = ${$filesinproduct}[$i];
 438         my $filename = $onefile->{'Name'};
 439         if ( $filename eq $readmefilename )
 440         {
 441             $foundreadmefile = 1;
 442             $line = "%readme" . " " . $onefile->{'sourcepath'} . "\n";
 443             push(@epmheader, $line);
 444             last;
 445         }
 446     }
 447
 448     # searching for and license file
 449
 450     if ( $license_in_package_defined )
 451     {
 452         my $fileref = installer::scriptitems::get_sourcepath_from_filename_and_includepath(\$licensefilename, "" , 0);
 453
 454         if ( $$fileref eq "" ) { installer::exiter::exit_program("ERROR: Could not find license file $licensefilename!", "create_epm_header"); }
 455
 456         # Special handling to add the content of the file "license_en-US" to the solaris copyrightfile. But not for all products
 457
 458         if (( $installer::globals::issolarispkgbuild ) && ( ! $variableshashref->{'NO_LICENSE_INTO_COPYRIGHT'} ))
 459         {
 460             if ( ! $installer::globals::englishlicenseset ) { installer::worker::set_english_license() }
 461
 462             # The location for the new file
 463             my $languagestring = "";
 464             for ( my $i = 0; $i <= $#{$languagesref}; $i++ ) { $languagestring = $languagestring . "_" . ${$languagesref}[$i]; }
 465             $languagestring =~ s/^\s*_//;
 466
 467             my $copyrightdir = installer::systemactions::create_directories("copyright", \$languagestring);
 468
 469             my $copyrightfile = installer::files::read_file($$fileref);
 470
 471             # Adding license content to copyright file
 472             push(@{$copyrightfile}, "\n");
 473             for ( my $i = 0; $i <= $#{$installer::globals::englishlicense}; $i++ ) { push(@{$copyrightfile}, ${$installer::globals::englishlicense}[$i]); }
 474
 475             # New destination for $$fileref
 476             $$fileref = $copyrightdir . $installer::globals::separator . "solariscopyrightfile_" . $onepackage->{'module'};
 477             if ( -f $$fileref ) { unlink $$fileref; }
 478             installer::files::save_file($$fileref, $copyrightfile);
 479         }
 480
 481         $infoline = "Using license file: \"$$fileref\"!\n";
 482         push(@installer::globals::logfileinfo, $infoline);
 483
 484         $foundlicensefile = 1;
 485         $line = "%license" . " " . $$fileref . "\n";
 486         push(@epmheader, $line);
 487     }
 488     else
 489     {
 490         for ( my $i = 0; $i <= $#{$filesinproduct}; $i++ )
 491         {
 492             my $onefile = ${$filesinproduct}[$i];
 493             my $filename = $onefile->{'Name'};
 494
 495             if ( $filename eq $licensefilename )
 496             {
 497                 $foundlicensefile = 1;
 498                 $line = "%license" . " " . $onefile->{'sourcepath'} . "\n";
 499                 push(@epmheader, $line);
 500                 last;
 501             }
 502         }
 503     }
 504
 505     if (!($foundlicensefile))
 506     {
 507         installer::exiter::exit_program("ERROR: Could not find license file $licensefilename", "create_epm_header");
 508     }
 509
 510     if (!($foundreadmefile))
 511     {
 512         installer::exiter::exit_program("ERROR: Could not find readme file $readmefilename", "create_epm_header");
 513     }
 514
 515     # including %replaces
 516
 517     my $replaces = "";
 518
 519     if (( $installer::globals::issolarispkgbuild ) && ( ! $installer::globals::patch ))
 520     {
 521         $replaces = "solarisreplaces";   # the name in the packagelist
 522     }
 523     elsif (( $installer::globals::islinuxbuild ) && ( ! $installer::globals::patch ))
 524     {
 525         $replaces = "linuxreplaces";    # the name in the packagelist
 526     }
 527
 528     if (( $replaces ) && ( ! $installer::globals::patch ))
 529     {
 530         if ( $onepackage->{$replaces} )
 531         {
 532             my $replacesstring = $onepackage->{$replaces};
 533
 534             my $allreplaces = installer::converter::convert_stringlist_into_array(\$replacesstring, ",");
 535
 536             for ( my $i = 0; $i <= $#{$allreplaces}; $i++ )
 537             {
 538                 my $onereplaces = ${$allreplaces}[$i];
 539                 $onereplaces =~ s/\s*$//;
 540                 installer::packagelist::resolve_packagevariables(\$onereplaces, $variableshashref, 1);
 541                 if ( $installer::globals::linuxlinkrpmprocess ) { $onereplaces = $onereplaces . "u"; }
 542                 $line = "%replaces" . " " . $onereplaces . "\n";
 543                 push(@epmheader, $line);
 544
 545                 # Force the openofficeorg packages to get removed,
 546                 # see http://www.debian.org/doc/debian-policy/ch-relationships.html
 547                 # 7.5.2 Replacing whole packages, forcing their removal
 548
 549                 if ( $installer::globals::debian )
 550                 {
 551                     $line = "%incompat" . " " . $onereplaces . "\n";
 552                     push(@epmheader, $line);
 553                 }
 554             }
 555
 556             if ( $installer::globals::debian && $variableshashref->{'UNIXPRODUCTNAME'} eq 'openoffice.org' )
 557             {
 558                 $line = "%provides" . " openoffice.org-unbundled\n";
 559                 push(@epmheader, $line);
 560                 $line = "%incompat" . " openoffice.org-bundled\n";
 561                 push(@epmheader, $line);
 562             }
 563         }
 564     }
 565
 566     # including the directives for %requires and %provides
 567
 568     my $provides = "";
 569     my $requires = "";
 570
 571     if ( $installer::globals::issolarispkgbuild )
 572     {
 573         $provides = "solarisprovides";   # the name in the packagelist
 574         $requires = "solarisrequires";   # the name in the packagelist
 575     }
 576     elsif ( $installer::globals::isfreebsdpkgbuild )
 577     {
 578         $provides = "freebsdprovides";   # the name in the packagelist
 579         $requires = "freebsdrequires";   # the name in the packagelist
 580     }
 581     elsif (( $installer::globals::islinuxrpmbuild ) &&
 582             ( $installer::globals::patch ) &&
 583             ( exists($onepackage->{'linuxpatchrequires'}) ))
 584     {
 585         $provides = "provides";  # the name in the packagelist
 586         $requires = "linuxpatchrequires";        # the name in the packagelist
 587     }
 588     else
 589     {
 590         $provides = "provides";                 # the name in the packagelist
 591         $requires = "requires";                 # the name in the packagelist
 592     }
 593
 594     # if ( $installer::globals::patch )
 595     # {
 596     #   $onepackage->{$provides} = "";
 597         my $isdict = 0;
 598         if ( $onepackage->{'packagename'} =~ /-dict-/ ) { $isdict = 1;  }
 599
 600     #   $onepackage->{$requires} = "";
 601     # }
 602
 603     if ( $onepackage->{$provides} )
 604     {
 605         my $providesstring = $onepackage->{$provides};
 606
 607         my $allprovides = installer::converter::convert_stringlist_into_array(\$providesstring, ",");
 608
 609         for ( my $i = 0; $i <= $#{$allprovides}; $i++ )
 610         {
 611             my $oneprovides = ${$allprovides}[$i];
 612             $oneprovides =~ s/\s*$//;
 613             installer::packagelist::resolve_packagevariables(\$oneprovides, $variableshashref, 1);
 614             if ( $installer::globals::linuxlinkrpmprocess ) { $oneprovides = $oneprovides . "u"; }
 615             $line = "%provides" . " " . $oneprovides . "\n";
 616             push(@epmheader, $line);
 617         }
 618     }
 619
 620     if ( $onepackage->{$requires} )
 621     {
 622         my $requiresstring = $onepackage->{$requires};
 623
 624         if ( $installer::globals::add_required_package ) { $requiresstring = $requiresstring . "," . $installer::globals::add_required_package; }
 625
 626         # The requires string can contain the separator "," in the names (descriptions) of the packages
 627         # (that are required for Solaris depend files). Therefore "," inside such a description has to
 628         # masked with a backslash.
 629         # This masked separator need to be found and replaced, before the stringlist is converted into an array.
 630         # This replacement has to be turned back after the array is created.
 631
 632         my $replacementstring = "COMMAREPLACEMENT";
 633         $requiresstring = installer::converter::replace_masked_separator($requiresstring, ",", "$replacementstring");
 634
 635         my $allrequires = installer::converter::convert_stringlist_into_array(\$requiresstring, ",");
 636
 637         installer::converter::resolve_masked_separator($allrequires, ",", $replacementstring);
 638
 639         for ( my $i = 0; $i <= $#{$allrequires}; $i++ )
 640         {
 641             my $onerequires = ${$allrequires}[$i];
 642             $onerequires =~ s/\s*$//;
 643             installer::packagelist::resolve_packagevariables2(\$onerequires, $variableshashref, 0, $isdict);
 644
 645             # Special handling for Solaris. In depend files, the names of the packages are required, not
 646             # only the abbreviation. Therefore there is a special syntax for names in packagelist:
 647             # solarisrequires = "SUNWcar (Name="Package name of SUNWcar"),SUNWkvm (Name="Package name of SUNWcar"), ...
 648             # if ( $installer::globals::issolarispkgbuild )
 649             # {
 650             #   if ( $onerequires =~ /^\s*(.*?)\s+\(\s*Name\s*=\s*\"(.*?)\"\s*\)\s*$/ )
 651             #   {
 652             #           $onerequires = $1;
 653             #           $packagename = $2;
 654             #           $installer::globals::dependfilenames{$onerequires} = $packagename;
 655             #   }
 656             # }
 657
 658             $line = "%requires" . " " . $onerequires . "\n";
 659             push(@epmheader, $line);
 660         }
 661     }
 662     else
 663     {
 664         if ( $installer::globals::add_required_package )
 665         {
 666             my $requiresstring = $installer::globals::add_required_package;
 667
 668             my $replacementstring = "COMMAREPLACEMENT";
 669             $requiresstring = installer::converter::replace_masked_separator($requiresstring, ",", "$replacementstring");
 670             my $allrequires = installer::converter::convert_stringlist_into_array(\$requiresstring, ",");
 671             installer::converter::resolve_masked_separator($allrequires, ",", $replacementstring);
 672
 673             for ( my $i = 0; $i <= $#{$allrequires}; $i++ )
 674             {
 675                 my $onerequires = ${$allrequires}[$i];
 676                 $onerequires =~ s/\s*$//;
 677                 installer::packagelist::resolve_packagevariables(\$onerequires, $variableshashref, 0);
 678
 679                 # Special handling for Solaris. In depend files, the names of the packages are required, not
 680                 # only the abbreviation. Therefore there is a special syntax for names in packagelist:
 681                 # solarisrequires = "SUNWcar (Name="Package name of SUNWcar"),SUNWkvm (Name="Package name of SUNWcar"), ...
 682                 # if ( $installer::globals::issolarispkgbuild )
 683                 # {
 684                 #       if ( $onerequires =~ /^\s*(.*?)\s+\(\s*Name\s*=\s*\"(.*?)\"\s*\)\s*$/ )
 685                 #       {
 686                 #               $onerequires = $1;
 687                 #               $packagename = $2;
 688                 #               $installer::globals::dependfilenames{$onerequires} = $packagename;
 689                 #       }
 690                 # }
 691
 692                 $line = "%requires" . " " . $onerequires . "\n";
 693                 push(@epmheader, $line);
 694             }
 695         }
 696     }
 697
 698     return \@epmheader;
 699 }
 700
 701 #######################################
 702 # Adding header to epm file
 703 #######################################
 704
 705 sub adding_header_to_epm_file
 706 {
 707     my ($epmfileref, $epmheaderref) = @_;
 708
 709     for ( my $i = 0; $i <= $#{$epmheaderref}; $i++ )
 710     {
 711         push( @{$epmfileref}, ${$epmheaderref}[$i] );
 712     }
 713
 714     push( @{$epmfileref}, "\n\n" );
 715 }
 716
 717 #####################################################
 718 # Replace one in shell scripts ( ${VARIABLENAME} )
 719 #####################################################
 720
 721 sub replace_variable_in_shellscripts
 722 {
 723     my ($scriptref, $variable, $searchstring) = @_;
 724
 725     for ( my $i = 0; $i <= $#{$scriptref}; $i++ )
 726     {
 727         ${$scriptref}[$i] =~ s/\$\{$searchstring\}/$variable/g;
 728     }
 729 }
 730
 731 ###################################################
 732 # Replace one in shell scripts ( %VARIABLENAME )
 733 ###################################################
 734
 735 sub replace_percent_variable_in_shellscripts
 736 {
 737     my ($scriptref, $variable, $searchstring) = @_;
 738
 739     for ( my $i = 0; $i <= $#{$scriptref}; $i++ )
 740     {
 741         ${$scriptref}[$i] =~ s/\%$searchstring/$variable/g;
 742     }
 743 }
 744
 745 ################################################
 746 # Replacing many variables in shell scripts
 747 ################################################
 748
 749 sub replace_many_variables_in_shellscripts
 750 {
 751     my ($scriptref, $variableshashref) = @_;
 752
 753     my $key;
 754
 755     foreach $key (keys %{$variableshashref})
 756     {
 757         my $value = $variableshashref->{$key};
 758         if ( ! $value =~ /.oxt/ ) { $value = lc($value); }      # lowercase !
 759         if ( $installer::globals::issolarisbuild) { $value =~ s/\.org/org/g; }  # openofficeorg instead of openoffice.org
 760         replace_variable_in_shellscripts($scriptref, $value, $key);
 761     }
 762 }
 763
 764 #######################################
 765 # Setting oxt file name variable
 766 #######################################
 767
 768 sub set_oxt_filename
 769 {
 770     my ($filesinpackage, $allvariables) = @_;
 771
 772     for ( my $i = 0; $i <= $#{$filesinpackage}; $i++ )
 773     {
 774         my $onefile = ${$filesinpackage}[$i];
 775         if ( $onefile->{'Name'} =~ /.oxt\s*$/ )
 776         {
 777             $allvariables->{'OXTFILENAME'} = $onefile->{'Name'};
 778             # $allvariables->{'FULLOXTFILENAME'} = $onefile->{'destination'};
 779             last;  # only one oxt file for each rpm!
 780         }
 781     }
 782 }
 783
 784 #######################################
 785 # Adding shell scripts to epm file
 786 #######################################
 787
 788 sub adding_shellscripts_to_epm_file
 789 {
 790     my ($epmfileref, $shellscriptsfilename, $localrootpath, $allvariableshashref, $filesinpackage) = @_;
 791
 792     # Setting variable for ${OXTFILENAME} into $allvariableshashref, if this is a RPM with an extension
 793     set_oxt_filename($filesinpackage, $allvariableshashref);
 794
 795     # $installer::globals::shellscriptsfilename
 796
 797     push( @{$epmfileref}, "\n\n" );
 798
 799     my $shellscriptsfileref = installer::files::read_file($shellscriptsfilename);
 800
 801     replace_variable_in_shellscripts($shellscriptsfileref, $localrootpath, "rootpath");
 802
 803     replace_many_variables_in_shellscripts($shellscriptsfileref, $allvariableshashref);
 804
 805     for ( my $i = 0; $i <= $#{$shellscriptsfileref}; $i++ )
 806     {
 807         push( @{$epmfileref}, ${$shellscriptsfileref}[$i] );
 808     }
 809
 810     push( @{$epmfileref}, "\n" );
 811 }
 812
 813 #################################################
 814 # Determining the epm on the system
 815 #################################################
 816
 817 sub find_epm_on_system
 818 {
 819     my ($includepatharrayref) = @_;
 820
 821     installer::logger::include_header_into_logfile("Check epm on system");
 822
 823     my $epmname = "epm";
 824
 825     # epm should be defined through the configure script but we need to
 826     # check for it to be defined because of the Sun environment.
 827     # Check the environment variable first and if it is not defined,
 828     # or if it is but the location is not executable, search further.
 829     # It has to be found in the solver or it has to be in the path
 830     # (saved in $installer::globals::epm_in_path) or we get the specified
 831     # one through the environment (i.e. when --with-epm=... is specified)
 832
 833     if ($ENV{'EPM'})
 834     {
 835         if (($ENV{'EPM'} ne "") && (-x "$ENV{'EPM'}"))
 836         {
 837             $epmname = $ENV{'EPM'};
 838         }
 839         elsif ( ($ENV{'EPM'} eq "no") || ($ENV{'EPM'} eq "internal") )
 840         {
 841             $epmname = "epm";
 842             my $epmref = installer::scriptitems::get_sourcepath_from_filename_and_includepath( \$epmname, $includepatharrayref, 0);
 843             if ($$epmref eq "") { installer::exiter::exit_program("ERROR: Could not find program $epmname (EPM set to \"internal\" or \"no\")!", "find_epm_on_system"); }
 844             $epmname = $$epmref;
 845         }
 846         else
 847         {
 848             installer::exiter::exit_program("Environment variable EPM set (\"$ENV{'EPM'}\"), but file does not exist or is not executable!", "find_epm_on_system");
 849         }
 850     }
 851     else
 852     {
 853         my $epmfileref = installer::scriptitems::get_sourcepath_from_filename_and_includepath(\$epmname, $includepatharrayref, 0);
 854
 855         if (($$epmfileref eq "") && (!($installer::globals::epm_in_path))) { installer::exiter::exit_program("ERROR: Could not find program $epmname!", "find_epm_on_system"); }
 856         if (($$epmfileref eq "") && ($installer::globals::epm_in_path)) { $epmname = $installer::globals::epm_path; }
 857         if (!($$epmfileref eq "")) { $epmname = $$epmfileref; }
 858     }
 859
 860     my $infoline = "Using epmfile: $epmname\n";
 861     push( @installer::globals::logfileinfo, $infoline);
 862
 863     return $epmname;
 864 }
 865
 866 #################################################
 867 # Determining the epm patch state
 868 # saved in $installer::globals::is_special_epm
 869 #################################################
 870
 871 sub set_patch_state
 872 {
 873     my ($epmexecutable) = @_;
 874
 875     my $infoline = "";
 876
 877     my $systemcall = "$epmexecutable |";
 878     open (EPMPATCH, "$systemcall");
 879
 880     while (<EPMPATCH>)
 881     {
 882         chop;
 883         if ( $_ =~ /Patched for OpenOffice.org/ ) { $installer::globals::is_special_epm = 1; }
 884     }
 885
 886     close (EPMPATCH);
 887
 888     if ( $installer::globals::is_special_epm )
 889     {
 890         $infoline = "\nPatch state: This is a patched version of epm!\n\n";
 891         push( @installer::globals::logfileinfo, $infoline);
 892     }
 893     else
 894     {
 895         $infoline = "\nPatch state: This is an unpatched version of epm!\n\n";
 896         push( @installer::globals::logfileinfo, $infoline);
 897     }
 898
 899     if ( ( $installer::globals::is_special_epm ) && (($installer::globals::islinuxrpmbuild) || ($installer::globals::issolarispkgbuild)) )
 900     {
 901         # Special postprocess handling only for Linux RPM and Solaris packages
 902         $installer::globals::postprocess_specialepm = 1;
 903         $installer::globals::postprocess_standardepm = 0;
 904     }
 905     else
 906     {
 907         $installer::globals::postprocess_specialepm = 0;
 908         $installer::globals::postprocess_standardepm = 1;
 909     }
 910 }
 911
 912 #################################################
 913 # LD_PRELOAD string for Debian packages
 914 #################################################
 915
 916 sub get_ld_preload_string
 917 {
 918     my ($includepatharrayref) = @_;
 919
 920     my $getuidlibraryname = "getuid.so";
 921
 922     my $getuidlibraryref = installer::scriptitems::get_sourcepath_from_filename_and_includepath(\$getuidlibraryname, $includepatharrayref, 0);
 923     if ($$getuidlibraryref eq "") { installer::exiter::exit_program("ERROR: Could not find $getuidlibraryname!", "get_ld_preload_string"); }
 924
 925     my $ldpreloadstring = "LD_PRELOAD=" . $$getuidlibraryref;
 926
 927     return $ldpreloadstring;
 928 }
 929
 930 #################################################
 931 # Calling epm to create the installation sets
 932 #################################################
 933
 934 sub call_epm
 935 {
 936     my ($epmname, $epmlistfilename, $packagename, $includepatharrayref) = @_;
 937
 938     installer::logger::include_header_into_logfile("epm call for $packagename");
 939
 940     my $packageformat = $installer::globals::packageformat;
 941
 942     my $localpackagename = $packagename;
 943     # Debian allows only lowercase letters in package name
 944     if ( $installer::globals::debian ) { $localpackagename = lc($localpackagename); }
 945
 946     my $outdirstring = "";
 947     if ( $installer::globals::epmoutpath ne "" ) { $outdirstring = " --output-dir $installer::globals::epmoutpath"; }
 948
 949     # Debian package build needs a LD_PRELOAD for correct rights
 950
 951     my $ldpreloadstring = "";
 952
 953     if ( $installer::globals::debian ) { $ldpreloadstring = get_ld_preload_string($includepatharrayref) . " "; }
 954
 955     my $extraflags = "";
 956         if ($ENV{'EPM_FLAGS'}) { $extraflags = $ENV{'EPM_FLAGS'}; }
 957
 958     my $systemcall = $ldpreloadstring . $epmname . " -f " . $packageformat . " " . $extraflags . " " . $localpackagename . " " . $epmlistfilename . $outdirstring . " -v " . " 2\>\&1 |";
 959
 960     installer::logger::print_message( "... $systemcall ...\n" );
 961
 962     my $maxepmcalls = 3;
 963
 964     for ( my $i = 1; $i <= $maxepmcalls; $i++ )
 965     {
 966         my @epmoutput = ();
 967
 968         open (EPM, "$systemcall");
 969         while (<EPM>) {push(@epmoutput, $_); }
 970         close (EPM);
 971
 972         my $returnvalue = $?;   # $? contains the return value of the systemcall
 973
 974         my $infoline = "Systemcall  (Try $i): $systemcall\n";
 975         push( @installer::globals::logfileinfo, $infoline);
 976
 977         for ( my $j = 0; $j <= $#epmoutput; $j++ )
 978         {
 979             if ( $i < $maxepmcalls ) { $epmoutput[$j] =~ s/\bERROR\b/PROBLEM/ig; }
 980             push( @installer::globals::logfileinfo, "$epmoutput[$j]");
 981         }
 982
 983         if ($returnvalue)
 984         {
 985             $infoline = "Try $i : Could not execute \"$systemcall\"!\n";
 986             push( @installer::globals::logfileinfo, $infoline);
 987             if ( $i == $maxepmcalls ) { installer::exiter::exit_program("ERROR: \"$systemcall\"!", "call_epm"); }
 988         }
 989         else
 990         {
 991             installer::logger::print_message( "Success (Try $i): \"$systemcall\"\n" );
 992             $infoline = "Success: Executed \"$systemcall\" successfully!\n";
 993             push( @installer::globals::logfileinfo, $infoline);
 994             last;
 995         }
 996     }
 997 }
 998
 999 #####################################################################
1000 # Adding the new line for relocatables into pkginfo file (Solaris)
1001 # or spec file (Linux) created by epm
1002 #####################################################################
1003
1004 sub add_one_line_into_file
1005 {
1006     my ($file, $insertline, $filename) = @_;
1007
1008     if ( $installer::globals::issolarispkgbuild )
1009     {
1010         push(@{$file}, $insertline);            # simply adding at the end of pkginfo file
1011     }
1012
1013     if ( $installer::globals::islinuxrpmbuild )
1014     {
1015         # Adding behind the line beginning with: Group:
1016
1017         my $inserted_line = 0;
1018
1019         for ( my $i = 0; $i <= $#{$file}; $i++ )
1020         {
1021             if ( ${$file}[$i] =~ /^\s*Group\:\s*/ )
1022             {
1023                 splice(@{$file},$i+1,0,$insertline);
1024                 $inserted_line = 1;
1025                 last;
1026             }
1027         }
1028
1029         if (! $inserted_line) { installer::exiter::exit_program("ERROR: Did not find string \"Group:\" in file: $filename", "add_one_line_into_file"); }
1030     }
1031
1032     $insertline =~ s/\s*$//;    # removing line end for correct logging
1033     my $infoline = "Success: Added line $insertline into file $filename!\n";
1034     push( @installer::globals::logfileinfo, $infoline);
1035 }
1036
1037 #####################################################################
1038 # Setting the revision VERSION=1.9,REV=66  .
1039 # Also adding the new line: "AutoReqProv: no"
1040 #####################################################################
1041
1042 sub set_revision_in_pkginfo
1043 {
1044     my ($file, $filename, $variables, $packagename) = @_;
1045
1046     my $revisionstring = "\,REV\=" . $installer::globals::packagerevision;
1047
1048     # Adding also a time string to the revision. Syntax: VERSION=8.0.0,REV=66.2005.01.24
1049
1050     my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime(time);
1051
1052     $mday = $mday;
1053     $mon = $mon + 1;
1054     $year = $year + 1900;
1055
1056     if ( $mday < 10 ) { $mday = "0" . $mday; }
1057     if ( $mon < 10 ) { $mon = "0" . $mon; }
1058     $datestring = $year . "." . $mon . "." . $mday;
1059     $revisionstring = $revisionstring . "." . $datestring;
1060
1061     for ( my $i = 0; $i <= $#{$file}; $i++ )
1062     {
1063         if ( ${$file}[$i] =~ /^\s*(VERSION\=.*?)\s*$/ )
1064         {
1065             my $oldstring = $1;
1066             my $newstring = $oldstring . $revisionstring;       # also adding the date string
1067             ${$file}[$i] =~ s/$oldstring/$newstring/;
1068             my $infoline = "Info: Changed in $filename file: \"$oldstring\" to \"$newstring\"!\n";
1069             push( @installer::globals::logfileinfo, $infoline);
1070             last;
1071         }
1072     }
1073
1074     # For Update and Patch reasons, this string can also be kept constant
1075
1076     my $pkgversion = "SOLSPARCPKGVERSION";
1077     if ( $installer::globals::issolarisx86build ) { $pkgversion = "SOLIAPKGVERSION"; }
1078
1079     if (( $variables->{$pkgversion} ) &&  ( $variables->{$pkgversion} ne "" ))
1080     {
1081         if ( $variables->{$pkgversion} ne "FINALVERSION" )
1082         {
1083             # In OOo 3.x timeframe, this string is no longer unique for all packages, because of the three layer.
1084             # In the string: "3.0.0,REV=9.2008.09.30" only the part "REV=9.2008.09.30" can be unique for all packages
1085             # and therefore be set as $pkgversion.
1086             # The first part "3.0.0" has to be derived from the
1087
1088             my $version = $installer::globals::packageversion;
1089             if ( $version =~ /^\s*(\d+)\.(\d+)\.(\d+)\s*$/ )
1090             {
1091                 my $major = $1;
1092                 my $minor = $2;
1093                 my $micro = $3;
1094
1095                 my $finalmajor = $major;
1096                 my $finalminor = $minor;
1097                 my $finalmicro = 0;
1098
1099                 # if (( $packagename =~ /-ure\s*$/ ) && ( $finalmajor == 1 )) { $finalminor = 4; }
1100
1101                 $version = "$finalmajor.$finalminor.$finalmicro";
1102             }
1103
1104             my $versionstring = "$version,$variables->{$pkgversion}";
1105
1106             for ( my $i = 0; $i <= $#{$file}; $i++ )
1107             {
1108                 if ( ${$file}[$i] =~ /^\s*(VERSION\=).*?\s*$/ )
1109                 {
1110                     my $start = $1;
1111                     my $newstring = $start . $versionstring . "\n";     # setting the complete new string
1112                     my $oldstring = ${$file}[$i];
1113                     ${$file}[$i] = $newstring;
1114                     $oldstring =~ s/\s*$//;
1115                     $newstring =~ s/\s*$//;
1116                     my $infoline = "Info: Changed in $filename file: \"$oldstring\" to \"$newstring\"!\n";
1117                     push( @installer::globals::logfileinfo, $infoline);
1118                     last;
1119                 }
1120             }
1121         }
1122     }
1123 }
1124
1125 ########################################################
1126 # Setting Patch information for Respin versions
1127 # into pkginfo file. This prevents Respin versions
1128 # from patching.
1129 ########################################################
1130
1131 sub set_patchlist_in_pkginfo_for_respin
1132 {
1133     my ($changefile, $filename, $allvariables, $packagename) = @_;
1134
1135     my $patchlistname = "SOLSPARCPATCHLISTFORRESPIN";
1136     if ( $installer::globals::issolarisx86build ) { $patchlistname = "SOLIAPATCHLISTFORRESPIN"; }
1137
1138     if ( $allvariables->{$patchlistname} )
1139     {
1140         # patchlist separator is a blank
1141         my $allpatchesstring = $allvariables->{$patchlistname};
1142         my @usedpatches = ();
1143
1144         # Analyzing the patchlist
1145         # Syntax: 120186-10 126411-01(+core-01) -> use 126411-01 only for core-01
1146         # Syntax: 120186-10 126411-01(-core-01) -> use 126411-01 for all packages except for core-01
1147         my $allpatches = installer::converter::convert_whitespace_stringlist_into_array(\$allpatchesstring);
1148
1149         for ( my $i = 0; $i <= $#{$allpatches}; $i++ )
1150         {
1151             my $patchdefinition = ${$allpatches}[$i];
1152
1153             my $patchid = "";
1154             my $symbol = "";
1155             my $constraint = "";
1156             my $isusedpatch = 0;
1157
1158             if ( $patchdefinition =~ /^\s*(.+)\(([+-])(.+)\)\s*$/ )
1159             {
1160                 $patchid = $1;
1161                 $symbol = $2;
1162                 $constraint = $3;
1163             }
1164             elsif (( $patchdefinition =~ /\(/ ) || ( $patchdefinition =~ /\)/ ))        # small syntax check
1165             {
1166                 # if there is a bracket in the $patchdefinition, but it does not
1167                 # match the if-condition, this is an erroneous definition.
1168                 installer::exiter::exit_program("ERROR: Unknown patch string: $patchdefinition", "set_patchlist_in_pkginfo_for_respin");
1169             }
1170             else
1171             {
1172                 $patchid = $patchdefinition;
1173                 $isusedpatch = 1; # patches without constraint are always included
1174             }
1175
1176             if ( $symbol ne "" )
1177             {
1178                 if ( $symbol eq "+" )
1179                 {
1180                     if ( $packagename =~ /^.*\Q$constraint\E\s*$/ ) { $isusedpatch = 1; }
1181                 }
1182
1183                 if ( $symbol eq "-" )
1184                 {
1185                     if ( ! ( $packagename =~ /^.*\Q$constraint\E\s*$/ )) { $isusedpatch = 1; }
1186                 }
1187             }
1188
1189             if ( $isusedpatch ) { push(@usedpatches, $patchid); }
1190         }
1191
1192         if ( $#usedpatches > -1 )
1193         {
1194             my $patchstring = installer::converter::convert_array_to_space_separated_string(\@usedpatches);
1195
1196             my $newline = "PATCHLIST=" . $patchstring . "\n";
1197             add_one_line_into_file($changefile, $newline, $filename);
1198
1199             # Adding patch info for each used patch in the patchlist
1200
1201             for ( my $i = 0; $i <= $#usedpatches; $i++ )
1202             {
1203                 my $patchid = $usedpatches[$i];
1204                 my $key = "PATCH_INFO_" . $patchid;
1205                 $key =~ s/\s*$//;
1206
1207                 if ( ! $allvariables->{$key} ) { installer::exiter::exit_program("ERROR: No Patch info available in zip list file for $key", "set_patchlist_in_pkginfo"); }
1208                 my $value = set_timestamp_in_patchinfo($allvariables->{$key});
1209                 $newline = $key . "=" . $value . "\n";
1210
1211                 add_one_line_into_file($changefile, $newline, $filename);
1212             }
1213         }
1214     }
1215 }
1216
1217 ########################################################
1218 # Solaris requires, that the time of patch installation
1219 # must not be empty.
1220 # Format: Mon Mar 24 11:20:56 PDT 2008
1221 # Log file: Tue Apr 29 23:26:19 2008 (04:31 min.)
1222 # Replace string: ${TIMESTAMP}
1223 ########################################################
1224
1225 sub set_timestamp_in_patchinfo
1226 {
1227     my ($value) = @_;
1228
1229     my $currenttime = localtime();
1230
1231     if ( $currenttime =~ /^\s*(.+?)(\d\d\d\d)\s*$/ )
1232     {
1233         my $start = $1;
1234         my $year = $2;
1235         $currenttime = $start . "CET " . $year;
1236     }
1237
1238     $value =~ s/\$\{TIMESTAMP\}/$currenttime/;
1239
1240     return $value;
1241 }
1242
1243 ########################################################
1244 # Setting MAXINST=1000 into the pkginfo file.
1245 ########################################################
1246
1247 sub set_maxinst_in_pkginfo
1248 {
1249     my ($changefile, $filename) = @_;
1250
1251     my $newline = "MAXINST\=1000\n";
1252
1253     add_one_line_into_file($changefile, $newline, $filename);
1254 }
1255
1256 #############################################################
1257 # Setting several Solaris variables into the pkginfo file.
1258 #############################################################
1259
1260 sub set_solaris_parameter_in_pkginfo
1261 {
1262     my ($changefile, $filename, $allvariables) = @_;
1263
1264     my $newline = "";
1265
1266     # SUNW_PRODNAME
1267     # SUNW_PRODVERS
1268     # SUNW_PKGVERS
1269     # Not: SUNW_PKGTYPE
1270     # HOTLINE
1271     # EMAIL
1272
1273     my $productname = $allvariables->{'PRODUCTNAME'};
1274     $newline = "SUNW_PRODNAME=$productname\n";
1275     add_one_line_into_file($changefile, $newline, $filename);
1276
1277     my $productversion = "";
1278     if ( $allvariables->{'PRODUCTVERSION'} )
1279     {
1280         $productversion = $allvariables->{'PRODUCTVERSION'};
1281         if ( $allvariables->{'PRODUCTEXTENSION'} ) { $productversion = $productversion . "/" . $allvariables->{'PRODUCTEXTENSION'}; }
1282     }
1283     $newline = "SUNW_PRODVERS=$productversion\n";
1284     add_one_line_into_file($changefile, $newline, $filename);
1285
1286     $newline = "SUNW_PKGVERS=1\.0\n";
1287     add_one_line_into_file($changefile, $newline, $filename);
1288
1289     if ( $allvariables->{'SUNW_PKGTYPE'} )
1290     {
1291         $newline = "SUNW_PKGTYPE=$allvariables->{'SUNW_PKGTYPE'}\n";
1292         add_one_line_into_file($changefile, $newline, $filename);
1293     }
1294     else
1295     {
1296         $newline = "SUNW_PKGTYPE=\n";
1297         add_one_line_into_file($changefile, $newline, $filename);
1298     }
1299
1300     $newline = "HOTLINE=Please contact your local service provider\n";
1301     add_one_line_into_file($changefile, $newline, $filename);
1302
1303     $newline = "EMAIL=\n";
1304     add_one_line_into_file($changefile, $newline, $filename);
1305
1306 }
1307
1308 #####################################################################
1309 # epm uses as archtecture for Solaris x86 "i86pc". This has to be
1310 # changed to "i386".
1311 #####################################################################
1312
1313 sub fix_architecture_setting
1314 {
1315     my ($changefile) = @_;
1316
1317     for ( my $i = 0; $i <= $#{$changefile}; $i++ )
1318     {
1319         if ( ${$changefile}[$i] =~ /^\s*ARCH=i86pc\s*$/ )
1320         {
1321             ${$changefile}[$i] =~ s/i86pc/i386/;
1322             last;
1323         }
1324
1325     }
1326 }
1327
1328 #####################################################################
1329 # Adding a new line for topdir into specfile, removing old
1330 # topdir if set.
1331 #####################################################################
1332
1333 sub set_topdir_in_specfile
1334 {
1335     my ($changefile, $filename, $newepmdir) = @_;
1336
1337     # $newepmdir =~ s/^\s*\.//; # removing leading "."
1338     $newepmdir = cwd() . $installer::globals::separator . $newepmdir; # only absolute path allowed
1339
1340     # removing "%define _topdir", if existing
1341
1342     for ( my $i = 0; $i <= $#{$changefile}; $i++ )
1343     {
1344         if ( ${$changefile}[$i] =~ /^\s*\%define _topdir\s+/ )
1345         {
1346             my $removeline = ${$changefile}[$i];
1347             $removeline =~ s/\s*$//;
1348             splice(@{$changefile},$i,1);
1349             my $infoline = "Info: Removed line \"$removeline\" from file $filename!\n";
1350             push( @installer::globals::logfileinfo, $infoline);
1351             last;
1352         }
1353     }
1354
1355     # Adding "topdir" behind the line beginning with: Group:
1356
1357     my $inserted_line = 0;
1358
1359     my $topdirline = "\%define _topdir $newepmdir\n";
1360
1361     for ( my $i = 0; $i <= $#{$changefile}; $i++ )
1362     {
1363         if ( ${$changefile}[$i] =~ /^\s*Group\:\s*/ )
1364         {
1365             splice(@{$changefile},$i+1,0,$topdirline);
1366             $inserted_line = 1;
1367             $topdirline =~ s/\s*$//;
1368             my $infoline = "Success: Added line $topdirline into file $filename!\n";
1369             push( @installer::globals::logfileinfo, $infoline);
1370         }
1371     }
1372
1373     if (! $inserted_line) { installer::exiter::exit_program("ERROR: Did not find string \"Group:\" in file: $filename", "set_topdir_in_specfile"); }
1374
1375 }
1376
1377 #####################################################################
1378 # Setting the packager in the spec file
1379 # Syntax: Packager: abc@def
1380 #####################################################################
1381
1382 sub set_packager_in_specfile
1383 {
1384     my ($changefile) = @_;
1385
1386     my $packager = $installer::globals::longmanufacturer;
1387
1388     for ( my $i = 0; $i <= $#{$changefile}; $i++ )
1389     {
1390         if ( ${$changefile}[$i] =~ /^\s*Packager\s*:\s*(.+?)\s*$/ )
1391         {
1392             my $oldstring = $1;
1393             ${$changefile}[$i] =~ s/\Q$oldstring\E/$packager/;
1394             my $infoline = "Info: Changed Packager in spec file from $oldstring to $packager!\n";
1395             push( @installer::globals::logfileinfo, $infoline);
1396             last;
1397         }
1398     }
1399 }
1400
1401 #####################################################################
1402 # Setting the requirements in the spec file (i81494)
1403 # Syntax: PreReq: "requirements" (only for shared extensions)
1404 #####################################################################
1405
1406 sub set_prereq_in_specfile
1407 {
1408     my ($changefile) = @_;
1409
1410     my $prereq = "PreReq:";
1411
1412     for ( my $i = 0; $i <= $#{$changefile}; $i++ )
1413     {
1414         if ( ${$changefile}[$i] =~ /^\s*Requires:\s*(.+?)\s*$/ )
1415         {
1416             my $oldstring = ${$changefile}[$i];
1417             ${$changefile}[$i] =~ s/Requires:/$prereq/;
1418             my $infoline = "Info: Changed requirements in spec file from $oldstring to ${$changefile}[$i]!\n";
1419             push( @installer::globals::logfileinfo, $infoline);
1420         }
1421     }
1422 }
1423
1424 #####################################################################
1425 # Setting the Auto[Req]Prov line and __find_requires
1426 #####################################################################
1427
1428 sub set_autoprovreq_in_specfile
1429 {
1430     my ($changefile, $findrequires, $bindir) = @_;
1431
1432     my $autoreqprovline;
1433
1434     if ( $findrequires )
1435     {
1436         $autoreqprovline = "AutoProv\: no\n%define __find_requires $bindir/$findrequires\n";
1437     }
1438     else
1439     {
1440         $autoreqprovline = "AutoReqProv\: no\n";
1441     }
1442
1443     for ( my $i = 0; $i <= $#{$changefile}; $i++ )
1444     {
1445         # Adding "autoreqprov" behind the line beginning with: Group:
1446         if ( ${$changefile}[$i] =~ /^\s*Group\:\s*/ )
1447         {
1448             splice(@{$changefile},$i+1,0,$autoreqprovline);
1449             $autoreqprovline =~ s/\s*$//;
1450             $infoline = "Success: Added line $autoreqprovline into spec file!\n";
1451             push( @installer::globals::logfileinfo, $infoline);
1452
1453             last;
1454         }
1455     }
1456 }
1457
1458 #####################################################################
1459 # Replacing Copyright with License in the spec file
1460 # Syntax: License: LGPL, SISSL
1461 #####################################################################
1462
1463 sub set_license_in_specfile
1464 {
1465     my ($changefile, $variableshashref) = @_;
1466
1467     my $license = $variableshashref->{'LICENSENAME'};
1468
1469     for ( my $i = 0; $i <= $#{$changefile}; $i++ )
1470     {
1471         if ( ${$changefile}[$i] =~ /^\s*Copyright\s*:\s*(.+?)\s*$/ )
1472         {
1473             ${$changefile}[$i] = "License: $license\n";
1474             my $infoline = "Info: Replaced Copyright with License: $license !\n";
1475             push( @installer::globals::logfileinfo, $infoline);
1476             last;
1477         }
1478     }
1479 }
1480
1481 #########################################################
1482 # Building relocatable Solaris packages means:
1483 # 1. Add "BASEDIR=/opt" into pkginfo
1484 # 2. Remove "/opt/" from all objects in prototype file
1485 # For step2 this function exists
1486 # Sample: d none /opt/openofficeorg20/help 0755 root other
1487 # -> d none openofficeorg20/help 0755 root other
1488 #########################################################
1489
1490 sub make_prototypefile_relocatable
1491 {
1492     my ($prototypefile, $relocatablepath) = @_;
1493
1494     for ( my $i = 0; $i <= $#{$prototypefile}; $i++ )
1495     {
1496         if ( ${$prototypefile}[$i] =~ /^\s*\w\s+\w+\s+\/\w+/ )  # this is an object line
1497         {
1498             ${$prototypefile}[$i] =~ s/$relocatablepath//;      # Important: $relocatablepath has a "/" at the end. Example "/opt/"
1499         }
1500     }
1501
1502     # If the $relocatablepath is "/opt/openoffice20/" the line "d none /opt/openoffice20" was not changed.
1503     # This line has to be removed now
1504
1505     if ( $relocatablepath ne "/" ) { $relocatablepath =~ s/\/\s*$//; }          # removing the ending slash
1506
1507     for ( my $i = 0; $i <= $#{$prototypefile}; $i++ )
1508     {
1509         if ( ${$prototypefile}[$i] =~ /^\s*d\s+\w+\s+\Q$relocatablepath\E/ )
1510         {
1511             my $line = ${$prototypefile}[$i];
1512             splice(@{$prototypefile},$i,1);     # removing the line
1513             $line =~ s/\s*$//;
1514             my $infoline = "Info: Removed line \"$line\" from prototype file!\n";
1515             push( @installer::globals::logfileinfo, $infoline);
1516             last;
1517         }
1518     }
1519
1520     # Making "\$" to "$" in prototype file. "\$" was created by epm.
1521
1522     for ( my $i = 0; $i <= $#{$prototypefile}; $i++ )
1523     {
1524         if ( ${$prototypefile}[$i] =~ /\\\$/ )
1525         {
1526             ${$prototypefile}[$i] =~ s/\\\$/\$/g;
1527             my $infoline2 = "Info: Changed line in prototype file: ${$prototypefile}[$i] !\n";
1528             push( @installer::globals::logfileinfo, $infoline2);
1529         }
1530     }
1531 }
1532
1533
1534 #########################################################################
1535 # In scp the flag VOLATEFILE can be used. This shall lead to style "v"
1536 # in Solaris prototype file. This is not supported by epm and has
1537 # therefore to be included in prototypefile, not in epm list file.
1538 #########################################################################
1539
1540 sub set_volatilefile_into_prototypefile
1541 {
1542     my ($prototypefile, $filesref) = @_;
1543
1544     for ( my $i = 0; $i <= $#{$filesref}; $i++ )
1545     {
1546         my $onefile = ${$filesref}[$i];
1547
1548         my $styles = "";
1549         if ( $onefile->{'Styles'} ) { $styles = $onefile->{'Styles'}; }
1550
1551         if ( $styles =~ /\bVOLATILEFILE\b/ )
1552         {
1553             my $sourcepath = $onefile->{'sourcepath'};
1554
1555             for ( my $j = 0; $j <= $#{$prototypefile}; $j++ )
1556             {
1557                 if (( ${$prototypefile}[$j] =~ /^\s*f\s+none\s+/ ) && ( ${$prototypefile}[$j] =~ /\=\Q$sourcepath\E\s+/ ))
1558                 {
1559                     my $oldline = ${$prototypefile}[$j];
1560                     ${$prototypefile}[$j] =~ s/^\s*f/v/;
1561                     my $newline = ${$prototypefile}[$j];
1562                     $oldline =~ s/\s*$//;
1563                     $newline =~ s/\s*$//;
1564                     my $infoline = "Volatile file: Changing content from \"$oldline\" to \"$newline\" .\n";
1565                     push(@installer::globals::logfileinfo, $infoline);
1566                     last;
1567                 }
1568             }
1569         }
1570     }
1571 }
1572
1573 #########################################################################
1574 # Replacing the variables in the Solaris patch shell scripts.
1575 # Taking care, that multiple slashes are not always removed.
1576 #########################################################################
1577
1578 sub replace_variables_in_shellscripts_for_patch
1579 {
1580     my ($scriptfile, $scriptfilename, $oldstring, $newstring) = @_;
1581
1582     for ( my $i = 0; $i <= $#{$scriptfile}; $i++ )
1583     {
1584         if ( ${$scriptfile}[$i] =~ /\Q$oldstring\E/ )
1585         {
1586             my $oldline = ${$scriptfile}[$i];
1587             if (( $oldstring eq "PRODUCTDIRECTORYNAME" ) && ( $newstring eq "" )) { $oldstring = $oldstring . "/"; }
1588             ${$scriptfile}[$i] =~ s/\Q$oldstring\E/$newstring/g;
1589             my $infoline = "Info: Substituting in $scriptfilename $oldstring by $newstring\n";
1590             push(@installer::globals::logfileinfo, $infoline);
1591         }
1592     }
1593 }
1594
1595 #########################################################################
1596 # Replacing the variables in the shell scripts or in the epm list file
1597 # Linux: spec file
1598 # Solaris: preinstall, postinstall, preremove, postremove
1599 # If epm is used in the original version (not relocatable)
1600 # the variables have to be exchanged in the list file,
1601 # created for epm.
1602 #########################################################################
1603
1604 sub replace_variables_in_shellscripts
1605 {
1606     my ($scriptfile, $scriptfilename, $oldstring, $newstring) = @_;
1607
1608     my $debug = 0;
1609     if ( $oldstring eq "PRODUCTDIRECTORYNAME" ) { $debug = 1; }
1610
1611     for ( my $i = 0; $i <= $#{$scriptfile}; $i++ )
1612     {
1613         if ( ${$scriptfile}[$i] =~ /\Q$oldstring\E/ )
1614         {
1615             my $oldline = ${$scriptfile}[$i];
1616             ${$scriptfile}[$i] =~ s/\Q$oldstring\E/$newstring/g;
1617             ${$scriptfile}[$i] =~ s/\/\//\//g;  # replacing "//" by "/" , if path $newstring is empty!
1618             my $infoline = "Info: Substituting in $scriptfilename $oldstring by $newstring\n";
1619             push(@installer::globals::logfileinfo, $infoline);
1620             if ( $debug )
1621             {
1622                 $infoline = "Old Line: $oldline";
1623                 push(@installer::globals::logfileinfo, $infoline);
1624                 $infoline = "New Line: ${$scriptfile}[$i]";
1625                 push(@installer::globals::logfileinfo, $infoline);
1626             }
1627         }
1628     }
1629 }
1630
1631 ############################################################
1632 # Determinig the directory created by epm, in which the
1633 # RPMS or Solaris packages are created.
1634 ############################################################
1635
1636 sub determine_installdir_ooo
1637 {
1638     # A simple "ls" command returns the directory name
1639
1640     my $dirname = "";
1641
1642     my $systemcall = "ls |";
1643     open (LS, "$systemcall");
1644     $dirname = <LS>;
1645     close (LS);
1646
1647     $dirname =~ s/\s*$//;
1648
1649     my $infoline = "Info: Directory created by epm: $dirname\n";
1650     push(@installer::globals::logfileinfo, $infoline);
1651
1652     return $dirname;
1653 }
1654
1655 ############################################################
1656 # Setting the tab content into the file container
1657 ############################################################
1658
1659 sub set_tab_into_datafile
1660 {
1661     my ($changefile, $filesref) = @_;
1662
1663     my @newclasses = ();
1664     my $newclassesstring = "";
1665
1666     if ( $installer::globals::issolarispkgbuild )
1667     {
1668         for ( my $i = 0; $i <= $#{$filesref}; $i++ )
1669         {
1670             my $onefile = ${$filesref}[$i];
1671
1672             if ( $onefile->{'SolarisClass'} )
1673             {
1674                 my $sourcepath = $onefile->{'sourcepath'};
1675
1676                 for ( my $j = 0; $j <= $#{$changefile}; $j++ )
1677                 {
1678                     if (( ${$changefile}[$j] =~ /^\s*f\s+none\s+/ ) && ( ${$changefile}[$j] =~ /\=\Q$sourcepath\E\s+/ ))
1679                     {
1680                         my $oldline = ${$changefile}[$j];
1681                         ${$changefile}[$j] =~ s/f\s+none/e $onefile->{'SolarisClass'}/;
1682                         my $newline = ${$changefile}[$j];
1683                         $oldline =~ s/\s*$//;
1684                         $newline =~ s/\s*$//;
1685
1686                         my $infoline = "TAB: Changing content from \"$oldline\" to \"$newline\" .\n";
1687                         push(@installer::globals::logfileinfo, $infoline);
1688
1689                         # collecting all new classes
1690                         if (! installer::existence::exists_in_array($onefile->{'SolarisClass'}, \@newclasses))
1691                         {
1692                             push(@newclasses, $onefile->{'SolarisClass'});
1693                         }
1694
1695                         last;
1696                     }
1697                 }
1698             }
1699         }
1700
1701         $newclassesstring = installer::converter::convert_array_to_space_separated_string(\@newclasses);
1702     }
1703
1704     if ( $installer::globals::islinuxrpmbuild )
1705     {
1706         for ( my $i = 0; $i <= $#{$filesref}; $i++ )
1707         {
1708             my $onefile = ${$filesref}[$i];
1709
1710             if ( $onefile->{'SpecFileContent'} )
1711             {
1712                 my $destination = $onefile->{'destination'};
1713
1714                 for ( my $j = 0; $j <= $#{$changefile}; $j++ )
1715                 {
1716                     if ( ${$changefile}[$j] =~ /^\s*(\%attr\(.*\))\s+(\".*?\Q$destination\E\"\s*)$/ )
1717                     {
1718                         my $begin = $1;
1719                         my $end = $2;
1720
1721                         my $oldline = ${$changefile}[$j];
1722                         ${$changefile}[$j] = $begin . " " . $onefile->{'SpecFileContent'} . " " . $end;
1723                         my $newline = ${$changefile}[$j];
1724
1725                         $oldline =~ s/\s*$//;
1726                         $newline =~ s/\s*$//;
1727
1728                         my $infoline = "TAB: Changing content from \"$oldline\" to \"$newline\" .\n";
1729                         push(@installer::globals::logfileinfo, $infoline);
1730
1731                         last;
1732                     }
1733                 }
1734             }
1735         }
1736     }
1737
1738     return $newclassesstring;
1739 }
1740
1741 ############################################################
1742 # Including additional classes into the pkginfo file
1743 ############################################################
1744
1745 sub include_classes_into_pkginfo
1746 {
1747     my ($changefile, $classesstring) = @_;
1748
1749     for ( my $i = 0; $i <= $#{$changefile}; $i++ )
1750     {
1751         if ( ${$changefile}[$i] =~ /^\s*CLASSES\=none/ )
1752         {
1753             ${$changefile}[$i] =~ s/\s*$//;
1754             my $oldline = ${$changefile}[$i];
1755             ${$changefile}[$i] = ${$changefile}[$i] . " " . $classesstring . "\n";
1756             my $newline = ${$changefile}[$i];
1757             $newline =~ s/\s*$//;
1758
1759             my $infoline = "pkginfo file: Changing content from \"$oldline\" to \"$newline\" .\n";
1760             push(@installer::globals::logfileinfo, $infoline);
1761         }
1762     }
1763 }
1764
1765 ##########################################################################################
1766 # Checking, if an extension is included into the package (Linux).
1767 # All extension files have to be installed into directory
1768 # share/extension/install
1769 # %attr(0444,root,root) "/opt/staroffice8/share/extension/install/SunSearchToolbar.oxt"
1770 ##########################################################################################
1771
1772 sub is_extension_package
1773 {
1774     my ($specfile) = @_;
1775
1776     my $is_extension_package = 0;
1777
1778     for ( my $i = 0; $i <= $#{$specfile}; $i++ )
1779     {
1780         my $line = ${$specfile}[$i];
1781         if ( $line =~ /share\/extension\/install\/.*?\.oxt\"\s*$/ )
1782         {
1783             $is_extension_package = 1;
1784             last;
1785         }
1786     }
1787
1788     return $is_extension_package;
1789 }
1790
1791 ######################################################################
1792 # Checking, if an extension is included into the package (Solaris).
1793 # All extension files have to be installed into directory
1794 # share/extension/install
1795 ######################################################################
1796
1797 sub get_extension_name
1798 {
1799     my ($prototypefile) = @_;
1800
1801     my $extensionName = "";
1802
1803     for ( my $i = 0; $i <= $#{$prototypefile}; $i++ )
1804     {
1805         my $line = ${$prototypefile}[$i];
1806         if ( $line =~ /^\s*f\s+none\s+share\/extension\/install\/(\w+?\.oxt)\s*\=/ )
1807         {
1808             $extensionName = $1;
1809             last;
1810         }
1811     }
1812
1813     return $extensionName;
1814 }
1815
1816
1817 ############################################################
1818 # A Solaris patch contains 7 specific scripts
1819 ############################################################
1820
1821 sub add_scripts_into_prototypefile
1822 {
1823     my ($prototypefile, $prototypefilename, $languagestringref, $staticpath) = @_;
1824
1825     # The files are stored in the directory $installer::globals::patchincludepath
1826     # The file names are available via @installer::globals::solarispatchscripts
1827
1828     my $path = $installer::globals::patchincludepath;
1829     $path =~ s/\/\s*$//;
1830     $path = $path . $installer::globals::separator;
1831
1832     my @newlines = ();
1833     my $extensionname = get_extension_name($prototypefile);
1834
1835     if ( $extensionname ne "" )
1836     {
1837         for ( my $i = 0; $i <= $#installer::globals::solarispatchscriptsforextensions; $i++ )
1838         {
1839             my $sourcefilename = $path . $installer::globals::solarispatchscriptsforextensions[$i];
1840             my $destfile = $installer::globals::solarispatchscriptsforextensions[$i];
1841
1842             # If the sourcepath has "_extension" in its name, this has to be removed
1843             $destfile =~ s/_extensions\s*$//;  # hard coded renaming of script name
1844
1845             # Creating unique directory name with $prototypefilename
1846             my $extensiondir = installer::systemactions::create_directories("extensionscripts", $languagestringref);
1847
1848             if ( $prototypefilename =~ /\/(\S*?)\s*$/ ) { $prototypefilename = $1; }
1849             $prototypefilename =~ s/\./_/g;
1850             my $destdir = $extensiondir . $installer::globals::separator . $prototypefilename;
1851             if ( ! -d $destdir ) { installer::systemactions::create_directory($destdir); }
1852             my $destpath = $destdir . $installer::globals::separator . $destfile;
1853             if ( -f $destpath ) { unlink($destpath); }
1854
1855             # Reading file
1856             my $scriptfile = installer::files::read_file($sourcefilename);
1857
1858             # Replacing variables
1859             my $oldstring = "\$\{OXTFILENAME\}";
1860             replace_variables_in_shellscripts_for_patch($scriptfile, $destpath, $oldstring, $extensionname);
1861             $oldstring = "PRODUCTDIRECTORYNAME";
1862             replace_variables_in_shellscripts_for_patch($scriptfile, $destpath, $oldstring, $staticpath);
1863
1864             # Saving file
1865             installer::files::save_file($destpath, $scriptfile);
1866
1867             # Writing file destination into prototype file
1868             my $line = "i $destfile=" . $destpath . "\n";
1869             push(@newlines, $line);
1870         }
1871     }
1872     else
1873     {
1874         for ( my $i = 0; $i <= $#installer::globals::solarispatchscripts; $i++ )
1875         {
1876             my $line = "i $installer::globals::solarispatchscripts[$i]=" . $path . $installer::globals::solarispatchscripts[$i] . "\n";
1877             push(@newlines, $line);
1878         }
1879     }
1880
1881     # Including the new lines after the last line starting with "i"
1882
1883     for ( my $i = 0; $i <= $#{$prototypefile}; $i++ )
1884     {
1885         if ( ${$prototypefile}[$i] =~ /^\s*i\s+copyright/ )
1886         {
1887             splice(@{$prototypefile}, $i, 1);   # ignoring old copyright text, using patch standard
1888             next;
1889         }
1890         if ( ${$prototypefile}[$i] =~ /^\s*i\s+/ ) { next; }
1891         splice(@{$prototypefile}, $i, 0, @newlines);
1892         last;
1893     }
1894 }
1895
1896 ############################################################
1897 # Adding patch infos in pkginfo file
1898 ############################################################
1899
1900 sub include_patchinfos_into_pkginfo
1901 {
1902     my ( $changefile, $filename, $variableshashref ) = @_;
1903
1904     # SUNW_PATCHID=101998-10
1905     # SUNW_OBSOLETES=114999-01 113999-01
1906     # SUNW_PKGTYPE=usr
1907     # SUNW_PKGVERS=1.0
1908     # SUNW_REQUIRES=126411-01
1909
1910     my $patchidname = "SOLSPARCPATCHID";
1911     if ( $installer::globals::issolarisx86build ) { $patchidname = "SOLIAPATCHID"; }
1912
1913     if ( ! $variableshashref->{$patchidname} ) { installer::exiter::exit_program("ERROR: Variable $patchidname not defined in zip list file!", "include_patchinfos_into_pkginfo"); }
1914
1915     my $newline = "SUNW_PATCHID=" . $variableshashref->{$patchidname} . "\n";
1916     add_one_line_into_file($changefile, $newline, $filename);
1917
1918     my $patchobsoletesname = "SOLSPARCPATCHOBSOLETES";
1919     if ( $installer::globals::issolarisx86build ) { $patchobsoletesname = "SOLIAPATCHOBSOLETES"; }
1920
1921     my $obsoletes = "";
1922     if ( $variableshashref->{$patchobsoletesname} ) { $obsoletes = $variableshashref->{$patchobsoletesname}; }
1923     $newline = "SUNW_OBSOLETES=" . $obsoletes . "\n";
1924     add_one_line_into_file($changefile, $newline, $filename);
1925
1926     my $patchrequiresname = "SOLSPARCPATCHREQUIRES";
1927     if ( $installer::globals::issolarisx86build ) { $patchrequiresname = "SOLIAPATCHREQUIRES"; }
1928
1929     if ( $variableshashref->{$patchrequiresname} )
1930     {
1931         my $requires = $variableshashref->{$patchrequiresname};
1932         $newline = "SUNW_REQUIRES=" . $requires . "\n";
1933         add_one_line_into_file($changefile, $newline, $filename);
1934     }
1935     $newline = "SUNW_PATCH_PROPERTIES=\n";
1936     add_one_line_into_file($changefile, $newline, $filename);
1937     # $newline = "SUNW_PKGTYPE=usr\n";
1938     # add_one_line_into_file($changefile, $newline, $filename);
1939
1940     # $newline = "SUNW_PKGVERS=1.0\n";
1941     # add_one_line_into_file($changefile, $newline, $filename);
1942 }
1943
1944 ############################################################
1945 # Setting the correct Solaris locales
1946 ############################################################
1947
1948 sub get_solaris_language_for_langpack
1949 {
1950     my ( $onelanguage ) = @_;
1951
1952     my $sollanguage = $onelanguage;
1953     $sollanguage =~ s/\-/\_/;
1954
1955     if ( $sollanguage eq "de" ) { $sollanguage = "de"; }
1956     elsif ( $sollanguage eq "en_US" ) { $sollanguage = "en_AU,en_CA,en_GB,en_IE,en_MT,en_NZ,en_US,en_US.UTF-8"; }
1957     elsif ( $sollanguage eq "es" ) { $sollanguage = "es"; }
1958     elsif ( $sollanguage eq "fr" ) { $sollanguage = "fr"; }
1959     elsif ( $sollanguage eq "hu" ) { $sollanguage = "hu_HU"; }
1960     elsif ( $sollanguage eq "it" ) { $sollanguage = "it"; }
1961     elsif ( $sollanguage eq "nl" ) { $sollanguage = "nl_BE,nl_NL"; }
1962     elsif ( $sollanguage eq "pl" ) { $sollanguage = "pl_PL"; }
1963     elsif ( $sollanguage eq "sv" ) { $sollanguage = "sv"; }
1964     elsif ( $sollanguage eq "pt" ) { $sollanguage = "pt_PT"; }
1965     elsif ( $sollanguage eq "pt_BR" ) { $sollanguage = "pt_BR"; }
1966     elsif ( $sollanguage eq "ru" ) { $sollanguage = "ru_RU"; }
1967     elsif ( $sollanguage eq "ja" ) { $sollanguage = "ja,ja_JP,ja_JP.PCK,ja_JP.UTF-8"; }
1968     elsif ( $sollanguage eq "ko" ) { $sollanguage = "ko,ko.UTF-8"; }
1969     elsif ( $sollanguage eq "zh_CN" ) { $sollanguage = "zh,zh.GBK,zh_CN.GB18030,zh.UTF-8"; }
1970     elsif ( $sollanguage eq "zh_TW" ) { $sollanguage = "zh_TW,zh_TW.BIG5,zh_TW.UTF-8,zh_HK.BIG5HK,zh_HK.UTF-8"; }
1971
1972     return $sollanguage;
1973 }
1974
1975 ############################################################
1976 # Adding language infos in pkginfo file
1977 ############################################################
1978
1979 sub include_languageinfos_into_pkginfo
1980 {
1981     my ( $changefile, $filename, $languagestringref, $onepackage, $variableshashref ) = @_;
1982
1983     # SUNWPKG_LIST=core01
1984     # SUNW_LOC=de
1985
1986     my $locallang = $onepackage->{'language'};
1987     my $solarislanguage = get_solaris_language_for_langpack($locallang);
1988
1989     my $newline = "SUNW_LOC=" . $solarislanguage . "\n";
1990     add_one_line_into_file($changefile, $newline, $filename);
1991
1992     # SUNW_PKGLIST is required, if SUNW_LOC is defined.
1993     if ( $onepackage->{'pkg_list_entry'} )
1994     {
1995         my $packagelistentry = $onepackage->{'pkg_list_entry'};
1996         installer::packagelist::resolve_packagevariables(\$packagelistentry, $variableshashref, 1);
1997         $newline = "SUNW_PKGLIST=" . $packagelistentry . "\n";
1998         add_one_line_into_file($changefile, $newline, $filename);
1999     }
2000     else
2001     {
2002         # Using default package ooobasis30-core01.
2003         my $packagelistentry = "%BASISPACKAGEPREFIX%WITHOUTDOTOOOBASEVERSION-core01";
2004         installer::packagelist::resolve_packagevariables(\$packagelistentry, $variableshashref, 1);
2005         $newline = "SUNW_PKGLIST=" . $packagelistentry . "\n";
2006         add_one_line_into_file($changefile, $newline, $filename);
2007     }
2008 }
2009
2010 ############################################################
2011 # Collecting all files included in patch in
2012 # @installer::globals::patchfilecollector
2013 ############################################################
2014
2015 sub collect_patch_files
2016 {
2017     my ($file, $packagename, $prefix) = @_;
2018
2019     # $file is the spec file or the prototypefile
2020
2021     $prefix = $prefix . "/";
2022     my $packagenamestring = "Package " . $packagename . " \:\n";
2023     push(@installer::globals::patchfilecollector, $packagenamestring);
2024
2025     for ( my $i = 0; $i <= $#{$file}; $i++ )
2026     {
2027         my $line = ${$file}[$i];
2028
2029         if ( $installer::globals::islinuxrpmbuild )
2030         {
2031             # %attr(0444,root,root) "/opt/openofficeorg20/program/about.bmp"
2032
2033             if ( $line =~ /^\s*\%attr\(.*\)\s*\"(.*?)\"\s*$/ )
2034             {
2035                 my $filename = $1 . "\n";
2036                 $filename =~ s/^\s*\Q$prefix\E//;
2037                 push(@installer::globals::patchfilecollector, $filename);
2038             }
2039         }
2040
2041         if ( $installer::globals::issolarispkgbuild )
2042         {
2043             # f none program/msomrl.rdb=/ab/SRC680/unxsols4.pro/bin/msomrl.rdb 0444 root bin
2044
2045             if ( $line =~ /^\s*f\s+\w+\s+(.*?)\=/ )
2046             {
2047                 my $filename = $1 . "\n";
2048                 push(@installer::globals::patchfilecollector, $filename);
2049             }
2050         }
2051     }
2052
2053     push(@installer::globals::patchfilecollector, "\n");
2054
2055 }
2056
2057 ############################################################
2058 # Including package names into the depend files.
2059 # The package names have to be included into
2060 # packagelist. They are already saved in
2061 # %installer::globals::dependfilenames.
2062 ############################################################
2063
2064 sub put_packagenames_into_dependfile
2065 {
2066     my ( $file ) = @_;
2067
2068     for ( my $i = 0; $i <= $#{$file}; $i++ )
2069     {
2070         my $line = ${$file}[$i];
2071         if ( $line =~ /^\s*\w\s+(.*?)\s*$/ )
2072         {
2073             my $abbreviation = $1;
2074
2075             if ( $abbreviation =~ /\%/ ) { installer::exiter::exit_program("ERROR: Could not resolve all properties in Solaris package abbreviation \"$abbreviation\"!", "read_packagemap"); }
2076
2077             if ( exists($installer::globals::dependfilenames{$abbreviation}) )
2078             {
2079                 my $packagename = $installer::globals::dependfilenames{$abbreviation};
2080                 if ( $packagename =~ /\%/ ) { installer::exiter::exit_program("ERROR: Could not resolve all properties in Solaris package name \"$packagename\"!", "read_packagemap"); }
2081
2082                 $line =~ s/\s*$//;
2083                 ${$file}[$i] = $line . "\t" . $packagename . "\n";
2084             }
2085             else
2086             {
2087                 installer::exiter::exit_program("ERROR: Missing packagename for Solaris package \"$abbreviation\"!", "put_packagenames_into_dependfile");
2088             }
2089         }
2090     }
2091 }
2092
2093 ############################################################
2094 # Including the relocatable directory into
2095 # spec file and pkginfo file
2096 # Linux: set topdir in specfile
2097 # Solaris: remove $relocatablepath (/opt/)
2098 # for all objects in prototype file
2099 # and changing "topdir" for Linux
2100 ############################################################
2101
2102 sub prepare_packages
2103 {
2104     my ($loggingdir, $packagename, $staticpath, $relocatablepath, $onepackage, $variableshashref, $filesref, $languagestringref) = @_;
2105
2106     my $filename = "";
2107     my $newline = "";
2108     my $newepmdir = $installer::globals::epmoutpath . $installer::globals::separator;
2109
2110     my $localrelocatablepath = $relocatablepath;
2111     if ( $localrelocatablepath ne "/" ) { $localrelocatablepath =~ s/\/\s*$//; }
2112
2113     if ( $installer::globals::issolarispkgbuild )
2114     {
2115         $filename = $packagename . ".pkginfo";
2116         $newline = "BASEDIR\=" . $localrelocatablepath . "\n";
2117     }
2118
2119     if ( $installer::globals::islinuxrpmbuild )
2120     {
2121         # if ( $localrelocatablepath =~ /^\s*$/ ) { $localrelocatablepath = "/"; }; # at least the "/"
2122         $filename =  $packagename . ".spec";
2123         $newline = "Prefix\:\ " . $localrelocatablepath . "\n";
2124     }
2125
2126     my $completefilename = $newepmdir . $filename;
2127
2128     if ( ! -f $completefilename) { installer::exiter::exit_program("ERROR: Did not find file: $completefilename", "prepare_packages"); }
2129     my $changefile = installer::files::read_file($completefilename);
2130     if ( $newline ne "" )
2131     {
2132         add_one_line_into_file($changefile, $newline, $filename);
2133         installer::files::save_file($completefilename, $changefile);
2134     }
2135
2136     # my $newepmdir = $completefilename;
2137     # installer::pathanalyzer::get_path_from_fullqualifiedname(\$newepmdir);
2138
2139     # adding new "topdir" and removing old "topdir" in specfile
2140
2141     if ( $installer::globals::islinuxrpmbuild )
2142     {
2143         set_topdir_in_specfile($changefile, $filename, $newepmdir);
2144         set_autoprovreq_in_specfile($changefile, $onepackage->{'findrequires'}, "$installer::globals::unpackpath" . "/bin");
2145         set_packager_in_specfile($changefile);
2146         if ( is_extension_package($changefile) ) { set_prereq_in_specfile($changefile); }
2147         set_license_in_specfile($changefile, $variableshashref);
2148         set_tab_into_datafile($changefile, $filesref);
2149         # check_requirements_in_specfile($changefile);
2150         installer::files::save_file($completefilename, $changefile);
2151         if ( $installer::globals::patch ) { collect_patch_files($changefile, $packagename, $localrelocatablepath); }
2152     }
2153
2154     # removing the relocatable path in prototype file
2155
2156     if ( $installer::globals::issolarispkgbuild )
2157     {
2158         set_revision_in_pkginfo($changefile, $filename, $variableshashref, $packagename);
2159         set_maxinst_in_pkginfo($changefile, $filename);
2160         set_solaris_parameter_in_pkginfo($changefile, $filename, $variableshashref);
2161         if ( $installer::globals::issolarisx86build ) { fix_architecture_setting($changefile); }
2162         if ( ! $installer::globals::patch ) { set_patchlist_in_pkginfo_for_respin($changefile, $filename, $variableshashref, $packagename); }
2163         if ( $installer::globals::patch ) { include_patchinfos_into_pkginfo($changefile, $filename, $variableshashref); }
2164         if (( $onepackage->{'language'} ) && ( $onepackage->{'language'} ne "" ) && ( $onepackage->{'language'} ne "en-US" )) { include_languageinfos_into_pkginfo($changefile, $filename, $languagestringref, $onepackage, $variableshashref); }
2165         installer::files::save_file($completefilename, $changefile);
2166
2167         my $prototypefilename = $packagename . ".prototype";
2168         $prototypefilename = $newepmdir . $prototypefilename;
2169         if (! -f $prototypefilename) { installer::exiter::exit_program("ERROR: Did not find prototype file: $prototypefilename", "prepare_packages"); }
2170
2171         my $prototypefile = installer::files::read_file($prototypefilename);
2172         make_prototypefile_relocatable($prototypefile, $relocatablepath);
2173         set_volatilefile_into_prototypefile($prototypefile, $filesref);
2174         my $classesstring = set_tab_into_datafile($prototypefile, $filesref);
2175         if ($classesstring)
2176         {
2177             include_classes_into_pkginfo($changefile, $classesstring);
2178             installer::files::save_file($completefilename, $changefile);
2179         }
2180
2181         if ( $installer::globals::patch ) { add_scripts_into_prototypefile($prototypefile, $prototypefilename, $languagestringref, $staticpath); }
2182
2183         installer::files::save_file($prototypefilename, $prototypefile);
2184         if ( $installer::globals::patch ) { collect_patch_files($prototypefile, $packagename, ""); }
2185
2186         # Adding package names into depend files for Solaris (not supported by epm)
2187         my $dependfilename = $packagename . ".depend";
2188         $dependfilename = $newepmdir . $dependfilename;
2189         if ( -f $dependfilename)
2190         {
2191             my $dependfile = installer::files::read_file($dependfilename);
2192             put_packagenames_into_dependfile($dependfile);
2193             installer::files::save_file($dependfilename, $dependfile);
2194         }
2195     }
2196
2197     return $newepmdir;
2198 }
2199
2200 ############################################################
2201 # Linux requirement for perl is changed by epm from
2202 # /usr/bin/perl to perl .
2203 # Requires: perl
2204 ############################################################
2205
2206 sub check_requirements_in_specfile
2207 {
2208     my ( $specfile ) = @_;
2209
2210     for ( my $i = 0; $i <= $#{$specfile}; $i++ )
2211     {
2212         if (( ${$specfile}[$i] =~ /^\s*Requires/ ) && ( ${$specfile}[$i] =~ /\bperl\b/ ) && ( ! (  ${$specfile}[$i] =~ /\/usr\/bin\/perl\b/ )))
2213         {
2214             my $oldline = ${$specfile}[$i];
2215             ${$specfile}[$i] =~ s/perl/\/usr\/bin\/perl/;
2216             my $newline = ${$specfile}[$i];
2217
2218             $oldline =~ s/\s*$//;
2219             $newline =~ s/\s*$//;
2220             my $infoline = "Spec File: Changing content from \"$oldline\" to \"$newline\".\n";
2221             push(@installer::globals::logfileinfo, $infoline);
2222         }
2223     }
2224 }
2225
2226 ###############################################################################
2227 # Replacement of PRODUCTINSTALLLOCATION and PRODUCTDIRECTORYNAME in the
2228 # epm list file.
2229 # The complete rootpath is stored in $installer::globals::rootpath
2230 # or for each package in $onepackage->{'destpath'}
2231 # The static rootpath is stored in $staticpath
2232 # The relocatable path is stored in $relocatablepath
2233 # PRODUCTINSTALLLOCATION is the relocatable part ("/opt") and
2234 # PRODUCTDIRECTORYNAME the static path ("openofficeorg20").
2235 # In standard epm process:
2236 # No usage of package specific variables like $BASEDIR, because
2237 # 1. These variables would be replaced in epm process
2238 # 2. epm version 3.7 does not support relocatable packages
2239 ###############################################################################
2240
2241 sub resolve_path_in_epm_list_before_packaging
2242 {
2243     my ($listfile, $listfilename, $variable, $path) = @_;
2244
2245     installer::logger::include_header_into_logfile("Replacing variables in epm list file:");
2246
2247     $path =~ s/\/\s*$//;
2248     replace_variables_in_shellscripts($listfile, $listfilename, $variable, $path);
2249
2250 }
2251
2252 #################################################################
2253 # Determining the rpm version. Beginning with rpm version 4.0
2254 # the tool to create RPMs is "rpmbuild" and no longer "rpm"
2255 #################################################################
2256
2257 sub determine_rpm_version
2258 {
2259     my $rpmversion = 0;
2260     my $rpmout = "";
2261     my $systemcall = "";
2262
2263     # my $systemcall = "rpm --version |";
2264     # "rpm --version" has problems since LD_LIBRARY_PATH was removed. Therefore the content of $RPM has to be called.
2265     # "rpm --version" and "rpmbuild --version" have the same output. Therefore $RPM can be used. Its value
2266     # is saved in $installer::globals::rpm
2267
2268     if ( $installer::globals::rpm ne "" )
2269     {
2270         $systemcall = "$installer::globals::rpm --version |";
2271     }
2272     else
2273     {
2274         $systemcall = "rpm --version |";
2275     }
2276
2277     open (RPM, "$systemcall");
2278     $rpmout = <RPM>;
2279     close (RPM);
2280
2281     if ( $rpmout ne "" )
2282     {
2283         $rpmout =~ s/\s*$//g;
2284
2285         my $infoline = "Systemcall: $systemcall\n";
2286         push( @installer::globals::logfileinfo, $infoline);
2287
2288         if ( $rpmout eq "" ) { $infoline = "ERROR: Could not find file \"rpm\" !\n"; }
2289         else { $infoline = "Success: rpm version: $rpmout\n"; }
2290
2291         push( @installer::globals::logfileinfo, $infoline);
2292
2293         if ( $rpmout =~ /(\d+)\.(\d+)\.(\d+)/ ) { $rpmversion = $1; }
2294         elsif ( $rpmout =~ /(\d+)\.(\d+)/ ) { $rpmversion = $1; }
2295         elsif ( $rpmout =~ /(\d+)/ ) { $rpmversion = $1; }
2296         else { installer::exiter::exit_program("ERROR: Unknown format: $rpmout ! Expected: \"a.b.c\", or \"a.b\", or \"a\"", "determine_rpm_version"); }
2297     }
2298
2299     return $rpmversion;
2300 }
2301
2302 #################################################
2303 # Systemcall to start the packaging process
2304 #################################################
2305
2306 sub create_packages_without_epm
2307 {
2308     my ($epmdir, $packagename, $includepatharrayref, $allvariables, $languagestringref) = @_;
2309
2310     # Solaris: pkgmk -o -f solaris-2.8-sparc/SUNWso8m34.prototype -d solaris-2.8-sparc
2311     # Solaris: pkgtrans solaris-2.8-sparc SUNWso8m34.pkg SUNWso8m34
2312     # Solaris: tar -cf - SUNWso8m34 | gzip > SUNWso8m34.tar.gz
2313
2314     if ( $installer::globals::issolarispkgbuild )
2315     {
2316         my $prototypefile = $epmdir . $packagename . ".prototype";
2317         if (! -f $prototypefile) { installer::exiter::exit_program("ERROR: Did not find file: $prototypefile", "create_packages_without_epm"); }
2318
2319         my $destinationdir = $prototypefile;
2320         installer::pathanalyzer::get_path_from_fullqualifiedname(\$destinationdir);
2321         $destinationdir =~ s/\/\s*$//;  # removing ending slashes
2322
2323         # my $systemcall = "pkgmk -o -f $prototypefile -d $destinationdir \> /dev/null 2\>\&1";
2324         my $systemcall = "pkgmk -l 1073741824 -o -f $prototypefile -d $destinationdir 2\>\&1 |";
2325         installer::logger::print_message( "... $systemcall ...\n" );
2326
2327         my $maxpkgmkcalls = 3;
2328
2329         for ( my $i = 1; $i <= $maxpkgmkcalls; $i++ )
2330         {
2331             my @pkgmkoutput = ();
2332
2333             open (PKGMK, "$systemcall");
2334             while (<PKGMK>) {push(@pkgmkoutput, $_); }
2335             close (PKGMK);
2336
2337             my $returnvalue = $?;       # $? contains the return value of the systemcall
2338
2339             my $infoline = "Systemcall (Try $i): $systemcall\n";
2340             push( @installer::globals::logfileinfo, $infoline);
2341
2342             for ( my $j = 0; $j <= $#pkgmkoutput; $j++ )
2343             {
2344                 if ( $i < $maxpkgmkcalls ) { $pkgmkoutput[$j] =~ s/\bERROR\b/PROBLEM/ig; }
2345                 push( @installer::globals::logfileinfo, "$pkgmkoutput[$j]");
2346             }
2347
2348             if ($returnvalue)
2349             {
2350                 $infoline = "Try $i : Could not execute \"$systemcall\"!\n";
2351                 push( @installer::globals::logfileinfo, $infoline);
2352                 if ( $i == $maxpkgmkcalls ) { installer::exiter::exit_program("ERROR: \"$systemcall\"!", "create_packages_without_epm"); }
2353             }
2354             else
2355             {
2356                 installer::logger::print_message( "Success (Try $i): \"$systemcall\"\n" );
2357                 $infoline = "Success: Executed \"$systemcall\" successfully!\n";
2358                 push( @installer::globals::logfileinfo, $infoline);
2359                 last;
2360             }
2361         }
2362
2363         # It might be necessary to save uncompressed Solaris packages
2364
2365         if ( $allvariables->{'JDSBUILD'} )
2366         {
2367             if ( ! $installer::globals::jds_language_controlled )
2368             {
2369                 my $correct_language = installer::worker::check_jds_language($allvariables, $languagestringref);
2370                 $installer::globals::correct_jds_language = $correct_language;
2371                 $installer::globals::jds_language_controlled = 1;
2372             }
2373
2374             if ( $installer::globals::correct_jds_language )
2375             {
2376                 if ( $installer::globals::saved_packages_path eq "" )
2377                 {
2378                     $packagestempdir = installer::systemactions::create_directories("jds", $languagestringref);
2379                     $installer::globals::saved_packages_path = $packagestempdir;
2380                     push(@installer::globals::jdsremovedirs, $packagestempdir);
2381                 }
2382
2383                 $systemcall = "cd $destinationdir; cp -p -R $packagename $installer::globals::saved_packages_path;";
2384                  make_systemcall($systemcall);
2385                 installer::logger::print_message( "... $systemcall ...\n" );
2386
2387                 # Setting unix rights to "775" for all created directories inside the package,
2388                 # that is saved in temp directory
2389
2390                 $systemcall = "cd $packagestempdir; find $packagename -type d -exec chmod 775 \{\} \\\;";
2391                 installer::logger::print_message( "... $systemcall ...\n" );
2392
2393                 $returnvalue = system($systemcall);
2394
2395                 $infoline = "Systemcall: $systemcall\n";
2396                 push( @installer::globals::logfileinfo, $infoline);
2397
2398                 if ($returnvalue)
2399                 {
2400                     $infoline = "ERROR: Could not execute \"$systemcall\"!\n";
2401                     push( @installer::globals::logfileinfo, $infoline);
2402                 }
2403                 else
2404                 {
2405                     $infoline = "Success: Executed \"$systemcall\" successfully!\n";
2406                     push( @installer::globals::logfileinfo, $infoline);
2407                 }
2408             }
2409         }
2410
2411         # compressing packages
2412
2413         if ( ! $installer::globals::solarisdontcompress )
2414         {
2415             my $faspac = "faspac-so.sh";
2416
2417             my $compressorref = installer::scriptitems::get_sourcepath_from_filename_and_includepath(\$faspac, $includepatharrayref, 0);
2418             if ($$compressorref ne "")
2419             {
2420                 # Saving original pkginfo, to set time stamp later
2421                 my $pkginfoorig = "$destinationdir/$packagename/pkginfo";
2422                 my $pkginfotmp = "$destinationdir/$packagename" . ".pkginfo.tmp";
2423                 $systemcall = "cp -p $pkginfoorig $pkginfotmp";
2424                  make_systemcall($systemcall);
2425
2426                 $faspac = $$compressorref;
2427                 $infoline = "Found compressor: $faspac\n";
2428                 push( @installer::globals::logfileinfo, $infoline);
2429
2430                 installer::logger::print_message( "... $faspac ...\n" );
2431                 installer::logger::include_timestamp_into_logfile("Starting $faspac");
2432
2433                  $systemcall = "/bin/sh $faspac -a -q -d $destinationdir $packagename";  # $faspac has to be the absolute path!
2434                  make_systemcall($systemcall);
2435
2436                  # Setting time stamp for pkginfo, because faspac-so.sh changed the pkginfo file,
2437                  # updated the size and checksum, but not the time stamp.
2438                  $systemcall = "touch -r $pkginfotmp $pkginfoorig";
2439                  make_systemcall($systemcall);
2440                 if ( -f $pkginfotmp ) { unlink($pkginfotmp); }
2441
2442                 installer::logger::include_timestamp_into_logfile("End of $faspac");
2443             }
2444             else
2445             {
2446                 $infoline = "Not found: $faspac\n";
2447                 push( @installer::globals::logfileinfo, $infoline);
2448             }
2449         }
2450
2451         # Setting unix rights to "775" for all created directories inside the package
2452
2453         $systemcall = "cd $destinationdir; find $packagename -type d -exec chmod 775 \{\} \\\;";
2454         installer::logger::print_message( "... $systemcall ...\n" );
2455
2456         $returnvalue = system($systemcall);
2457
2458         $infoline = "Systemcall: $systemcall\n";
2459         push( @installer::globals::logfileinfo, $infoline);
2460
2461         if ($returnvalue)
2462         {
2463             $infoline = "ERROR: Could not execute \"$systemcall\"!\n";
2464             push( @installer::globals::logfileinfo, $infoline);
2465         }
2466         else
2467         {
2468             $infoline = "Success: Executed \"$systemcall\" successfully!\n";
2469             push( @installer::globals::logfileinfo, $infoline);
2470         }
2471
2472         ######################
2473         # making pkg files
2474         ######################
2475
2476         # my $streamname = $packagename . ".pkg";
2477         # $systemcall = "pkgtrans $destinationdir $streamname $packagename";
2478         # print "... $systemcall ...\n";
2479
2480         # $returnvalue = system($systemcall);
2481
2482         # $infoline = "Systemcall: $systemcall\n";
2483         # push( @installer::globals::logfileinfo, $infoline);
2484
2485         # if ($returnvalue)
2486         # {
2487         #       $infoline = "ERROR: Could not execute \"$systemcall\"!\n";
2488         #       push( @installer::globals::logfileinfo, $infoline);
2489         # }
2490         # else
2491         # {
2492         #       $infoline = "Success: Executed \"$systemcall\" successfully!\n";
2493         #       push( @installer::globals::logfileinfo, $infoline);
2494         # }
2495
2496         #########################
2497         # making tar.gz files
2498         #########################
2499
2500         # my $targzname = $packagename . ".tar.gz";
2501         # $systemcall = "cd $destinationdir; tar -cf - $packagename | gzip > $targzname";
2502         # print "... $systemcall ...\n";
2503
2504         # $returnvalue = system($systemcall);
2505
2506         # $infoline = "Systemcall: $systemcall\n";
2507         # push( @installer::globals::logfileinfo, $infoline);
2508
2509         # if ($returnvalue)
2510         # {
2511         #       $infoline = "ERROR: Could not execute \"$systemcall\"!\n";
2512         #       push( @installer::globals::logfileinfo, $infoline);
2513         # }
2514         # else
2515         # {
2516         #       $infoline = "Success: Executed \"$systemcall\" successfully!\n";
2517         #       push( @installer::globals::logfileinfo, $infoline);
2518         # }
2519     }
2520
2521     # Linux: rpm -bb so8m35.spec        ( -> dependency check abklemmen? )
2522
2523     if ( $installer::globals::islinuxrpmbuild )
2524     {
2525         my $specfilename = $epmdir . $packagename . ".spec";
2526         if (! -f $specfilename) { installer::exiter::exit_program("ERROR: Did not find file: $specfilename", "create_packages_without_epm"); }
2527
2528         # my $rpmcommand = "rpm";
2529         my $rpmcommand = $installer::globals::rpm;
2530         my $rpmversion = determine_rpm_version();
2531
2532         # if ( $rpmversion >= 4 ) { $rpmcommand = "rpmbuild"; }
2533
2534         # saving globally for later usage
2535         $installer::globals::rpmcommand = $rpmcommand;
2536         $installer::globals::rpmquerycommand = "rpm";
2537
2538         my $target = "";
2539         if ( $installer::globals::compiler =~ /unxlngi/) { $target = "i586"; }
2540         elsif ( $installer::globals::compiler =~ /unxlng/) {$target = (POSIX::uname())[4]; }
2541
2542         # rpm 4.6 ignores buildroot tag in spec file
2543
2544         my $buildrootstring = "";
2545
2546         if ( $rpmversion >= 4 )
2547         {
2548             my $dir = getcwd;
2549             my $buildroot = $dir . "/" . $epmdir . "buildroot/";
2550             $buildrootstring = "--buildroot=$buildroot";
2551         }
2552
2553         my $systemcall = "$rpmcommand -bb --define \"_unpackaged_files_terminate_build  0\" $specfilename --target $target $buildrootstring 2\>\&1 |";
2554
2555         installer::logger::print_message( "... $systemcall ...\n" );
2556
2557         my $maxrpmcalls = 3;
2558         my $rpm_failed = 0;
2559
2560         for ( my $i = 1; $i <= $maxrpmcalls; $i++ )
2561         {
2562             my @rpmoutput = ();
2563
2564             open (RPM, "$systemcall");
2565             while (<RPM>) {push(@rpmoutput, $_); }
2566             close (RPM);
2567
2568             my $returnvalue = $?;       # $? contains the return value of the systemcall
2569
2570             my $infoline = "Systemcall (Try $i): $systemcall\n";
2571             push( @installer::globals::logfileinfo, $infoline);
2572
2573             for ( my $j = 0; $j <= $#rpmoutput; $j++ )
2574             {
2575                 # if ( $i < $maxrpmcalls ) { $rpmoutput[$j] =~ s/\bERROR\b/PROBLEM/ig; }
2576                 $rpmoutput[$j] =~ s/\bERROR\b/PROBLEM/ig;
2577                 push( @installer::globals::logfileinfo, "$rpmoutput[$j]");
2578             }
2579
2580             if ($returnvalue)
2581             {
2582                 $infoline = "Try $i : Could not execute \"$systemcall\"!\n";
2583                 push( @installer::globals::logfileinfo, $infoline);
2584                 $rpm_failed = 1;
2585             }
2586             else
2587             {
2588                 installer::logger::print_message( "Success (Try $i): \"$systemcall\"\n" );
2589                 $infoline = "Success: Executed \"$systemcall\" successfully!\n";
2590                 push( @installer::globals::logfileinfo, $infoline);
2591                 $rpm_failed = 0;
2592                 last;
2593             }
2594         }
2595
2596         if ( $rpm_failed )
2597         {
2598             # Because of the problems with LD_LIBARY_PATH, a direct call of local "rpm" or "rpmbuild" might be successful
2599             my $rpmprog = "";
2600             if ( -f "/usr/bin/rpmbuild" ) { $rpmprog = "/usr/bin/rpmbuild"; }
2601             elsif ( -f "/usr/bin/rpm" ) { $rpmprog = "/usr/bin/rpm"; }
2602
2603             if ( $rpmprog ne "" )
2604             {
2605                 installer::logger::print_message( "... $rpmprog ...\n" );
2606
2607                 my $helpersystemcall = "$rpmprog -bb $specfilename --target $target $buildrootstring 2\>\&1 |";
2608
2609                 my @helperrpmoutput = ();
2610
2611                 open (RPM, "$helpersystemcall");
2612                 while (<RPM>) {push(@helperrpmoutput, $_); }
2613                 close (RPM);
2614
2615                 my $helperreturnvalue = $?;     # $? contains the return value of the systemcall
2616
2617                 $infoline = "\nLast try: Using $rpmprog directly (problem with LD_LIBARY_PATH)\n";
2618                 push( @installer::globals::logfileinfo, $infoline);
2619
2620                 $infoline = "\nSystemcall: $helpersystemcall\n";
2621                 push( @installer::globals::logfileinfo, $infoline);
2622
2623                 for ( my $j = 0; $j <= $#helperrpmoutput; $j++ ) { push( @installer::globals::logfileinfo, "$helperrpmoutput[$j]"); }
2624
2625                 if ($helperreturnvalue)
2626                 {
2627                     $infoline = "Could not execute \"$helpersystemcall\"!\n";
2628                     push( @installer::globals::logfileinfo, $infoline);
2629                 }
2630                 else
2631                 {
2632                     installer::logger::print_message( "Success: \"$helpersystemcall\"\n" );
2633                     $infoline = "Success: Executed \"$helpersystemcall\" successfully!\n";
2634                     push( @installer::globals::logfileinfo, $infoline);
2635                     $rpm_failed = 0;
2636                 }
2637             }
2638
2639             # Now it is really time to exit this packaging process, if the error still occurs
2640             if ( $rpm_failed ) { installer::exiter::exit_program("ERROR: \"$systemcall\"!", "create_packages_without_epm"); }
2641         }
2642     }
2643 }
2644
2645 #################################################
2646 # Removing all temporary files created by epm
2647 #################################################
2648
2649 sub remove_temporary_epm_files
2650 {
2651     my ($epmdir, $loggingdir, $packagename) = @_;
2652
2653     # saving the files into the loggingdir
2654
2655     if ( $installer::globals::issolarispkgbuild )
2656     {
2657         my @extensions = ();
2658         push(@extensions, ".pkginfo");
2659         push(@extensions, ".prototype");
2660         push(@extensions, ".postinstall");
2661         push(@extensions, ".postremove");
2662         push(@extensions, ".preinstall");
2663         push(@extensions, ".preremove");
2664         push(@extensions, ".depend");
2665
2666         for ( my $i = 0; $i <= $#extensions; $i++ )
2667         {
2668             my $removefile = $epmdir . $packagename . $extensions[$i];
2669             my $destfile = $loggingdir . $packagename . $extensions[$i] . ".log";
2670
2671             if (! -f $removefile) { next; }
2672
2673             my $systemcall = "mv -f $removefile $destfile";
2674             system($systemcall);         # ignoring the return value
2675             $infoline = "Systemcall: $systemcall\n";
2676             push( @installer::globals::logfileinfo, $infoline);
2677         }
2678
2679         # removing the package
2680
2681 #               my $removedir = $epmdir . $packagename;
2682 #
2683 #               my $systemcall = "rm -rf $removedir";
2684 #
2685 #               print "... $systemcall ...\n";
2686 #
2687 #               my $returnvalue = system($systemcall);
2688 #
2689 #               my $infoline = "Systemcall: $systemcall\n";
2690 #               push( @installer::globals::logfileinfo, $infoline);
2691 #
2692 #               if ($returnvalue)
2693 #               {
2694 #                       $infoline = "ERROR: Could not execute \"$systemcall\"!\n";
2695 #                       push( @installer::globals::logfileinfo, $infoline);
2696 #               }
2697 #               else
2698 #               {
2699 #                       $infoline = "Success: Executed \"$systemcall\" successfully!\n";
2700 #                       push( @installer::globals::logfileinfo, $infoline);
2701 #               }
2702     }
2703
2704     if ( $installer::globals::islinuxrpmbuild )
2705     {
2706         my $removefile = $epmdir . $packagename . ".spec";
2707         my $destfile = $loggingdir . $packagename . ".spec.log";
2708
2709          # if (! -f $removefile) { next; }
2710
2711         my $systemcall = "mv -f $removefile $destfile";
2712         system($systemcall);     # ignoring the return value
2713         $infoline = "Systemcall: $systemcall\n";
2714         push( @installer::globals::logfileinfo, $infoline);
2715
2716         # removing the directory "buildroot"
2717
2718         my $removedir = $epmdir . "buildroot";
2719
2720         $systemcall = "rm -rf $removedir";
2721
2722         installer::logger::print_message( "... $systemcall ...\n" );
2723
2724         my $returnvalue = system($systemcall);
2725
2726         my $infoline = "Systemcall: $systemcall\n";
2727         push( @installer::globals::logfileinfo, $infoline);
2728
2729         if ($returnvalue)
2730         {
2731             $infoline = "ERROR: Could not execute \"$systemcall\"!\n";
2732             push( @installer::globals::logfileinfo, $infoline);
2733         }
2734         else
2735         {
2736             $infoline = "Success: Executed \"$systemcall\" successfully!\n";
2737             push( @installer::globals::logfileinfo, $infoline);
2738         }
2739     }
2740 }
2741
2742 ######################################################
2743 # Making the systemcall
2744 ######################################################
2745
2746 sub make_systemcall
2747 {
2748     my ($systemcall) = @_;
2749
2750     my $returnvalue = system($systemcall);
2751
2752     my $infoline = "Systemcall: $systemcall\n";
2753     push( @installer::globals::logfileinfo, $infoline);
2754
2755     if ($returnvalue)
2756     {
2757         $infoline = "ERROR: Could not execute \"$systemcall\"!\n";
2758         push( @installer::globals::logfileinfo, $infoline);
2759     }
2760     else
2761     {
2762         $infoline = "Success: Executed \"$systemcall\" successfully!\n";
2763         push( @installer::globals::logfileinfo, $infoline);
2764     }
2765 }
2766
2767 ###########################################################
2768 # Creating a better directory structure in the solver.
2769 ###########################################################
2770
2771 sub create_new_directory_structure
2772 {
2773     my ($newepmdir) = @_;
2774
2775     my $newdir = $installer::globals::epmoutpath;
2776
2777     if ( $installer::globals::islinuxrpmbuild )
2778     {
2779         my $rpmdir;
2780                 my $machine = "";
2781         if ( $installer::globals::compiler =~ /unxlngi/) {
2782                     $rpmdir = "$installer::globals::epmoutpath/RPMS/i586";
2783                 }
2784         elsif ( $installer::globals::compiler =~ /unxlng/) {
2785                     $machine = (POSIX::uname())[4];
2786                     $rpmdir = "$installer::globals::epmoutpath/RPMS/$machine";
2787                 }
2788                 else { installer::exiter::exit_program("ERROR: rpmdir undefined !", "create_new_directory_structure"); }
2789
2790         my $systemcall = "mv $rpmdir/* $newdir";        # moving the rpms into the directory "RPMS"
2791
2792         my $returnvalue = system($systemcall);
2793
2794         my $infoline = "Systemcall: $systemcall\n";
2795         push( @installer::globals::logfileinfo, $infoline);
2796
2797         if ($returnvalue)
2798         {
2799             $infoline = "ERROR: Could not move content of \"$rpmdir\" to \"$newdir\"!\n";
2800             push( @installer::globals::logfileinfo, $infoline);
2801         }
2802         else
2803         {
2804             $infoline = "Success: Moved content of \"$rpmdir\" to \"$newdir\"!\n";
2805             push( @installer::globals::logfileinfo, $infoline);
2806         }
2807
2808         # and removing the empty directory
2809
2810         if ( $machine ne "" )
2811         {
2812             installer::systemactions::remove_empty_directory("$installer::globals::epmoutpath/RPMS/$machine");
2813         }
2814         installer::systemactions::remove_empty_directory("$installer::globals::epmoutpath/RPMS/x86_64");
2815         installer::systemactions::remove_empty_directory("$installer::globals::epmoutpath/RPMS/i586");
2816         installer::systemactions::remove_empty_directory("$installer::globals::epmoutpath/RPMS/i386");
2817         installer::systemactions::remove_empty_directory("$installer::globals::epmoutpath/RPMS");
2818
2819     }
2820
2821     # Setting unix rights to "775" for $newdir ("RPMS" or "packages")
2822
2823     my $localcall = "chmod 775 $newdir \>\/dev\/null 2\>\&1";
2824     my $callreturnvalue = system($localcall);
2825
2826     my $callinfoline = "Systemcall: $localcall\n";
2827     push( @installer::globals::logfileinfo, $callinfoline);
2828
2829     if ($callreturnvalue)
2830     {
2831         $callinfoline = "ERROR: Could not execute \"$localcall\"!\n";
2832         push( @installer::globals::logfileinfo, $callinfoline);
2833     }
2834     else
2835     {
2836         $callinfoline = "Success: Executed \"$localcall\" successfully!\n";
2837         push( @installer::globals::logfileinfo, $callinfoline);
2838     }
2839 }
2840
2841 ######################################################
2842 # Collect modules with product specific styles.
2843 ######################################################
2844
2845 sub collect_modules_with_style
2846 {
2847     my ($style, $modulesarrayref) = @_;
2848
2849     my @allmodules = ();
2850
2851     for ( my $i = 0; $i <= $#{$modulesarrayref}; $i++ )
2852     {
2853         my $onemodule = ${$modulesarrayref}[$i];
2854         my $styles = "";
2855         if ( $onemodule->{'Styles'} ) { $styles = $onemodule->{'Styles'}; }
2856         if ( $styles =~ /\b\Q$style\E\b/ )
2857         {
2858             push(@allmodules, $onemodule);
2859         }
2860     }
2861
2862     return \@allmodules;
2863 }
2864
2865 ######################################################
2866 # Remove modules without packagecontent.
2867 ######################################################
2868
2869 sub remove_modules_without_package
2870 {
2871     my ($allmodules) = @_;
2872
2873     my @allmodules = ();
2874
2875     for ( my $i = 0; $i <= $#{$allmodules}; $i++ )
2876     {
2877         my $onemodule = ${$allmodules}[$i];
2878         my $packagename = "";
2879         if ( $onemodule->{'PackageName'} ) { $packagename = $onemodule->{'PackageName'}; }
2880         if ( $packagename ne "" )
2881         {
2882             push(@allmodules, $onemodule);
2883         }
2884     }
2885
2886     return \@allmodules;
2887 }
2888
2889 ######################################################
2890 # Unpacking tar.gz file and setting new packagename.
2891 ######################################################
2892
2893 sub unpack_tar_gz_file
2894 {
2895     my ($packagename, $destdir) = @_;
2896
2897     my $newpackagename = "";
2898
2899     if ( $packagename =~ /\.tar\.gz\s*$/ )
2900     {
2901         # Collecting all packages in directory "packages"
2902         my $oldcontent = installer::systemactions::read_directory($destdir);
2903
2904         # unpacking gunzip
2905         my $systemcall = "cd $destdir; cat $packagename | gunzip | tar -xf -";
2906         make_systemcall($systemcall);
2907
2908         # deleting the tar.gz files
2909         $systemcall = "cd $destdir; rm -f $packagename";
2910         make_systemcall($systemcall);
2911
2912         # Finding new content -> that is the package name
2913         my ($newcontent, $allcontent ) = installer::systemactions::find_new_content_in_directory($destdir, $oldcontent);
2914         $newpackagename = ${$newcontent}[0];
2915         installer::pathanalyzer::make_absolute_filename_to_relative_filename(\$newpackagename);
2916     }
2917
2918     if ( $newpackagename ne "" ) { $packagename = $newpackagename; }
2919
2920     return $packagename;
2921 }
2922
2923 ######################################################
2924 # Copying files of child projects.
2925 ######################################################
2926
2927 sub copy_childproject_files
2928 {
2929     my ($allmodules, $sopackpath, $destdir, $modulesarrayref, $allvariables, $subdir, $includepatharrayref, $use_sopackpath) = @_;
2930
2931     for ( my $i = 0; $i <= $#{$allmodules}; $i++ )
2932     {
2933         my $localdestdir = $destdir;
2934         my $onemodule = ${$allmodules}[$i];
2935         my $packagename = $onemodule->{'PackageName'};
2936         my $sourcefile = "";
2937         if ( $use_sopackpath )
2938         {
2939             $sourcefile = $sopackpath . $installer::globals::separator . $installer::globals::compiler . $installer::globals::separator . $subdir . $installer::globals::separator . $packagename;
2940         }
2941         else
2942         {
2943             my $sourcepathref = installer::scriptitems::get_sourcepath_from_filename_and_includepath(\$packagename, $includepatharrayref, 1);
2944             $sourcefile = $$sourcepathref;
2945         }
2946
2947         if ( ! -f $sourcefile ) { installer::exiter::exit_program("ERROR: File not found: $sourcefile ($packagename) !", "copy_childproject_files"); }
2948         if ( $onemodule->{'Subdir'} )
2949         {
2950             $localdestdir = $localdestdir . $installer::globals::separator . $onemodule->{'Subdir'};
2951             if ( ! -d $localdestdir ) { installer::systemactions::create_directory($localdestdir); }
2952         }
2953         installer::systemactions::copy_one_file($sourcefile, $localdestdir);
2954         # Solaris: unpacking tar.gz files and setting new packagename
2955         if ( $installer::globals::issolarispkgbuild ) { $packagename = unpack_tar_gz_file($packagename, $localdestdir); }
2956
2957         if (( $installer::globals::isxpdplatform ) && ( $allvariables->{'XPDINSTALLER'} ))
2958         {
2959             installer::xpdinstaller::create_xpd_file_for_childproject($onemodule, $localdestdir, $packagename, $allvariableshashref, $modulesarrayref);
2960         }
2961     }
2962
2963 }
2964
2965 ######################################################
2966 # Copying files for system integration.
2967 ######################################################
2968
2969 sub copy_and_unpack_tar_gz_files
2970 {
2971     my ($sourcefile, $destdir) = @_;
2972
2973     my $systemcall = "cd $destdir; cat $sourcefile | gunzip | tar -xf -";
2974     make_systemcall($systemcall);
2975 }
2976
2977 ######################################################
2978 # Including child packages into the
2979 # installation set.
2980 ######################################################
2981
2982 sub put_childprojects_into_installset
2983 {
2984     my ($newdir, $allvariables, $modulesarrayref, $includepatharrayref) = @_;
2985
2986     my $infoline = "";
2987
2988     my $sopackpath = "";
2989     if ( $ENV{'SO_PACK'} ) { $sopackpath  = $ENV{'SO_PACK'}; }
2990     else { installer::exiter::exit_program("ERROR: Environment variable SO_PACK not set!", "put_childprojects_into_installset"); }
2991
2992     my $destdir = "$newdir";
2993
2994     # adding Java
2995
2996     my $sourcefile = "";
2997
2998     # Finding the modules defined in scp (with flag JAVAMODULE, ADAMODULE, ...)
2999     # Getting name of package from scp-Module
3000     # Copy file into installation set
3001     # Create xpd file and put it into xpd directory
3002     # xpd file has to be created completely from module and package itself (-> no packagelist!)
3003
3004     if ( $allvariables->{'JAVAPRODUCT'} )
3005     {
3006         # Collect all modules with flag "JAVAMODULE"
3007         my $allmodules = collect_modules_with_style("JAVAMODULE", $modulesarrayref);
3008         $allmodules = remove_modules_without_package($allmodules);
3009         copy_childproject_files($allmodules, $sopackpath, $destdir, $modulesarrayref, $allvariables, "jre", $includepatharrayref, 1);
3010     }
3011
3012     # Adding additional required packages (freetype).
3013     # This package names are stored in global array @installer::globals::requiredpackages
3014
3015     if ( $allvariables->{'ADDREQUIREDPACKAGES'} )
3016     {
3017         # Collect all modules with flag "REQUIREDPACKAGEMODULE"
3018         my $allmodules = collect_modules_with_style("REQUIREDPACKAGEMODULE", $modulesarrayref);
3019         $allmodules = remove_modules_without_package($allmodules);
3020         copy_childproject_files($allmodules, $sopackpath, $destdir, $modulesarrayref, $allvariables, "requiredpackages", $includepatharrayref, 1);
3021     }
3022
3023     # Collect all modules with flag "USERLANDMODULE"
3024     my $alluserlandmodules = collect_modules_with_style("USERLANDMODULE", $modulesarrayref);
3025     $alluserlandmodules = remove_modules_without_package($alluserlandmodules);
3026     copy_childproject_files($alluserlandmodules, $sopackpath, $destdir, $modulesarrayref, $allvariables, "", $includepatharrayref, 0);
3027
3028 }
3029
3030 ######################################################
3031 # Checking whether the new content is a directory and
3032 # not a package. If it is a directory, the complete
3033 # content of the directory has to be added to the
3034 # array newcontent.
3035 ######################################################
3036
3037 sub control_subdirectories
3038 {
3039     my ($content, $subdir) = @_;
3040
3041     my @newcontent = ();
3042
3043     for ( my $i = 0; $i <= $#{$content}; $i++ )
3044     {
3045         if ( -d ${$content}[$i] )
3046         {
3047             $subdir = ${$content}[$i];
3048             installer::pathanalyzer::make_absolute_filename_to_relative_filename(\$subdir);
3049             my $allpackages = installer::systemactions::read_directory(${$content}[$i]);
3050             for ( my $j = 0; $j <= $#{$allpackages}; $j++ )
3051             {
3052                 # Currently only Linux rpm is supported, debian packages cannot be installed via xpd installer
3053                 if (( $installer::globals::islinuxbuild ) && ( ! ( ${$allpackages}[$j] =~ /\.rpm\s*$/ ))) { next; }
3054                 push(@newcontent, ${$allpackages}[$j]);
3055             }
3056         }
3057         else
3058         {
3059             push(@newcontent, ${$content}[$i]);
3060         }
3061     }
3062
3063     return (\@newcontent, $subdir);
3064 }
3065
3066 ######################################################
3067 # Including the system integration files into the
3068 # installation sets.
3069 ######################################################
3070
3071 sub put_systemintegration_into_installset
3072 {
3073     my ($newdir, $includepatharrayref, $allvariables, $modulesarrayref) = @_;
3074
3075     my $destdir = $newdir;
3076
3077     # adding System integration files
3078
3079     my $sourcefile = "";
3080
3081     # Finding the modules defined in scp (with flag SYSTEMMODULE)
3082     # Getting name of package from scp-Module
3083     # Search package in list off all include files
3084     # Copy file into installation set and unpack it (always tar.gz)
3085     # Create xpd file and put it into xpd directory
3086     # tar.gz can contain a different number of packages -> automatically create hidden sub modules
3087     # xpd file has to be created completely from module and package itself (-> no packagelist!)
3088
3089     # Collect all modules with flag "SYSTEMMODULE"
3090     my $allmodules = collect_modules_with_style("SYSTEMMODULE", $modulesarrayref);
3091     $allmodules = remove_modules_without_package($allmodules);
3092
3093     for ( my $i = 0; $i <= $#{$allmodules}; $i++ )
3094     {
3095         my $onemodule = ${$allmodules}[$i];
3096         my $packagetarfilename = $onemodule->{'PackageName'};
3097
3098         my $infoline = "Including into installation set: $packagetarfilename\n";
3099         push( @installer::globals::logfileinfo, $infoline);
3100
3101         my $sourcepathref = installer::scriptitems::get_sourcepath_from_filename_and_includepath(\$packagetarfilename, $includepatharrayref, 1);
3102         if ( $$sourcepathref eq "" ) { installer::exiter::exit_program("ERROR: Source path not found for $packagetarfilename!", "copy_systemintegration_files"); }
3103
3104         # Collecting all packages in directory "packages" or "RPMS"
3105         my $oldcontent = installer::systemactions::read_directory($destdir);
3106
3107         copy_and_unpack_tar_gz_files($$sourcepathref, $destdir);
3108
3109         # Finding new content -> that is the package name
3110         my ($newcontent, $allcontent ) = installer::systemactions::find_new_content_in_directory($destdir, $oldcontent);
3111
3112         # special handling, if new content is a directory
3113         my $subdir = "";
3114         if ( ! $installer::globals::issolarispkgbuild ) { ($newcontent, $subdir) = control_subdirectories($newcontent); }
3115
3116         # Adding license content into Solaris packages
3117         if (( $installer::globals::issolarispkgbuild ) && ( $installer::globals::englishlicenseset ) && ( ! $variableshashref->{'NO_LICENSE_INTO_COPYRIGHT'} )) { installer::worker::add_license_into_systemintegrationpackages($destdir, $newcontent); }
3118
3119         if (( $installer::globals::isxpdplatform ) && ( $allvariables->{'XPDINSTALLER'} ))
3120         {
3121             installer::xpdinstaller::create_xpd_file_for_systemintegration($onemodule, $newcontent, $modulesarrayref, $subdir);
3122         }
3123     }
3124 }
3125
3126 ######################################################
3127 # Analyzing the Unix installation path.
3128 # From the installation path /opt/openofficeorg20
3129 # is the part /opt relocatable and the part
3130 # openofficeorg20 static.
3131 ######################################################
3132
3133 sub analyze_rootpath
3134 {
3135     my ($rootpath, $staticpathref, $relocatablepathref, $allvariables) = @_;
3136
3137     $rootpath =~ s/\/\s*$//;    # removing ending slash
3138
3139     ##############################################################
3140     # Version 1: "/opt" is variable and "openofficeorg20" fixed
3141     ##############################################################
3142
3143     # my $staticpath = $rootpath;
3144     # installer::pathanalyzer::make_absolute_filename_to_relative_filename(\$staticpath);
3145     # $$staticpathref = $staticpath;                            # will be "openofficeorg20"
3146
3147     # my $relocatablepath = $rootpath;
3148     # installer::pathanalyzer::get_path_from_fullqualifiedname(\$relocatablepath);
3149     # $$relocatablepathref = $relocatablepath;          # will be "/opt/"
3150
3151     ##############################################################
3152     # Version 2: "/opt/openofficeorg20" is variable and "" fixed
3153     ##############################################################
3154
3155     # if ( $$relocatablepathref eq "" ) # relocatablepath is not defined in package list
3156     # {
3157     #   $$staticpathref = "";   # will be ""
3158     #   $$relocatablepathref = $rootpath . "\/"; # relocatable path must end with "/", will be "/opt/openofficeorg20/"
3159     #   # setting the static path to the hostname of the directory with style OFFICEDIRECTORY
3160     #   if ( $allvariables->{'SETSTATICPATH'} ) { $$staticpathref = $installer::globals::officedirhostname; }
3161     #
3162     # }
3163     # else      # relocatablepath is defined in package list
3164     # {
3165     #   $$relocatablepathref =~ s/\/\s*$//;                     # removing ending slash
3166     #   $$relocatablepathref = $$relocatablepathref . "\/";     # relocatable path must end with "/"
3167     #   my $staticpath = $rootpath;
3168     #   $staticpath =~ s/\Q$$relocatablepathref\E//;
3169     #   $staticpath =~ s/\/\s*$//;
3170     #   $$staticpathref = $staticpath;
3171     # }
3172
3173     ##############################################################
3174     # Version 3: "/" is variable and "/opt/openofficeorg20" fixed
3175     ##############################################################
3176
3177     $$relocatablepathref = "/";
3178     # Static path has to contain the office directory name. This is replaced in shellscripts.
3179     $$staticpathref = $rootpath . $installer::globals::separator . $installer::globals::officedirhostname;
3180     # For RPM version 3.x it is required, that Prefix is not "/" in spec file. In this case --relocate will not work,
3181     # because RPM 3.x says, that the package is not relocatable. Therefore we have to use Prefix=/opt and for
3182     # all usages of --relocate this path has to be on both sides of the "=": --relocate /opt=<myselectdir>/opt .
3183     if ( $installer::globals::islinuxrpmbuild )
3184     {
3185         $$relocatablepathref = $rootpath . "\/"; # relocatable path must end with "/", will be "/opt/"
3186         $$staticpathref = $installer::globals::officedirhostname; # to be used as replacement in shell scripts
3187     }
3188
3189     if ( $installer::globals::islinuxdebbuild )
3190     {
3191         $$relocatablepathref = "";
3192         # $$staticpathref is already "/opt/openoffice.org3", no additional $rootpath required.
3193         # $$staticpathref = $rootpath . $installer::globals::separator . $$staticpathref;  # no relocatibility for Debian
3194     }
3195
3196 }
3197
3198 ######################################################
3199 # Including license and readme into
3200 # Unix installation sets.
3201 ######################################################
3202
3203 sub put_installsetfiles_into_installset
3204 {
3205     my ($destdir) = @_;
3206
3207     # All files for the installation set are saved in the global
3208     # array @installer::globals::installsetfiles
3209
3210     for ( my $i = 0; $i <= $#installer::globals::installsetfiles; $i++ )
3211     {
3212         my $onefile = $installer::globals::installsetfiles[$i];
3213         my $sourcefile = $onefile->{'sourcepath'};
3214         my $destfile = "";
3215         if ( $installer::globals::addjavainstaller ) { $destfile = $onefile->{'Name'}; }
3216         else { $destfile = $destdir . $installer::globals::separator . $onefile->{'Name'}; }
3217         installer::systemactions::copy_one_file($sourcefile, $destfile);
3218
3219         my $infoline = "Adding to installation set \"$destfile\" from source \"$sourcefile\".\n";
3220         push( @installer::globals::logfileinfo, $infoline);
3221     }
3222 }
3223
3224 ######################################################
3225 # Replacing one variable in patchinfo file
3226 ######################################################
3227
3228 sub replace_one_variable_in_file
3229 {
3230     my ( $file, $placeholder, $value ) = @_;
3231
3232     for ( my $i = 0; $i <= $#{$file}; $i++ )
3233     {
3234         ${$file}[$i] =~ s/$placeholder/$value/g;
3235     }
3236 }
3237
3238 ######################################################
3239 # Setting variables in the patchinfo file
3240 ######################################################
3241
3242 sub set_patchinfo
3243 {
3244     my ( $patchinfofile, $patchid, $allvariables ) = @_;
3245
3246     # Setting: PATCHIDPLACEHOLDER and ARCHITECTUREPLACEHOLDER and PATCHCORRECTSPLACEHOLDER
3247
3248     replace_one_variable_in_file($patchinfofile, "PATCHIDPLACEHOLDER", $patchid);
3249
3250     my $architecture = "";
3251     if ( $installer::globals::issolarissparcbuild ) { $architecture = "sparc"; }
3252     if ( $installer::globals::issolarisx86build ) { $architecture = "i386"; }
3253
3254     replace_one_variable_in_file($patchinfofile, "ARCHITECTUREPLACEHOLDER", $architecture);
3255
3256     if ( ! $allvariables->{'SOLARISPATCHCORRECTS'} ) { installer::exiter::exit_program("ERROR: No setting for PATCH_CORRECTS in zip list file!", "set_patchinfo"); }
3257     my $patchcorrects = $allvariables->{'SOLARISPATCHCORRECTS'};
3258
3259     replace_one_variable_in_file($patchinfofile, "PATCHCORRECTSPLACEHOLDER", $patchcorrects);
3260
3261     # Setting also PATCH_REQUIRES in patch info file, if entry in zip list file exists
3262     my $requiresstring = "";
3263     if ( $installer::globals::issolarissparcbuild ) { $requiresstring = "SOLSPARCPATCHREQUIRES"; }
3264     if ( $installer::globals::issolarisx86build ) { $requiresstring = "SOLIAPATCHREQUIRES"; }
3265
3266     if ( $allvariables->{$requiresstring} )
3267     {
3268         my $newline = "PATCH_REQUIRES=\"" . $allvariables->{$requiresstring} . "\"" . "\n";
3269         push(@{$patchinfofile}, $newline);
3270     }
3271 }
3272
3273 ######################################################
3274 # Finalizing patch: Renaming directory and
3275 # including additional patch files.
3276 ######################################################
3277
3278 sub finalize_patch
3279 {
3280     my ( $newepmdir, $allvariables ) = @_;
3281
3282     my $patchidname = "SOLSPARCPATCHID";
3283     if ( $installer::globals::issolarisx86build ) { $patchidname = "SOLIAPATCHID"; }
3284
3285     if ( ! $allvariables->{$patchidname} ) { installer::exiter::exit_program("ERROR: Variable $patchidname not defined in zip list file!", "finalize_patch"); }
3286     my $patchid = $allvariables->{$patchidname};
3287     installer::systemactions::rename_directory($newepmdir, $patchid);
3288
3289     # Copying all typical patch files into the patch directory
3290     # All patch file names are stored in @installer::globals::solarispatchfiles
3291     # Location of the file is $installer::globals::patchincludepath
3292
3293     my $sourcepath = $installer::globals::patchincludepath;
3294     $sourcepath =~ s/\/\s*$//;
3295
3296     for ( my $i = 0; $i <= $#installer::globals::solarispatchfiles; $i++ )
3297     {
3298         my $sourcefile = $sourcepath . $installer::globals::separator . $installer::globals::solarispatchfiles[$i];
3299         my $destfile = $patchid . $installer::globals::separator . $installer::globals::solarispatchfiles[$i];
3300         installer::systemactions::copy_one_file($sourcefile, $destfile);
3301     }
3302
3303     # And editing the patchinfo file
3304
3305     my $patchinfofilename = $patchid . $installer::globals::separator . "patchinfo";
3306     my $patchinfofile = installer::files::read_file($patchinfofilename);
3307     set_patchinfo($patchinfofile, $patchid, $allvariables);
3308     installer::files::save_file($patchinfofilename, $patchinfofile);
3309 }
3310
3311 ######################################################
3312 # Finalizing Linux patch: Renaming directory and
3313 # including additional patch files.
3314 ######################################################
3315
3316 sub finalize_linux_patch
3317 {
3318     my ( $newepmdir, $allvariables, $includepatharrayref ) = @_;
3319
3320     # Copying the setup into the patch directory
3321     # and including the list of RPMs into it
3322
3323     print "... creating patch setup ...\n";
3324
3325     installer::logger::include_header_into_logfile("Creating Linux patch setup:");
3326
3327     # find and read setup script template
3328
3329     my $scriptfilename = "linuxpatchscript.sh";
3330     my $scriptref = installer::scriptitems::get_sourcepath_from_filename_and_includepath(\$scriptfilename, $includepatharrayref, 0);
3331     if ($$scriptref eq "") { installer::exiter::exit_program("ERROR: Could not find patch script template $scriptfilename!", "finalize_linux_patch"); }
3332     my $scriptfile = installer::files::read_file($$scriptref);
3333
3334     my $infoline = "Found  script file $scriptfilename: $$scriptref \n";
3335     push( @installer::globals::logfileinfo, $infoline);
3336
3337     # Collecting all RPMs in the patch directory
3338
3339     my $fileextension = "rpm";
3340     my $rpmfiles = installer::systemactions::find_file_with_file_extension($fileextension, $newepmdir);
3341     if ( ! ( $#{$rpmfiles} > -1 )) { installer::exiter::exit_program("ERROR: Could not find rpm in directory $newepmdir!", "finalize_linux_patch"); }
3342     for ( my $i = 0; $i <= $#{$rpmfiles}; $i++ ) { installer::pathanalyzer::make_absolute_filename_to_relative_filename(\${$rpmfiles}[$i]); }
3343
3344 #       my $installline = "";
3345 #
3346 #       for ( my $i = 0; $i <= $#{$rpmfiles}; $i++ )
3347 #       {
3348 #               $installline = $installline . "  rpm --prefix \$PRODUCTINSTALLLOCATION -U $newepmdir/${$rpmfiles}[$i]\n";
3349 #       }
3350 #
3351 #       $installline =~ s/\s*$//;
3352 #
3353 #       for ( my $j = 0; $j <= $#{$scriptfile}; $j++ )
3354 #       {
3355 #               ${$scriptfile}[$j] =~ s/INSTALLLINES/$installline/;
3356 #       }
3357
3358     # Searching packagename containing -core01
3359     my $found_package = 0;
3360     my $searchpackagename = "";
3361     for ( my $i = 0; $i <= $#{$rpmfiles}; $i++ )
3362     {
3363         if ( ${$rpmfiles}[$i] =~ /-core01-/ )
3364         {
3365             $searchpackagename = ${$rpmfiles}[$i];
3366             $found_package = 1;
3367             if ( $searchpackagename =~ /^\s*(.*?-core01)-.*/ ) { $searchpackagename = $1; }
3368             last;
3369         }
3370     }
3371
3372     if ( ! $found_package ) { installer::exiter::exit_program("ERROR: No package containing \"-core01\" found in directory \"$newepmdir\"", "finalize_linux_patch"); }
3373
3374     # Replacing the searchpackagename
3375     for ( my $j = 0; $j <= $#{$scriptfile}; $j++ ) { ${$scriptfile}[$j] =~ s/SEARCHPACKAGENAMEPLACEHOLDER/$searchpackagename/; }
3376
3377     # Setting the PRODUCTDIRECTORYNAME to $installer::globals::officedirhostname
3378     for ( my $j = 0; $j <= $#{$scriptfile}; $j++ ) { ${$scriptfile}[$j] =~ s/PRODUCTDIRECTORYNAME/$installer::globals::officedirhostname/; }
3379
3380     # Replacing the productname
3381     my $productname = $allvariables->{'PRODUCTNAME'};
3382     $productname = lc($productname);
3383     $productname =~ s/ /_/g;    # abc office -> abc_office
3384 #       $productname =~ s/\.//g;        # openoffice.org -> openofficeorg
3385
3386     $infoline = "Adding productname $productname into Linux patch script\n";
3387     push( @installer::globals::logfileinfo, $infoline);
3388
3389     for ( my $j = 0; $j <= $#{$scriptfile}; $j++ ) { ${$scriptfile}[$j] =~ s/PRODUCTNAMEPLACEHOLDER/$productname/; }
3390
3391     # Saving the file
3392
3393     my $newscriptfilename = "setup"; # $newepmdir . $installer::globals::separator . "setup";
3394     installer::files::save_file($newscriptfilename, $scriptfile);
3395
3396     $infoline = "Saved Linux patch setup $newscriptfilename \n";
3397     push( @installer::globals::logfileinfo, $infoline);
3398
3399     # Setting unix rights 755
3400     my $localcall = "chmod 775 $newscriptfilename \>\/dev\/null 2\>\&1";
3401     system($localcall);
3402 }
3403
3404 1;