smoketestoo_native/smoketest.pl

   1 :
   2 eval 'exec perl -wS $0 ${1+"$@"}'
   3     if 0;
   4 #*************************************************************************
   5 #
   6 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   7 #
   8 # Copyright 2008 by Sun Microsystems, Inc.
   9 #
  10 # OpenOffice.org - a multi-platform office productivity suite
  11 #
  12 # $RCSfile: smoketest.pl,v $
  13 #
  14 # $Revision: 1.35 $
  15 #
  16 # This file is part of OpenOffice.org.
  17 #
  18 # OpenOffice.org is free software: you can redistribute it and/or modify
  19 # it under the terms of the GNU Lesser General Public License version 3
  20 # only, as published by the Free Software Foundation.
  21 #
  22 # OpenOffice.org is distributed in the hope that it will be useful,
  23 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  24 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25 # GNU Lesser General Public License version 3 for more details
  26 # (a copy is included in the LICENSE file that accompanied this code).
  27 #
  28 # You should have received a copy of the GNU Lesser General Public License
  29 # version 3 along with OpenOffice.org.  If not, see
  30 # <http://www.openoffice.org/license.html>
  31 # for a copy of the LGPLv3 License.
  32 #
  33 #*************************************************************************
  34
  35 #
  36 # smoketest - do the smoketest
  37 #
  38
  39 use lib ("$ENV{SOLARENV}/bin/modules");
  40
  41 use File::Basename;
  42 use File::Path;
  43 use File::Copy;
  44 use Getopt::Long;
  45
  46 ########################
  47 #                       #
  48 #   Globale Variablen   #
  49 #                       #
  50 #########################
  51 $is_debug = 0;           # run without executing commands
  52 $is_command_infos = 0;   # print command details before exec
  53 $is_protocol_test = 0;
  54 $is_remove_on_error = 0;
  55 $is_remove_at_end = 1;
  56 $is_do_deinstall = 0;
  57 $is_without_msiexec = 1;
  58 $is_oo = 1;
  59
  60 $gui = $ENV{GUI};
  61 $temp_path = $ENV{TEMP};
  62 $vcsid = $ENV{VCSID};
  63 $sversion_saved = 0;
  64 $FileURLPrefix = "file:///";
  65 $userinstalldir = "UserInstallation";
  66 $cygwin = "cygwin";
  67 $prefered_lang = "en-US";
  68 $global_instset_mask = "";
  69 $smoketest_install = $ENV{SMOKETESTINSTALLSET};
  70
  71 if (!defined($gui)) {
  72     print "The workstamp is missing. Please use setsolar\n";
  73     exit(1);
  74 }
  75
  76 if (($gui eq "WNT") and ($ENV{USE_SHELL} ne "4nt")) {
  77     $gui = $cygwin;
  78 }
  79
  80 if (!defined($temp_path) and (($gui eq "UNX") or ($gui eq $cygwin))) {
  81     $temp_path = $ENV{TMPDIR};
  82     if (!defined($temp_path) and (-d "/tmp")) {
  83         $temp_path = "/tmp";
  84     }
  85 }
  86
  87 if (defined($ENV{INSTALLPATH_SMOKETEST})) {
  88     $installpath_without = $ENV{INSTALLPATH_SMOKETEST};
  89 }
  90 else {
  91     $installpath_without = $temp_path;
  92 }
  93
  94 if (!defined($installpath_without)) {
  95     print "Your temp value is missing. Please set your temp-variable or define INSTALLPATH_SMOKETEST\n\n";
  96     exit(1);
  97 }
  98
  99 if (!((defined($ENV{UPDATER})) and ($ENV{UPDATER} eq "YES") and !defined($ENV{CWS_WORK_STAMP})) ) {
 100     $is_protocol_test = 0;
 101 }
 102
 103 if ($gui eq "WNT") {
 104     $PathSeparator = '\\';
 105     $NewPathSeparator = ';';
 106     $dos = "$ENV{COMSPEC} -c";
 107     $PERL = "$dos $ENV{PERL}";
 108     $REMOVE_DIR = "$dos del /qsxyz";
 109     $REMOVE_FILE = "$dos del";
 110     $LIST_DIR = "$dos ls";
 111     $COPY_FILE = "$dos copy";
 112     $COPY_DIR = "$dos copy /s";
 113     $MK_DIR = "md";
 114     $RENAME_FILE = "ren";
 115     $nul = '> NUL';
 116     $RESPFILE="response_fat_wnt";
 117     $SVERSION_INI = $ENV{USERPROFILE} . $PathSeparator . "Anwendungsdaten" . $PathSeparator . "sversion.ini";
 118     $SOFFICEBIN = "soffice.exe";
 119     $bootstrapini = "bootstrap.ini";
 120     $bootstrapiniTemp = $bootstrapini . "_";
 121     $packpackage = "msi";
 122     $installpath_without =~ s/\//\\/g;
 123 }
 124 elsif ($gui eq "UNX") {
 125     $is_do_deinstall = 0;
 126     $PathSeparator = '/';
 127     $NewPathSeparator = ':';
 128     $dos = "";
 129     $PERL = "$ENV{PERL}";
 130     $REMOVE_DIR = "rm -rf";
 131     $REMOVE_FILE = "rm -f";
 132     $LIST_DIR = "ls";
 133     $COPY_FILE = "cp -f";
 134     $MK_DIR = "mkdir";
 135     $RENAME_FILE = "mv";
 136     $nul = '> /dev/null';
 137     $RESPFILE="response_fat_unx";
 138     $SVERSION_INI = $ENV{HOME} . $PathSeparator . ".sversionrc";
 139     $bootstrapini = "bootstraprc";
 140     $bootstrapiniTemp = $bootstrapini . "_";
 141     $packpackage = $ENV{PKGFORMAT};
 142     $SOFFICEBIN = "soffice";
 143     if ($ENV{OS} eq "MACOSX") {
 144         $COPY_DIR = "cp -RPfp";
 145     }
 146     else {
 147         $COPY_DIR = "cp -rf";
 148     }
 149 }
 150 elsif ($gui eq $cygwin) {
 151     $PathSeparator = '/';
 152     $NewPathSeparator = ':';
 153     $dos = "";
 154     $PERL = "$ENV{PERL}";
 155     $REMOVE_DIR = "rm -rf";
 156     $REMOVE_FILE = "rm -f";
 157     $LIST_DIR = "ls";
 158     $COPY_FILE = "cp -f";
 159     $COPY_DIR = "cp -rf";
 160     $MK_DIR = "mkdir";
 161     $RENAME_FILE = "mv";
 162     $nul = '> /dev/null';
 163     $RESPFILE="response_fat_wnt";
 164     $SVERSION_INI = $ENV{USERPROFILE} . $PathSeparator . "Anwendungsdaten" . $PathSeparator . "sversion.ini";
 165     $SOFFICEBIN = "soffice";
 166     $bootstrapini = "bootstrap.ini";
 167     $bootstrapiniTemp = $bootstrapini . "_";
 168     $CygwinLineends = $/;
 169     $WinLineends = "\r\n";
 170     $packpackage = "msi";
 171     $installpath_without =~ s/\\/\//g;
 172 }
 173 else {
 174     print_error ("not supported system\n",1);
 175 }
 176
 177 if ($is_without_msiexec) {
 178     require installer::windows::admin; import installer::windows::admin;
 179     $installer::globals::logfilename = $ENV{DMAKE_WORK_DIR} . $PathSeparator . $ENV{OUTPATH} . $ENV{PROEXT} . $PathSeparator . "misc" . $PathSeparator . "installer.log";
 180     $installer::globals::exithandler = \&install_error;
 181 }
 182
 183 if ($is_oo) {
 184     @install_list = (   'instsetoo_native'
 185     );
 186 }
 187 else {
 188     @install_list = (   'instset_native'
 189     );
 190 }
 191
 192 @error_messages = (     '',
 193             'lock flag for pkgadd still exist. Installation not possible!',
 194             'Error during installation!',
 195             'Error: patching configuration failed!',
 196             'Error: starting office failed or office crashed!',
 197             'Error during testing',
 198             'can not copy extension',
 199             'Error in setup log',
 200             'installationsset is not complete',
 201             'can not copy all basic scripts',
 202             'can not patch bottstrapini',
 203             'msiexec failed. Maybe you have got an installed version',
 204             'deinstallation is incomplete',
 205             'this packformat is not supported for this environment',
 206             'can not set execute permission'
 207 );
 208
 209 my $show_NoMessage = 0;
 210 my $show_Message = 1;
 211
 212 my $error_logflag = 1;
 213 my $error_setup = 2;
 214 my $error_patchConfig = 3;
 215 my $error_startOffice = 4;
 216 my $error_testResult = 5;
 217 my $error_copyExtension = 6;
 218 my $error_setup_log = 7;
 219 my $error_installset = 8;
 220 my $error_copyBasic = 9;
 221 my $error_patchBootstrap = 10;
 222 my $error_msiexec = 11;
 223 my $error_deinst = 12;
 224 my $error_packformat = 13;
 225 my $error_permission = 14;
 226
 227 my $command_normal = 0;
 228 my $command_withoutErrorcheck = 1;
 229 my $command_withoutOutput = 2;
 230
 231 if ($is_oo) {
 232     $PRODUCT="OpenOffice";
 233 }
 234 else {
 235     $PRODUCT="StarOffice";
 236 }
 237
 238 if (($ENV{PKGFORMAT} eq "installed") and (!defined ($ENV{FORCE2ARCHIVE}))) {
 239     $packpackage = $ENV{PKGFORMAT}; # take it for all environments
 240 }
 241 elsif (defined ($ENV{FORCE2ARCHIVE})) {
 242     $packpackage = "archive"; # take it for all environments
 243 }
 244 $StandDir = $ENV{SOLARSRC} . $PathSeparator;
 245 $SHIP = defined $ENV{SHIPDRIVE} ? $ENV{SHIPDRIVE} . $PathSeparator : "shipdrive_not_set";
 246 $PORDUCT = "$SHIP$ENV{INPATH}$PathSeparator$PRODUCT$PathSeparator$packpackage$PathSeparator";
 247 $DATA="$ENV{DMAKE_WORK_DIR}$PathSeparator" . "data$PathSeparator";
 248 $WORK_STAMP_LC=$ENV{WORK_STAMP};
 249 $WORK_STAMP_LC =~ tr/A-Z/a-z/;
 250 $ENV{DBGSV_INIT} = $DATA . "dbgsv.ini";
 251 $ExtensionDir = $ENV{DMAKE_WORK_DIR} . $PathSeparator . $ENV{OUTPATH} . $ENV{PROEXT} . $PathSeparator . "bin" . $PathSeparator;
 252
 253 if (defined($vcsid)) {
 254     $installpath_without .= $PathSeparator . $vcsid;
 255 }
 256 if (!$is_oo) {
 257     $installpath_without .= $PathSeparator . "StarOffice";
 258 }
 259 else {
 260     $installpath_without .= $PathSeparator . "OpenOffice";
 261 }
 262
 263 $installpath = $installpath_without . $PathSeparator;
 264 $installpath = glob $installpath;
 265
 266 $ENV{STAR_REGISTRY}="";
 267 $milestone = "";
 268
 269 #### options ####
 270
 271 $opt_nr = 0;
 272 GetOptions('nr');
 273
 274 if ($opt_nr)  {
 275     $is_remove_at_end = 0; # do not remove installation
 276 }
 277 if ( $ARGV[0] ) {
 278     $milestone = $ARGV[0];
 279 }
 280 if ( $ARGV[1] ) {
 281     $buildid = $ARGV[1];
 282 }
 283
 284
 285 #### script id #####
 286
 287 ( $script_name = $0 ) =~ s/^.*\b(\w+)\.pl$/$1/;
 288
 289 $id_str = ' $Revision: 1.35 $ ';
 290 $id_str =~ /Revision:\s+(\S+)\s+\$/
 291   ? ($script_rev = $1) : ($script_rev = "-");
 292
 293 print "$script_name -- version: $script_rev\n";
 294
 295
 296 #### main ####
 297
 298 if (!$is_debug) {
 299     if ($is_do_deinstall) {
 300         deinstallInstallation ($installpath);
 301     }
 302     removeOldInstallation($installpath);
 303     save_sversion ($SVERSION_INI);
 304 }
 305
 306 ($INSTSETNAME, $INSTALLSET) = getInstset();
 307
 308 print "Install: $INSTALLSET$INSTSETNAME\n";
 309 prepare();
 310 doTest();
 311
 312 if (!$is_debug) {
 313     restore_sversion ($SVERSION_INI);
 314     if ($is_remove_at_end) {
 315         if ($is_do_deinstall) {
 316             deinstallInstallation ($installpath);
 317         }
 318         removeInstallation($installpath);
 319     }
 320     else {
 321         print_notRemoved ($installpath);
 322     }
 323 }
 324 print "smoketest successful!\n";
 325 exit (0);
 326
 327 #########################
 328 #                       #
 329 #      Procedures       #
 330 #                       #
 331 #########################
 332
 333 sub getSubFiles {
 334     my ($startDir, $DirArray_ref, $mask) = @_;
 335     my ($dir);
 336     opendir(DIR,"$startDir");
 337     while($dir = readdir(DIR)) {
 338     if (($dir =~ /\.$/) or ($dir !~ /$mask/)) {
 339         next;
 340     }
 341         push (@{$DirArray_ref}, "$dir");
 342     }
 343     closedir(DIR);
 344
 345 }
 346
 347 sub getSubDirs {
 348     my ($startDir, $DirArray_ref) = @_;
 349     my ($dir);
 350     opendir(DIR,"$startDir");
 351     while($dir = readdir(DIR)) {
 352         if (($dir !~ /\.$/) and ( -d "$startDir$dir") ) {
 353             push (@{$DirArray_ref}, "$dir");
 354         }
 355     }
 356     closedir(DIR);
 357
 358 }
 359
 360 sub getSubDirsFullPath {
 361     my ($startDir, $DirArray_ref) = @_;
 362     my ($dir);
 363     opendir(DIR,"$startDir");
 364     while($dir = readdir(DIR)) {
 365         if (($dir !~ /\.$/) and ( -d "$startDir$dir") ) {
 366             push (@{$DirArray_ref}, "$startDir$dir");
 367         }
 368     }
 369     closedir(DIR);
 370
 371 }
 372
 373 sub findSubDir {
 374     my ($DirArray_ref) = @_;
 375     my (@sortedArray, $dir, $instdir);
 376     @sortedArray = sort langsort @{$DirArray_ref};
 377     print "Langs: @sortedArray\n" if $is_command_infos;
 378     foreach $dir (@sortedArray) {
 379         if ($dir =~ /log$/) {
 380             next;
 381         }
 382         $instdir = "$dir";
 383         return $instdir;
 384     }
 385     return "";
 386 }
 387
 388 sub findMultiple {
 389     my ($base, $name) = @_;
 390     my ($f, @s, @res);
 391     opendir(DIR, $base) or die "cannot open dir $base";
 392     while ($f = readdir(DIR)) {
 393         push @res, "$base" if $f eq $name;
 394         push @s, $f if
 395             -d "$base$f" && ! -l "$base$f" && $f ne '.' && $f ne '..';
 396     }
 397     closedir(DIR);
 398     foreach $f (@s) {
 399         push @res, findMultiple("$base$f$PathSeparator", $name);
 400     }
 401     return @res;
 402 }
 403
 404 sub findUnique {
 405     my ($base, $name) = @_;
 406     my @res = findMultiple($base, $name);
 407     die "no unique $name in $base" unless @res == 1;
 408     return $res[0];
 409 }
 410
 411 sub prepare {
 412     if ($gui eq "UNX") {
 413         $ENV{ignore_patch_check}="t";
 414         $ENV{OOO_FORCE_DESKTOP} = "none";
 415     }
 416
 417 }
 418
 419 sub is_Installset_ok {
 420     my ($installpath, $installname) = @_;
 421     my ($is_ok, $infile);
 422     $is_ok = 1;
 423     $infile = $INSTALLSET. "log$PathSeparator";
 424     $infile =~ s/_pre_//;
 425     $infile =~ s/[\/\\]normal[\/\\]//;
 426     $infile =~ s/\.(\d+)$/_$1\.html/;
 427     #if ($installname =~ /(?:_pre_){0,1}(.*)\.(\d+)/) {
 428     #   $infile .= "$1_$2.html";
 429     #   print "protocol: $infile\n" if $is_debug;
 430     #}
 431     open INTABLE, "<$infile" or return errorFromOpen ($infile);
 432         while(<INTABLE>) {
 433                 $line = $_;
 434         if ( $line =~ />(error)(.*)</ ) {
 435             print "ERROR: $1$2\n";
 436             $is_ok = 0;
 437         }
 438     }
 439     close INTABLE;
 440     return $is_ok;
 441 }
 442
 443 sub errorFromOpen {
 444     my ($file) = @_;
 445     print "ERROR: can't open $file\n";
 446     return 0;
 447 }
 448
 449 sub doTest {
 450     my ($Command);
 451     my (@Params, $basedir, $basisdir, $branddir);
 452
 453     # check installset (error 8)
 454
 455     if (($INSTSETNAME ne "") and $is_protocol_test) {
 456         if (!is_Installset_ok ("$PORDUCT", $INSTSETNAME)) {
 457             print_error ($error_messages[$error_installset], $error_installset);
 458         }
 459     }
 460
 461     # install office (error 2)
 462
 463     $basedir = doInstall ("$INSTALLSET$INSTSETNAME$PathSeparator", $installpath);
 464     $basisdir = findUnique($basedir, 'ure-link');
 465     $branddir = findUnique($basedir, 'basis-link');
 466     if ( (defined($ENV{OS})) && ($ENV{OS} eq "MACOSX") ) {
 467         $programpath = "$branddir". "MacOS$PathSeparator";
 468     }
 469     else {
 470         $programpath = "$branddir". "program$PathSeparator";
 471     }
 472     $userinstallpath_without = $installpath . $userinstalldir;
 473     $userinstallpath = $userinstallpath_without . $PathSeparator;
 474     $userpath = "$userinstallpath" . "user$PathSeparator";
 475     $basicpath = $userpath . "basic$PathSeparator";
 476     $standardbasicpath = "$basisdir" . "presets$PathSeparator" . "basic$PathSeparator";
 477     $LOGPATH="$userinstallpath" . "user" . $PathSeparator . "temp";
 478
 479     if ($gui eq "UNX") {
 480         $Command = "chmod -R 777 \"$basedir\"*";
 481         execute_system ("$Command");
 482     }
 483
 484     # check setup log file (error 7)
 485
 486 #       $Command = "$PERL check_setup.pl \"$programpath" . "setup.log\"";
 487 #       execute_Command ($Command, $error_setup_log, $show_Message, $command_normal );
 488
 489     # patch config (error 3)
 490
 491     $Command = "$PERL config.pl \"$basisdir \" \"$branddir \" \"$userinstallpath \" \"$DATA \" \"$buildid\"";
 492     execute_Command ($Command, $error_patchConfig, $show_Message, $command_normal );
 493
 494     # copy basicscripts (error 9)
 495
 496     $Command = "$COPY_FILE \"$DATA" . "scripts$PathSeparator" . "\"*.x* \"$standardbasicpath" . "Standard$PathSeparator\"";
 497     execute_Command ($Command, $error_copyBasic, $show_Message, $command_withoutOutput);
 498
 499     createPath("$basicpath", $error_copyBasic);
 500     $Command = "$COPY_DIR \"$standardbasicpath\"* \"$basicpath\"";
 501     execute_Command ($Command, $error_copyBasic, $show_Message, $command_withoutOutput);
 502
 503     # patching bootstrap (error 11)
 504
 505     if (!patch_bootstrap ("$programpath$bootstrapini", "$programpath$bootstrapiniTemp")) {
 506         print_error ($error_messages[$error_patchBootstrap], $error_patchBootstrap);
 507     }
 508
 509     # copy extension (error 6)
 510
 511     createPath ($LOGPATH, $error_copyExtension);
 512     $Command = "$COPY_FILE \"$ExtensionDir" . "TestExtension.oxt\" " . "\"$LOGPATH$PathSeparator\"";
 513     execute_Command ($Command, $error_copyExtension, $show_Message, $command_withoutOutput);
 514
 515
 516     # start office (error 4)
 517
 518     print "starting office ($INSTSETNAME)\n";
 519
 520         $Command = "\"$programpath" . "$SOFFICEBIN\" -no-oosplash -norestore -nocrashreport macro:///Standard.Global.StartTestWithDefaultOptions";
 521     if ( (defined($ENV{OS})) && ($ENV{OS} eq "MACOSX") ) {
 522         $Command = "cd \"$programpath\"; " . $Command;
 523     }
 524     execute_Command ($Command, $error_startOffice, $show_Message, $command_normal);
 525
 526     # test if smoketest is ok (error 5)
 527
 528     $Command = "$PERL testlog.pl \"$LOGPATH\"";
 529     execute_Command ($Command, $error_testResult, $show_Message, $command_normal);
 530
 531     # deinstall office (error 6)
 532
 533     if ($is_remove_at_end) {
 534         print "Deinstalling Office\n";
 535     }
 536 #       $Command = "$PERL deinstall.pl \"$LOGPATH\" \"$installpath\"";
 537 #       execute_Command ($Command, $error_deinstall, $show_NoMessage, $command_normal);
 538 }
 539
 540 sub install_error {
 541     print_error ($error_messages[$error_setup], $error_setup);
 542 }
 543
 544 sub doInstall {
 545     my ($installsetpath, $dest_installdir) = @_;
 546     my ($DirArray, $mask, $file, $Command, $optdir, $rpmdir, $system, $mach, $basedir, $output_ref, $olddir, $newdir);
 547     if (($ENV{PKGFORMAT} eq "installed") and (!defined($ENV{FORCE2ARCHIVE}))) {
 548                 createPath ($dest_installdir, $error_setup);
 549                 $Command = "$COPY_DIR \"$installsetpath\" \"$dest_installdir\"";
 550             execute_Command ($Command, $error_setup, $show_Message, $command_withoutOutput);
 551         @DirArray = ();
 552         getSubDirsFullPath ($dest_installdir, \@DirArray);
 553         if ($#DirArray == 0) {
 554             $basedir = $DirArray[0] . $PathSeparator;
 555         }
 556         elsif ($#DirArray == -1) {
 557             print_error ($error_setup, $show_Message);
 558         }
 559         else {
 560             $basedir = $dest_installdir;
 561         }
 562     }
 563     elsif (($gui eq "WNT") or ($gui eq $cygwin)) {
 564         if (defined($ENV{FORCE2ARCHIVE})) {
 565             print_error ($error_messages[$error_packformat], $error_packformat);
 566         }
 567         $mask = "\\.msi\$";
 568         getSubFiles ("$installsetpath", \@DirArray, $mask);
 569         if ($#DirArray == -1) {
 570                     print_error ("Installationset in $installsetpath is incomplete", 2);
 571         }
 572         foreach $file (@DirArray) {
 573             if ($is_without_msiexec) {
 574                 if ($is_debug) {
 575                     print "Debugmode: no installation from $installsetpath\n";
 576                 }
 577                 else {
 578                     createPath ($dest_installdir, $error_setup);
 579                     installer::windows::admin::make_admin_install ($installsetpath . $file, $dest_installdir);
 580                     if ($gui eq $cygwin) {
 581                         $Command = "find $dest_installdir \\( -name \"installhelper\" -prune -o -name \"*.exe\" -o -name \"*.dll\" -o -name \"*.manifest\" -o -name \"*.bin\" -o -name \"*.jar\" \\) -exec chmod a+x {} \\;";
 582                         execute_Command ($Command, $error_permission, $show_Message,  $command_normal);
 583                     }
 584                 }
 585             }
 586             else
 587             {
 588                 if ($gui eq $cygwin) {
 589                     my $convertinstallset = ConvertCygwinToWin_Shell("$installsetpath$file");
 590                     my $convertdestdir = ConvertCygwinToWin_Shell($dest_installdir);
 591                     $_inst_cmd=$ENV{SMOKETEST_SOINSTCMD};
 592                     if ( defined($_inst_cmd) ) {
 593                         $Command = $_inst_cmd . " $convertinstallset -qn TARGETDIR=$convertdestdir";
 594                     }
 595                     else {
 596                         $Command = "msiexec.exe /a $convertinstallset -qn TARGETDIR=$convertdestdir ALLUSERS=2";
 597                     }
 598                 }
 599                 else {
 600                     $_inst_cmd=$ENV{SMOKETEST_SOINSTCMD};
 601                     if ( defined($_inst_cmd) ) {
 602                         $Command = $_inst_cmd . " $installsetpath$file -qn TARGETDIR=$dest_installdir";
 603                     }
 604                     else {
 605                         $Command = "msiexec.exe /a $installsetpath$file -qn TARGETDIR=$dest_installdir ALLUSERS=2";
 606                     }
 607                 }
 608                 execute_Command ($Command, $error_msiexec, $show_Message,  $command_normal);
 609             }
 610         }
 611         $basedir = $dest_installdir;
 612     }
 613     elsif ($gui eq "UNX") {
 614         $system = `uname -s`;
 615         chomp $system;
 616         $mach = `uname -m`;
 617         chomp $mach;
 618         if (defined ($ENV{EPM}) && ($ENV{EPM} eq 'NO')) { # do the install ourselves ...
 619 # FIXME - this tool should work nicely without such hacks
 620 # cut/paste from ooo-build/bin/ooinstall
 621             my $instoo_dir = "$ENV{SRC_ROOT}/instsetoo_native";
 622
 623             if ( $ENV{'SYSTEM_MOZILLA'} eq 'YES' ) {
 624                 if (defined $ENV{'LD_LIBRARY_PATH'}) {
 625                     $ENV{'LD_LIBRARY_PATH'} =
 626                         "$ENV{'LD_LIBRARY_PATH'}:$ENV{'MOZ_LIB'}";
 627                 } else {
 628                     $ENV{'LD_LIBRARY_PATH'} = $ENV{'MOZ_LIB'};
 629                 }
 630             }
 631             $ENV{'PYTHONPATH'} = "$ENV{SRC_ROOT}/instsetoo_native/$ENV{INPATH}/bin:$ENV{SOLARVERSION}/$ENV{INPATH}/lib";
 632             $ENV{OUT} = "../$ENV{INPATH}";
 633             $ENV{LOCAL_OUT} = "../$ENV{INPATH}";
 634             $ENV{LOCAL_COMMON_OUT} = "../$ENV{INPATH}";
 635             my $sane_destdir = $dest_installdir;
 636             $sane_destdir .= "oootest";
 637             createPath ($sane_destdir, $error_setup);
 638             $Command = "cd $instoo_dir/util ; perl -w $ENV{SOLARENV}/bin/make_installer.pl " .
 639             "-f openoffice.lst -l en-US -p OpenOffice " .
 640             "-buildid \"smoketestoo\" -simple $sane_destdir";
 641 # FIXME - this tool should work nicely without such evil
 642             execute_Command ($Command, $error_setup, $show_Message, $command_normal);
 643             return "$sane_destdir/"
 644
 645         } elsif ( (defined($system)) && ($system eq "Linux") ) {
 646             if (defined ($ENV{FORCE2ARCHIVE}) and ($ENV{FORCE2ARCHIVE} eq "TRUE")) {
 647                 $optdir = $dest_installdir; #needed for getting work dir at the end
 648                    $mask = "\\.tar\\.gz\$";
 649                 getSubFiles ("$installsetpath", \@DirArray, $mask);
 650                 if ($#DirArray == -1) {
 651                        print_error ("Installationset in $installsetpath is incomplete", 2);
 652                 }
 653                 elsif ($#DirArray == 0) {
 654                     createPath ($dest_installdir, $error_setup);
 655                     $Command = "cd \"$dest_installdir\" && tar xzvf \"$installsetpath$DirArray[0]\"";
 656                     execute_Command ($Command, $error_setup, $show_Message, $command_withoutOutput);
 657                 }
 658                 else {
 659                     print_error ($error_setup, $show_Message);
 660                 }
 661             }
 662             elsif ($ENV{PKGFORMAT} eq "deb") { # default is rpm
 663                 $installsetpath .= "DEBS$PathSeparator";
 664             $optdir = "$dest_installdir" . "opt" . $PathSeparator;
 665                 createPath ($optdir, $error_setup);
 666                 $mask = "\\.deb\$";
 667                 getSubFiles ("$installsetpath", \@DirArray, $mask);
 668                 if ($#DirArray == -1) {
 669                        print_error ("Installationset in $installsetpath is incomplete", 2);
 670                 }
 671                 foreach $file (@DirArray) {
 672                     if ( ($file =~ /-menus-/) or ($file =~ /^adabas/) or (/^j2re-/) or ($file =~ /-gnome-/) ) {
 673                         next;
 674                     }
 675                     $Command = "dpkg-deb -x $installsetpath$file $dest_installdir";
 676                     execute_Command ($Command, $error_setup, $show_Message, $command_withoutErrorcheck | $command_withoutOutput);
 677                 }
 678             }
 679             else {
 680                 $installsetpath .= "RPMS$PathSeparator";
 681                 $optdir = "$dest_installdir" . "opt" . $PathSeparator;
 682                 $rpmdir = "$dest_installdir" . "rpm" . $PathSeparator;
 683                 createPath ($optdir, $error_setup);
 684                 createPath ($rpmdir, $error_setup);
 685                 my $ld_library_backup = $ENV{LD_LIBRARY_PATH};
 686                 if ( defined $ENV{SYSBASE}) {
 687                     my $sysbase=$ENV{SYSBASE};
 688                     if ( "$ld_library_backup" eq "" ) {
 689                         $ENV{LD_LIBRARY_PATH} = "$sysbase/usr/lib";
 690                     } else {
 691                         $ENV{LD_LIBRARY_PATH} = "$ld_library_backup:$sysbase/lib";
 692                     }
 693                 }
 694                 $Command = "rpm --initdb --define \"_dbpath $rpmdir\"";
 695                 execute_Command ($Command, $error_setup, $show_Message, $command_withoutOutput);
 696                 $mask = "\\.rpm\$";
 697                 getSubFiles ("$installsetpath", \@DirArray, $mask);
 698                 if ($#DirArray == -1) {
 699                                 print_error ("Installationset in $installsetpath is incomplete", 2);
 700                 }
 701                 foreach $file (@DirArray) {
 702                     if ( ($file =~ /-menus-/) or ($file =~ /^adabas/) or (/^j2re-/) or ($file =~ /-gnome-/) ) {
 703                         next;
 704                     }
 705                     $Command = "rpm --define \"_dbpath $rpmdir\" --install --ignoresize --nodeps -vh --relocate /opt=${dest_installdir}opt $installsetpath$file";
 706                     execute_Command ($Command, $error_setup, $show_Message, $command_withoutErrorcheck | $command_withoutOutput);
 707                 }
 708                 $ENV{LD_LIBRARY_PATH}=$ld_library_backup;
 709             }
 710         }
 711         elsif ( (defined($system)) && ($system eq "SunOS") ) {
 712             if (defined($ENV{FORCE2ARCHIVE})) {
 713                 print_error ($error_messages[$error_packformat], $error_packformat);
 714             }
 715             @DirArray = ();
 716                 $mask = "^.ai.pkg.zone.lock";
 717                         getSubFiles ("/tmp", \@DirArray, $mask);
 718             if ($#DirArray >= 0) {
 719                 foreach $file (@DirArray) {
 720                                 $Command = "$REMOVE_FILE /tmp/$file";
 721                     execute_Command ($Command, $error_logflag, $show_Message, $command_withoutOutput);
 722                             }
 723             }
 724             if ($mach eq sun4u) {
 725                 $solarisdata = $DATA . "solaris$PathSeparator" . "sparc$PathSeparator";
 726             }
 727             else {
 728                 $solarisdata = $DATA . "solaris$PathSeparator" . "x86$PathSeparator";
 729             }
 730             $installsetpath .= "packages$PathSeparator";
 731             $optdir = "$dest_installdir" . "opt" . $PathSeparator;
 732             createPath ($optdir, $error_setup);
 733             createPath ($dest_installdir . "usr$PathSeparator" . "bin", $error_setup);
 734             @DirArray = ();
 735             getSubDirs ("$installsetpath", \@DirArray);
 736             my $ld_preload = $ENV{LD_PRELOAD};
 737             $ENV{LD_PRELOAD} = $solarisdata . "getuid.so";
 738             if ($#DirArray == -1) {
 739                             print_error ("Installationset in $installsetpath is incomplete", 2);
 740             }
 741             foreach $file (@DirArray) {
 742                 if ( ($file =~ /-gnome/) or ($file =~ /-cde/) or ($file =~ /adabas/) or ($file =~ /j3/) or ($file =~ /-desktop-/) ) {
 743                     next;
 744                 }
 745                 $Command = "pkgparam -d $installsetpath $file BASEDIR";
 746                 $output_ref = execute_Command ($Command, $error_setup, $show_Message, $command_withoutOutput);
 747                 if (($#{@$output_ref} > -1) and ($$output_ref[0] ne "") ) {
 748                     createPath ("$dest_installdir$$output_ref[0]", $error_setup);
 749                 }
 750                 $Command = "pkgadd -a $solarisdata" . "admin -d $installsetpath -R $dest_installdir $file";
 751                 execute_Command ($Command, $error_setup, $show_Message, $command_withoutErrorcheck | $command_withoutOutput);
 752             }
 753             my $pkgadd_tmpfile = "/tmp/.ai.pkg.zone.lock*";
 754             $Command = "$REMOVE_FILE $pkgadd_tmpfile";
 755             execute_Command ($Command, $error_setup, $show_NoMessage, $command_withoutErrorcheck | $command_withoutOutput);
 756             $ENV{LD_PRELOAD} = $ld_preload;
 757         }
 758         elsif ( (defined($ENV{OS})) && ($ENV{OS} eq "MACOSX") ) {
 759             if (defined($ENV{FORCE2ARCHIVE})) {
 760                 print_error ($error_messages[$error_packformat], $error_packformat);
 761             }
 762             @DirArray = ();
 763             my $install_dmg;
 764             getSubFiles ("$installsetpath", \@DirArray, "^[a-zA-Z0-9].*\\.dmg\$");
 765             if ($#DirArray == 0) {
 766                 $install_dmg = "$installsetpath" . $DirArray[0];
 767             }
 768             elsif ($#DirArray > 0) {
 769                 print_error ("more than one installset found in $installsetpath", 2);
 770             }
 771             else {
 772                 print_error ("no installset found in $installsetpath", 2);
 773             }
 774             $Command = "hdiutil attach " . $install_dmg;
 775             my $output_ref;
 776             $output_ref = execute_Command ($Command, $error_setup, $show_Message, $command_withoutOutput);
 777             my $volumeinfo = $$output_ref[$#{@{$output_ref}}];
 778             if (!$volumeinfo =~ /OpenOffice/) {
 779                 print_error ("mount of $install_dmg failed", 2);
 780             }
 781             $volumeinfo =~ s/\s{2,}/;/g;
 782             my @volumeinfos = split(/;/,$volumeinfo);
 783             my $detachpath = $volumeinfos[0];
 784             my $newinstallsetpath = $volumeinfos[2] . $PathSeparator;
 785             createPath ($dest_installdir, $error_setup);
 786             $Command = "$COPY_DIR \"$newinstallsetpath\" \"$dest_installdir\"";
 787             execute_Command ($Command, $error_setup, $show_Message, $command_withoutOutput);
 788             $Command = "hdiutil detach " . $detachpath;
 789             execute_Command ($Command, $error_setup, $show_Message, $command_withoutOutput);
 790             @DirArray = ();
 791             getSubFiles ("$dest_installdir", \@DirArray, "\\.app");
 792             if ($#DirArray == 0) {
 793                 $optdir = "$dest_installdir" . $DirArray[0] . $PathSeparator;
 794                 my $PListFile = "Info.plist";
 795                                 my $officeDir = "$optdir" . "Contents" . $PathSeparator;
 796                 my $programmDir = "$officeDir" . "MacOS" . $PathSeparator;
 797                 $Command = "$COPY_FILE \"$officeDir$PListFile\" \"$programmDir$PListFile\"";
 798                 execute_Command ($Command, $error_setup, $show_Message, $command_withoutOutput);
 799             }
 800             else {
 801                 print_error ("Installation in $dest_installdir is incomplete", 2);
 802             }
 803         }
 804                 else {
 805             print_error ("Plattform is not supported", 2);
 806                 }
 807         @DirArray = ();
 808         getSubDirsFullPath ($optdir, \@DirArray);
 809         if ($#DirArray == 0) {
 810             $basedir = $DirArray[0] . $PathSeparator;
 811         }
 812         elsif ($#DirArray == -1) {
 813             print_error ($error_setup, $show_Message);
 814         }
 815         else {
 816             $basedir = $optdir;
 817          }
 818     }
 819     return ($basedir);
 820 }
 821
 822 sub langsort {
 823     if ($a eq $prefered_lang) {
 824         return -1;
 825     }
 826     elsif ($b eq $prefered_lang) {
 827         return 1;
 828     }
 829     else {
 830         $a cmp $b;
 831     }
 832 }
 833
 834 sub getInstset {
 835     my ($INSTSET, $NEWINSTSET);
 836     my (@DirArray, $InstDir, $RootDir, $TestDir1, $TestDir2);
 837
 838     if (defined ($ENV{EPM}) && ($ENV{EPM} eq 'NO') && ($gui eq "UNX")) { # we do the install ourselves ...
 839         return ();
 840     }
 841
 842     print "get Instset\n" if $is_debug;
 843     $NEWINSTSET = "";
 844     if (defined($smoketest_install)) {
 845         my $mask = "\\" . $PathSeparator . "\$";
 846         $smoketest_install =~ s/$mask//;
 847         my ($sufix);
 848         ($NEWINSTSET, $INSTSET, $sufix) = fileparse ($smoketest_install);
 849         return ($NEWINSTSET, $INSTSET);
 850     }
 851     if (!isLocalEnv() and !defined($ENV{CWS_WORK_STAMP}) and (-e $SHIP)) {
 852         ($NEWINSTSET, $INSTSET) = getSetFromServer();
 853     }
 854     else {
 855         $InstDir="";
 856         $RootDir=$ENV{DMAKE_WORK_DIR};
 857         $RootDir=~s/\w+$//;
 858         foreach $project (@install_list) {
 859             @DirArray=();
 860             $TestDir1 = "$RootDir$project$PathSeparator$ENV{INPATH}$PathSeparator$PRODUCT$PathSeparator$packpackage$PathSeparator" . "install$PathSeparator";
 861             $TestDir2 = "$StandDir$project$PathSeparator$ENV{INPATH}$PathSeparator$PRODUCT$PathSeparator$packpackage$PathSeparator" . "install$PathSeparator";
 862             if (-e "$TestDir1") {
 863                 $InstDir= $TestDir1;
 864             }
 865             elsif (-e "$TestDir2") {
 866                 $InstDir="$TestDir2";
 867             }
 868             if ($InstDir eq "") {
 869                 next;
 870             }
 871             getSubDirs ("$InstDir", \@DirArray);
 872             $INSTSET = findSubDir (\@DirArray);
 873             print "Lang-Sel: $INSTSET\n" if $is_command_infos;
 874 ;
 875             if ($INSTSET ne "")  {
 876                 $NEWINSTSET = $INSTSET;
 877                 $INSTSET = $InstDir;
 878                 print "new: $INSTSET\n";
 879             }
 880             if (($INSTSET ne "") and (-e $INSTSET)) {
 881                 return ($NEWINSTSET, $INSTSET);
 882             }
 883         }
 884         print_error ("no installationset found\n",2);
 885     }
 886     return ($NEWINSTSET, $INSTSET);
 887 }
 888
 889 sub isLocalEnv {
 890     my $returnvalue = 0;
 891     if (defined ($ENV{SOL_TMP}) && defined ($ENV{SOLARVERSION})) {
 892         my $mask = $ENV{SOL_TMP};
 893         $mask =~ s/\\/\\\\/;
 894         print "Mask: $mask\n" if $is_debug;
 895         if ($ENV{SOLARVERSION}=~ /$mask/) {
 896             $returnvalue = 1;
 897         }
 898     }
 899     return $returnvalue;
 900 }
 901
 902 sub get_productcode {
 903     my ( $installpath ) = @_;
 904     my ($path, $productcode);
 905     $productcode = "";
 906     $path = "$installpath" . "setup.ini";
 907     print "$path\n" if $is_debug;
 908     if ( !open(SETUP,$path) ) {
 909         print "FATAL: can't open $path\n" if ($is_command_infos);
 910         return ($productcode);
 911     }
 912
 913     if (!eof(SETUP)) {
 914         while (<SETUP>) {
 915             chomp;
 916             if ( /productcode=(\{[\d\w-]+\})/ ) {
 917                 $productcode = $1;
 918             }
 919         }
 920
 921         close(SETUP);
 922     }
 923     return ($productcode);
 924 }
 925
 926 sub InstsetSort {
 927     my ($a1, $b1);
 928     if ($a =~ /$global_instset_mask/) {
 929         $a1 = $1;
 930     }
 931     if ($b =~ /$global_instset_mask/) {
 932         $b1 = $1;
 933     }
 934     $a1 <=> $b1;
 935 }
 936
 937 sub getSetFromServer {
 938     my ($DirName, $SetupFullPath);
 939     my $workspace = $ENV{WORK_STAMP};
 940     my $platform  = $ENV{INPATH};
 941     my $latestset;
 942     my (@DirArray, $mask);
 943     $SetupFullPath = $PORDUCT;
 944     if ( ! ( $workspace && $platform ) ) {
 945         print_error ( "Error: environment not set correctly.", 1);
 946     }
 947     if (!defined($milestone)) {
 948             print_error ("Milestone ist not defined!", 2);
 949     }
 950     if (!defined($buildid)) {
 951             print_error ("Build-ID ist not defined!", 2);
 952     }
 953
 954 #    if ( $SetupFullPath =~ /^\/s.*\/install\// ) {
 955 #        if ( $gui eq "UNX" ) {
 956 #            $SetupFullPath = "/net/jumbo.germany" . $SetupFullPath;
 957 #        } else {
 958 #            $SetupFullPath = "\\\\jumbo" . $SetupFullPath;
 959 #        }
 960 #    }
 961
 962 #    my $ws_lc = lc $workspace;
 963     $mask = "^$workspace" . "_" . $milestone . "_native_packed-(\\d+)_en-US\\.$buildid";
 964     $global_instset_mask = $mask;
 965     getSubFiles ($SetupFullPath, \@DirArray, $mask);
 966     @DirArray = sort InstsetSort @DirArray;
 967     if ($#DirArray > -1) {
 968     $latestset = $DirArray [$#DirArray];
 969     $DirName = $latestset;
 970     }
 971     else {
 972             print_error ("Cannot find install set $SetupFullPath for $workspace $milestone", 2);
 973     }
 974     print "Latest install sets: $latestset\n" if $is_debug;
 975
 976     print "$DirName\t $SetupFullPath\n" if $is_debug;
 977
 978     # compare with file system
 979     # at the moment just the existence is checked. For security reasons it might be
 980     # better to additionally check whether there are newer sets (this must not happen,
 981     # but who knows ...)
 982     if ( -d $SetupFullPath ) {
 983         return ($DirName, $SetupFullPath);
 984     } else {
 985         print_error ("Cannot find install set $SetupFullPath for $workspace $milestone", 2);
 986         }
 987 }
 988
 989 sub patch_bootstrap {
 990     my ($sourcefile, $destfile) = @_;
 991     my (@convert_split, $line);
 992     my ($Error) = 1;
 993     my ($lineend);
 994
 995     if ($is_debug) {
 996         print "patching bootstrap $sourcefile ...\n";
 997         return 1;
 998     }
 999
1000     $Error &= move ("$sourcefile", "$destfile");
1001
1002     open OUTFILE, ">$sourcefile" or return errorFromOpen ($sourcefile);
1003     open INFILE, "<$destfile" or return errorFromOpen ($destfile);
1004     binmode(OUTFILE);
1005     binmode(INFILE);
1006     while(<INFILE>) {
1007         $line = $_;
1008
1009         if ( $line =~ /UserInstallation/ ) {
1010             if ($line =~ /(\r\n)/) {
1011                 $lineend = $1;
1012             }
1013             elsif ($line =~ /(\n)/) {
1014                 $lineend = $1;
1015             }
1016             else {
1017                 $lineend = $/;
1018             }
1019             @convert_split = split "=", $line;
1020             $line = $convert_split[0];
1021             $line .= "=";
1022             if ($gui eq $cygwin) {
1023                 $line .= ConvertToFileURL(ConvertCygwinToWin($userinstallpath_without));
1024             }
1025             else {
1026                 $line .= ConvertToFileURL($userinstallpath_without);
1027             }
1028             $line .= $lineend;
1029         }
1030         print OUTFILE "$line";
1031
1032     }
1033
1034     close OUTFILE;
1035     close INFILE;
1036     $Error &= unlink ($destfile);
1037     return ($Error);
1038 }
1039
1040 sub SetWinLineends () {
1041     $/ = $WinLineends;
1042 }
1043
1044 sub SetCygwinLineends () {
1045     $/ = $CygwinLineends;
1046 }
1047
1048 sub ConvertToFileURL {
1049     my ($filename) = @_;
1050     my ($FileURL);
1051
1052     $FileURL = $FileURLPrefix . $filename;
1053     $FileURL =~ s/\\/\//g;
1054     $FileURL =~ s/\/\/\/\//\/\/\//; # 4 slashes to 3 slashes
1055     return ($FileURL);
1056 }
1057
1058 sub ConvertCygwinToWin_Shell {
1059     my ($cygwinpath) = @_;
1060     my ($winpath);
1061     $winpath = ConvertCygwinToWin ($cygwinpath);
1062     $winpath =~ s/\\/\\\\/g;
1063     return ($winpath);
1064 }
1065
1066 sub ConvertCygwinToWin {
1067     my ($cygwinpath) = @_;
1068     my ($winpath);
1069     my ($last_lineends) = $/;
1070     SetCygwinLineends();
1071     $winpath=`cygpath --windows $cygwinpath`;
1072     chomp($winpath);
1073     $/ = $last_lineends;
1074     return ($winpath);
1075 }
1076
1077 sub createPath {
1078     my ($path, $Error) = @_;
1079     if (!-d "$path") {
1080         if (!$is_debug) {
1081             eval {mkpath("$path", 0, 0777)};
1082             if ($@) {
1083                 print_error ($error_messages[$Error], $Error);
1084             }
1085         }
1086         else {
1087             print "mkpath($path, 0, 0777)\n";
1088         }
1089     }
1090 }
1091
1092 sub save_sversion {
1093     my ($sversion) = @_;
1094     my ($sversion_bak) = $sversion . "_";
1095     if (-e $sversion) {
1096         if (-e $sversion_bak) {
1097             execute_system("$REMOVE_FILE \"$sversion_bak\"");
1098         }
1099             execute_system("$COPY_FILE \"$sversion\" \"$sversion_bak\"");
1100         execute_system("$REMOVE_FILE \"$sversion\"");
1101         $sversion_saved = 1;
1102     }
1103 }
1104
1105 sub restore_sversion {
1106     my ($sversion) = @_;
1107     my ($sversion_bak) = $sversion . "_";
1108     if ($sversion_saved) {
1109         if (-e $sversion) {
1110             execute_system("$REMOVE_FILE \"$sversion\"");
1111         }
1112             execute_system("$COPY_FILE \"$sversion_bak\" \"$sversion\"");
1113         execute_system("$REMOVE_FILE \"$sversion_bak\"");
1114         $sversion_saved = 0;
1115     }
1116 }
1117
1118 sub removeOldInstallation  {
1119     my ($installpath) = @_;
1120     if (!$is_debug) {
1121         if (-e $installpath) {
1122             execute_system("$REMOVE_DIR \"$installpath\"");
1123         }
1124          if (-e $installpath) {
1125             print_error ("can not clear old installation in $installpath\n", 3);
1126         }
1127     }
1128 }
1129
1130 sub removeInstallation  {
1131     my ($installpath) = @_;
1132     if (!$is_debug) {
1133         if (-e $installpath) {
1134             execute_system("$REMOVE_DIR \"$installpath\"");
1135         }
1136     }
1137 }
1138
1139 sub deinstallInstallation  {
1140     my ($installpath) = @_;
1141     my ($productcode);
1142     if ($gui eq "UNX") { return; }
1143     if (!$is_debug) {
1144         if (-e $installpath) {
1145             $productcode = get_productcode ($installpath);
1146             print "Productcode: $productcode\n" if ($is_command_infos);
1147             if ($productcode ne "") {
1148                 print "deinstalling $productcode ...\n";
1149                 $Command = "msiexec.exe -x $productcode -qn";
1150                 execute_Command ($Command, $error_deinst, $show_Message, $command_withoutErrorcheck | $command_withoutOutput);
1151             }
1152         }
1153     }
1154 }
1155
1156 sub setInstallpath {
1157     my ($infile, $outfile, $installpath) = @_;
1158     if (-e $outfile) {
1159         execute_system ("$REMOVE_FILE \"$outfile\"");
1160
1161     }
1162     open OUTTABLE, ">$outfile" or die "Error: can\'t open solarfile $outfile";
1163     open INTABLE, "<$infile" or die "Error: can\'t open solarfile $infile";
1164         while(<INTABLE>) {
1165                 $line = $_;
1166         if ( $line =~ /^DESTINATIONPATH=officeinstallpath/ ) {
1167             $line =~ s/officeinstallpath/$installpath/;
1168         }
1169         print OUTTABLE "$line";
1170     }
1171     close INTABLE;
1172     close OUTTABLE;
1173 }
1174
1175 sub execute_Command {
1176     my ($Command, $Errorcode, $showMessage, $command_action) = @_;
1177     my ($Returncode, $output_ref);
1178     if (!$is_debug) {
1179         if ( ($command_action & $command_withoutOutput) == $command_withoutOutput) {
1180             ($Returncode, $output_ref) = execute_system ("$Command");
1181         }
1182         else {
1183             print "$Command\n" if $is_command_infos;
1184             $Returncode = system ("$Command");
1185         }
1186         if ($Returncode) {
1187             if ($showMessage) {
1188                 if (($command_action & $command_withoutErrorcheck) == $command_withoutErrorcheck) {
1189                     print_warning ($error_messages[$Errorcode], $Errorcode);
1190                 }
1191                 else {
1192                     print_error ($error_messages[$Errorcode], $Errorcode);
1193                 }
1194             }
1195             else {
1196                 if (($command_action & $command_withoutErrorcheck) != $command_withoutErrorcheck) {
1197                     do_exit ($Errorcode);
1198                 }
1199             }
1200         }
1201     }
1202     else {
1203         print "$Command\n";
1204     }
1205     return $output_ref;
1206 }
1207
1208 sub execute_system {
1209     my ($command) = shift;
1210     my (@output_array, $line);
1211     if ( $is_command_infos ) {
1212         print STDERR "TRACE_SYSTEM: $command\n";
1213     }
1214     open( COMMAND, "$command 2>&1 |");
1215     while ($line = <COMMAND>) {
1216         chomp $line;
1217         push (@output_array, $line);
1218     }
1219     close(COMMAND);
1220     return $?, \@output_array;
1221 }
1222
1223 sub print_warning
1224 {
1225     my $message     = shift;
1226
1227     print STDERR "$script_name: ";
1228     print STDERR "WARNING $message\n";
1229     return;
1230 }
1231
1232 sub print_error
1233 {
1234     my $message     = shift;
1235     my $error_code  = shift;
1236
1237     print STDERR "$script_name: ";
1238     print STDERR "ERROR: $message\n";
1239
1240     do_exit($error_code);
1241 }
1242
1243 sub print_notRemoved {
1244     my ($installpath) = @_;
1245     print "no deinstallation from $installpath\n";
1246 }
1247
1248 sub do_exit
1249 {
1250     my $error_code  = shift;
1251
1252     if ($sversion_saved) {
1253     restore_sversion ($SVERSION_INI);
1254     }
1255     if ($is_remove_on_error) {
1256     if ($is_do_deinstall) {
1257         deinstallInstallation ($installpath);
1258     }
1259     removeInstallation($installpath);
1260     }
1261     else {
1262     print_notRemoved ($installpath);
1263     }
1264     if ( $error_code ) {
1265     print STDERR "\nFAILURE: $script_name aborted.\n";
1266     }
1267     exit($error_code);
1268
1269 }