solenv/bin/modules/installer/windows/msiglobal.pm

   1 #
   2 # This file is part of the LibreOffice project.
   3 #
   4 # This Source Code Form is subject to the terms of the Mozilla Public
   5 # License, v. 2.0. If a copy of the MPL was not distributed with this
   6 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
   7 #
   8 # This file incorporates work covered by the following license notice:
   9 #
  10 #   Licensed to the Apache Software Foundation (ASF) under one or more
  11 #   contributor license agreements. See the NOTICE file distributed
  12 #   with this work for additional information regarding copyright
  13 #   ownership. The ASF licenses this file to you under the Apache
  14 #   License, Version 2.0 (the "License"); you may not use this file
  15 #   except in compliance with the License. You may obtain a copy of
  16 #   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  17 #
  18
  19 package installer::windows::msiglobal;
  20
  21 use Cwd;
  22 use Digest::MD5;
  23 use installer::converter;
  24 use installer::exiter;
  25 use installer::files;
  26 use installer::globals;
  27 use installer::logger;
  28 use installer::pathanalyzer;
  29 use installer::remover;
  30 use installer::scriptitems;
  31 use installer::systemactions;
  32 use installer::worker;
  33 use installer::windows::idtglobal;
  34 use installer::windows::language;
  35
  36 ###########################################################################
  37 # Generating the header of the ddf file.
  38 # The usage of ddf files is needed, because makecab.exe can only include
  39 # one sourcefile into a cab file
  40 ###########################################################################
  41
  42 sub write_ddf_file_header
  43 {
  44     my ($ddffileref, $cabinetfile, $installdir) = @_;
  45
  46     my $oneline;
  47
  48     $oneline = ".Set CabinetName1=" . $cabinetfile . "\n";
  49     push(@{$ddffileref} ,$oneline);
  50     $oneline = ".Set ReservePerCabinetSize=128\n";  # This reserves space for a digital signature.
  51     push(@{$ddffileref} ,$oneline);
  52     $oneline = ".Set MaxDiskSize=2147483648\n";     # This allows the .cab file to get a size of 2 GB.
  53     push(@{$ddffileref} ,$oneline);
  54     $oneline = ".Set CompressionType=LZX\n";
  55     push(@{$ddffileref} ,$oneline);
  56     $oneline = ".Set Compress=ON\n";
  57     push(@{$ddffileref} ,$oneline);
  58 # The window size for LZX compression
  59 # CompressionMemory=15 | 16 | ... | 21
  60 # Reference: http://msdn.microsoft.com/en-us/library/bb417343.aspx
  61     $oneline = ".Set CompressionMemory=$installer::globals::cabfilecompressionlevel\n";
  62     push(@{$ddffileref} ,$oneline);
  63     $oneline = ".Set Cabinet=ON\n";
  64     push(@{$ddffileref} ,$oneline);
  65     $oneline = ".Set DiskDirectoryTemplate=" . $installdir . "\n";
  66     push(@{$ddffileref} ,$oneline);
  67 }
  68
  69 ##########################################################################
  70 # Lines in ddf files must not contain more than 256 characters
  71 ##########################################################################
  72
  73 sub check_ddf_file
  74 {
  75     my ( $ddffile, $ddffilename ) = @_;
  76
  77     my $maxlength = 0;
  78     my $maxline = 0;
  79     my $linelength = 0;
  80     my $linenumber = 0;
  81
  82     for ( my $i = 0; $i <= $#{$ddffile}; $i++ )
  83     {
  84         my $oneline = ${$ddffile}[$i];
  85
  86         $linelength = length($oneline);
  87         $linenumber = $i + 1;
  88
  89         if ( $linelength > 256 )
  90         {
  91             installer::exiter::exit_program("ERROR \"$ddffilename\" line $linenumber: Lines in ddf files must not contain more than 256 characters!", "check_ddf_file");
  92         }
  93
  94         if ( $linelength > $maxlength )
  95         {
  96             $maxlength = $linelength;
  97             $maxline = $linenumber;
  98         }
  99     }
 100
 101     my $infoline = "Check of ddf file \"$ddffilename\": Maximum length \"$maxlength\" in line \"$maxline\" (allowed line length: 256 characters)\n";
 102     push(@installer::globals::logfileinfo, $infoline);
 103 }
 104
 105 ##########################################################################
 106 # Lines in ddf files must not be longer than 256 characters.
 107 # Therefore it can be useful to use relative paths. Then it is
 108 # necessary to change into temp directory before calling
 109 # makecab.exe.
 110 ##########################################################################
 111
 112 sub make_relative_ddf_path
 113 {
 114     my ( $sourcepath ) = @_;
 115
 116     my $windowstemppath = $installer::globals::temppath;
 117
 118     if ( $^O =~ /cygwin/i )
 119     {
 120         $windowstemppath = $installer::globals::cyg_temppath;
 121     }
 122
 123     $sourcepath =~ s/\Q$windowstemppath\E//;
 124     $sourcepath =~ s/^[\\\/]//;
 125
 126     return $sourcepath;
 127 }
 128
 129 ##########################################################################
 130 # Returning the order of the sequences in the files array.
 131 ##########################################################################
 132
 133 sub get_sequenceorder
 134 {
 135     my ($filesref) = @_;
 136
 137     my %order = ();
 138
 139     for ( my $i = 0; $i <= $#{$filesref}; $i++ )
 140     {
 141         my $onefile = ${$filesref}[$i];
 142         if ( ! $onefile->{'assignedsequencenumber'} ) { installer::exiter::exit_program("ERROR: No sequence number assigned to $onefile->{'gid'} ($onefile->{'uniquename'})!", "get_sequenceorder"); }
 143         $order{$onefile->{'assignedsequencenumber'}} = $i;
 144     }
 145
 146     return \%order;
 147 }
 148
 149 ##########################################################################
 150 # Generation the list, in which the source of the files is connected
 151 # with the cabinet destination file. Because more than one file needs
 152 # to be included into a cab file, this has to be done via ddf files.
 153 ##########################################################################
 154
 155 sub generate_cab_file_list
 156 {
 157     my ($filesref, $installdir, $ddfdir, $allvariables) = @_;
 158
 159     my @cabfilelist = ();
 160
 161     installer::logger::include_header_into_logfile("Generating ddf files");
 162
 163     installer::logger::include_timestamp_into_logfile("Performance Info: ddf file generation start");
 164
 165     if ( $^O =~ /cygwin/i ) { installer::worker::generate_cygwin_paths($filesref); }
 166
 167     if (( $installer::globals::fix_number_of_cab_files ) && ( $installer::globals::updatedatabase ))
 168     {
 169         my $sequenceorder = get_sequenceorder($filesref);
 170
 171         my $counter = 1;
 172
 173         while ( ( exists($sequenceorder->{$counter}) ) || ( exists($installer::globals::allmergemodulefilesequences{$counter}) ) ) # Taking care of files from merge modules
 174         {
 175 #           if ( exists($installer::globals::allmergemodulefilesequences{$counter}) )
 176 #           {
 177 #               # Skipping this sequence, it is not included in $filesref, because it is assigned to a file from a merge module.\n";
 178 #               $counter++;
 179 #               next;
 180 #           }
 181
 182             my $onefile = ${$filesref}[$sequenceorder->{$counter}];
 183             $counter++;
 184
 185             my $cabinetfile = $onefile->{'cabinet'};
 186             my $sourcepath =  $onefile->{'sourcepath'};
 187             if ( $^O =~ /cygwin/i ) { $sourcepath = $onefile->{'cyg_sourcepath'}; }
 188             my $uniquename =  $onefile->{'uniquename'};
 189
 190             my $styles = "";
 191             my $doinclude = 1;
 192             if ( $onefile->{'Styles'} ) { $styles = $onefile->{'Styles'}; };
 193             if ( $styles =~ /\bDONT_PACK\b/ ) { $doinclude = 0; }
 194
 195             # to avoid lines with more than 256 characters, it can be useful to use relative paths
 196             $sourcepath = make_relative_ddf_path($sourcepath);
 197
 198             my @ddffile = ();
 199
 200             write_ddf_file_header(\@ddffile, $cabinetfile, $installdir);
 201
 202             my $ddfline = "\"" . $sourcepath . "\" \"" . $uniquename . "\"\n";
 203             if ( $doinclude ) { push(@ddffile, $ddfline); }
 204
 205             my $nextfile = "";
 206             if ( ${$filesref}[$sequenceorder->{$counter}] ) { $nextfile = ${$filesref}[$sequenceorder->{$counter}]; }
 207
 208             my $nextcabinetfile = "";
 209
 210             if ( $nextfile->{'cabinet'} ) { $nextcabinetfile = $nextfile->{'cabinet'}; }
 211
 212             while ( $nextcabinetfile eq $cabinetfile )
 213             {
 214                 $sourcepath =  $nextfile->{'sourcepath'};
 215                 if ( $^O =~ /cygwin/i ) { $sourcepath = $nextfile->{'cyg_sourcepath'}; }
 216                 # to avoid lines with more than 256 characters, it can be useful to use relative paths
 217                 $sourcepath = make_relative_ddf_path($sourcepath);
 218                 $uniquename =  $nextfile->{'uniquename'};
 219                 my $localdoinclude = 1;
 220                 my $nextfilestyles = "";
 221                 if ( $nextfile->{'Styles'} ) { $nextfilestyles = $nextfile->{'Styles'}; }
 222                 if ( $nextfilestyles =~ /\bDONT_PACK\b/ ) { $localdoinclude = 0; }
 223                 $ddfline = "\"" . $sourcepath . "\" \"" . $uniquename . "\"\n";
 224                 if ( $localdoinclude ) { push(@ddffile, $ddfline); }
 225                 $counter++;
 226                 $nextfile = "";
 227                 $nextcabinetfile = "_lastfile_";
 228                 if (( exists($sequenceorder->{$counter}) ) && ( ${$filesref}[$sequenceorder->{$counter}] ))
 229                 {
 230                     $nextfile = ${$filesref}[$sequenceorder->{$counter}];
 231                     $nextcabinetfile = $nextfile->{'cabinet'};
 232                 }
 233             }
 234
 235             # creating the DDF file
 236
 237             my $ddffilename = $cabinetfile;
 238             $ddffilename =~ s/.cab/.ddf/;
 239             $ddfdir =~ s/\Q$installer::globals::separator\E\s*$//;
 240             $ddffilename = $ddfdir . $installer::globals::separator . $ddffilename;
 241
 242             installer::files::save_file($ddffilename ,\@ddffile);
 243             my $infoline = "Created ddf file: $ddffilename\n";
 244             push(@installer::globals::logfileinfo, $infoline);
 245
 246             # lines in ddf files must not be longer than 256 characters
 247             check_ddf_file(\@ddffile, $ddffilename);
 248
 249             # Writing the makecab system call
 250
 251             my $oneline = "makecab.exe /V3 /F " . $ddffilename . " 2\>\&1 |" . "\n";
 252             if ( $installer::globals::isunix )
 253             {
 254                 $oneline = "$ENV{'WORKDIR_FOR_BUILD'}/LinkTarget/Executable/makecab.exe /V3 /F " . $ddffilename . " 2\>\&1 |" . "\n";
 255             }
 256
 257             push(@cabfilelist, $oneline);
 258
 259             # collecting all ddf files
 260             push(@installer::globals::allddffiles, $ddffilename);
 261         }
 262     }
 263     elsif ( $installer::globals::fix_number_of_cab_files )
 264     {
 265         for ( my $i = 0; $i <= $#{$filesref}; $i++ )
 266         {
 267             my $onefile = ${$filesref}[$i];
 268             my $cabinetfile = $onefile->{'cabinet'};
 269             my $sourcepath =  $onefile->{'sourcepath'};
 270             if ( $^O =~ /cygwin/i ) { $sourcepath = $onefile->{'cyg_sourcepath'}; }
 271             my $uniquename =  $onefile->{'uniquename'};
 272
 273             my $styles = "";
 274             my $doinclude = 1;
 275             if ( $onefile->{'Styles'} ) { $styles = $onefile->{'Styles'}; };
 276             if ( $styles =~ /\bDONT_PACK\b/ ) { $doinclude = 0; }
 277
 278
 279             # to avoid lines with more than 256 characters, it can be useful to use relative paths
 280             $sourcepath = make_relative_ddf_path($sourcepath);
 281
 282             # all files with the same cabinetfile are directly behind each other in the files collector
 283
 284             my @ddffile = ();
 285
 286             write_ddf_file_header(\@ddffile, $cabinetfile, $installdir);
 287
 288             my $ddfline = "\"" . $sourcepath . "\" \"" . $uniquename . "\"\n";
 289             if ( $doinclude ) { push(@ddffile, $ddfline); }
 290
 291             my $nextfile = ${$filesref}[$i+1];
 292             my $nextcabinetfile = "";
 293
 294             if ( $nextfile->{'cabinet'} ) { $nextcabinetfile = $nextfile->{'cabinet'}; }
 295
 296             while ( $nextcabinetfile eq $cabinetfile )
 297             {
 298                 $sourcepath =  $nextfile->{'sourcepath'};
 299                 if ( $^O =~ /cygwin/i ) { $sourcepath = $nextfile->{'cyg_sourcepath'}; }
 300                 # to avoid lines with more than 256 characters, it can be useful to use relative paths
 301                 $sourcepath = make_relative_ddf_path($sourcepath);
 302                 $uniquename =  $nextfile->{'uniquename'};
 303                 my $localdoinclude = 1;
 304                 my $nextfilestyles = "";
 305                 if ( $nextfile->{'Styles'} ) { $nextfilestyles = $nextfile->{'Styles'}; }
 306                 if ( $nextfilestyles =~ /\bDONT_PACK\b/ ) { $localdoinclude = 0; }
 307                 $ddfline = "\"" . $sourcepath . "\" \"" . $uniquename . "\"\n";
 308                 if ( $localdoinclude ) { push(@ddffile, $ddfline); }
 309                 $i++;                                           # increasing the counter!
 310                 $nextfile = ${$filesref}[$i+1];
 311                 if ( $nextfile ) { $nextcabinetfile = $nextfile->{'cabinet'}; }
 312                 else { $nextcabinetfile = "_lastfile_"; }
 313             }
 314
 315             # creating the DDF file
 316
 317             my $ddffilename = $cabinetfile;
 318             $ddffilename =~ s/.cab/.ddf/;
 319             $ddfdir =~ s/\Q$installer::globals::separator\E\s*$//;
 320             $ddffilename = $ddfdir . $installer::globals::separator . $ddffilename;
 321
 322             installer::files::save_file($ddffilename ,\@ddffile);
 323             my $infoline = "Created ddf file: $ddffilename\n";
 324             push(@installer::globals::logfileinfo, $infoline);
 325
 326             # lines in ddf files must not be longer than 256 characters
 327             check_ddf_file(\@ddffile, $ddffilename);
 328
 329             # Writing the makecab system call
 330
 331             my $oneline = "makecab.exe /V3 /F " . $ddffilename . " 2\>\&1 |" . "\n";
 332             if ( $installer::globals::isunix )
 333             {
 334                 $oneline = "$ENV{'WORKDIR_FOR_BUILD'}/LinkTarget/Executable/makecab.exe /V3 /F " . $ddffilename . " 2\>\&1 |" . "\n";
 335             }
 336
 337             push(@cabfilelist, $oneline);
 338
 339             # collecting all ddf files
 340             push(@installer::globals::allddffiles, $ddffilename);
 341         }
 342     }
 343     else
 344     {
 345         installer::exiter::exit_program("ERROR: No cab file specification in globals.pm !", "generate_cab_file_list");
 346     }
 347
 348     installer::logger::include_timestamp_into_logfile("Performance Info: ddf file generation end");
 349
 350     return \@cabfilelist;   # contains all system calls for packaging process
 351 }
 352
 353 ########################################################################
 354 # For update and patch reasons the pack order needs to be saved.
 355 # The pack order is saved in the ddf files; the names and locations
 356 # of the ddf files are saved in @installer::globals::allddffiles.
 357 # The outputfile "packorder.txt" can be saved in
 358 # $installer::globals::infodirectory .
 359 ########################################################################
 360
 361 sub save_packorder
 362 {
 363     installer::logger::include_header_into_logfile("Saving pack order");
 364
 365     installer::logger::include_timestamp_into_logfile("Performance Info: saving pack order start");
 366
 367     my $packorderfilename = "packorder.txt";
 368     $packorderfilename = $installer::globals::infodirectory . $installer::globals::separator . $packorderfilename;
 369
 370     my @packorder = ();
 371
 372     my $headerline = "\# Syntax\: Filetable_Sequence Cabinetfilename Physical_FileName Unique_FileName\n\n";
 373     push(@packorder, $headerline);
 374
 375     for ( my $i = 0; $i <= $#installer::globals::allddffiles; $i++ )
 376     {
 377         my $ddffilename = $installer::globals::allddffiles[$i];
 378         my $ddffile = installer::files::read_file($ddffilename);
 379         my $cabinetfile = "";
 380
 381         for ( my $j = 0; $j <= $#{$ddffile}; $j++ )
 382         {
 383             my $oneline = ${$ddffile}[$j];
 384
 385             # Getting the Cabinet file name
 386
 387             if ( $oneline =~ /^\s*\.Set\s+CabinetName.*\=(.*?)\s*$/ ) { $cabinetfile = $1; }
 388             if ( $oneline =~ /^\s*\.Set\s+/ ) { next; }
 389
 390             if ( $oneline =~ /^\s*\"(.*?)\"\s+\"(.*?)\"\s*$/ )
 391             {
 392                 my $sourcefile = $1;
 393                 my $uniquefilename = $2;
 394
 395                 installer::pathanalyzer::make_absolute_filename_to_relative_filename(\$sourcefile);
 396
 397                 # Using the hash created in create_files_table for performance reasons to get the sequence number
 398                 my $filesequence = "";
 399                 if ( exists($installer::globals::uniquefilenamesequence{$uniquefilename}) ) { $filesequence = $installer::globals::uniquefilenamesequence{$uniquefilename}; }
 400                 else { installer::exiter::exit_program("ERROR: No sequence number value for $uniquefilename !", "save_packorder"); }
 401
 402                 my $line = $filesequence . "\t" . $cabinetfile . "\t" . $sourcefile . "\t" . $uniquefilename . "\n";
 403                 push(@packorder, $line);
 404             }
 405         }
 406     }
 407
 408     installer::files::save_file($packorderfilename ,\@packorder);
 409
 410     installer::logger::include_timestamp_into_logfile("Performance Info: saving pack order end");
 411 }
 412
 413 #################################################################
 414 # Returning the name of the msi database
 415 #################################################################
 416
 417 sub get_msidatabasename
 418 {
 419     my ($allvariableshashref, $language) = @_;
 420
 421     my $databasename = $allvariableshashref->{'PRODUCTNAME'} . $allvariableshashref->{'PRODUCTVERSION'};
 422     $databasename = lc($databasename);
 423     $databasename =~ s/\.//g;
 424     $databasename =~ s/\-//g;
 425     $databasename =~ s/\s//g;
 426
 427     # possibility to overwrite the name with variable DATABASENAME
 428     if ( $allvariableshashref->{'DATABASENAME'} )
 429     {
 430         $databasename = $allvariableshashref->{'DATABASENAME'};
 431     }
 432
 433     if ( $language )
 434     {
 435         if (!($language eq ""))
 436         {
 437             $databasename .= "_$language";
 438         }
 439     }
 440
 441     $databasename .= ".msi";
 442
 443     return $databasename;
 444 }
 445
 446 #################################################################
 447 # Creating the msi database
 448 # This works only on Windows
 449 #################################################################
 450
 451 sub create_msi_database
 452 {
 453     my ($idtdirbase ,$msifilename) = @_;
 454
 455     # -f : path containing the idt files
 456     # -d : msi database, including path
 457     # -c : create database
 458     # -i : include the following tables ("*" includes all available tables)
 459
 460     my $msidb = "msidb.exe";    # Has to be in the path
 461     if ( $installer::globals::isunix )
 462     {
 463         $msidb = "$ENV{'WORKDIR_FOR_BUILD'}/LinkTarget/Executable/msidb.exe";
 464     }
 465     my $extraslash = "";        # Has to be set for non-ActiveState perl
 466
 467     installer::logger::include_header_into_logfile("Creating msi database");
 468
 469     $idtdirbase = installer::converter::make_path_conform($idtdirbase);
 470
 471     $msifilename = installer::converter::make_path_conform($msifilename);
 472
 473     if ( $^O =~ /cygwin/i ) {
 474         # msidb.exe really wants backslashes. (And double escaping because system() expands the string.)
 475         $idtdirbase =~ s/\//\\\\/g;
 476         $msifilename =~ s/\//\\\\/g;
 477         $extraslash = "\\";
 478     }
 479     if ( $^O =~ /linux/i ) {
 480         $extraslash = "\\";
 481     }
 482     my $systemcall = $msidb . " -f " . $idtdirbase . " -d " . $msifilename . " -c " . "-i " . $extraslash . "*";
 483
 484     my $returnvalue = system($systemcall);
 485
 486     my $infoline = "Systemcall: $systemcall\n";
 487     push( @installer::globals::logfileinfo, $infoline);
 488
 489     if ($returnvalue)
 490     {
 491         $infoline = "ERROR: Could not execute $msidb!\n";
 492         push( @installer::globals::logfileinfo, $infoline);
 493     }
 494     else
 495     {
 496         $infoline = "Success: Executed $msidb successfully!\n";
 497         push( @installer::globals::logfileinfo, $infoline);
 498     }
 499 }
 500
 501 #################################################################
 502 # Returning the msi version for the Summary Information Stream
 503 #################################################################
 504
 505 sub get_msiversion_for_sis
 506 {
 507     my $msiversion = "200";
 508     return $msiversion;
 509 }
 510
 511 #################################################################
 512 # Returning the word count for the Summary Information Stream
 513 #################################################################
 514
 515 sub get_wordcount_for_sis
 516 {
 517     my $wordcount = "0";
 518     return $wordcount;
 519 }
 520
 521 #################################################################
 522 # Returning the template for the Summary Information Stream
 523 #################################################################
 524
 525 sub get_template_for_sis
 526 {
 527     my ( $language, $allvariables ) = @_;
 528
 529     my $windowslanguage = installer::windows::language::get_windows_language($language);
 530
 531     my $architecture = "Intel";
 532
 533     if (( $allvariables->{'64BITPRODUCT'} ) && ( $allvariables->{'64BITPRODUCT'} == 1 )) { $architecture = "x64"; }
 534
 535     my $value = "\"" . $architecture . ";" . $windowslanguage;  # adding the Windows language
 536
 537     $value = $value . "\"";                     # adding ending '"'
 538
 539     return $value ;
 540 }
 541
 542 #################################################################
 543 # Returning the PackageCode for the Summary Information Stream
 544 #################################################################
 545
 546 sub get_packagecode_for_sis
 547 {
 548     # always generating a new package code for each package
 549
 550     my $guidref = get_guid_list(1, 1);  # only one GUID shall be generated
 551
 552     ${$guidref}[0] =~ s/\s*$//;     # removing ending spaces
 553
 554     my $guid = "\{" . ${$guidref}[0] . "\}";
 555
 556     my $infoline = "PackageCode: $guid\n";
 557     push( @installer::globals::logfileinfo, $infoline);
 558
 559     return $guid;
 560 }
 561
 562 #################################################################
 563 # Returning the author for the Summary Information Stream
 564 #################################################################
 565
 566 sub get_author_for_sis
 567 {
 568     my $author = $installer::globals::longmanufacturer;
 569
 570     $author = "\"" . $author . "\"";
 571
 572     return $author;
 573 }
 574
 575 #################################################################
 576 # Returning the subject for the Summary Information Stream
 577 #################################################################
 578
 579 sub get_subject_for_sis
 580 {
 581     my ( $allvariableshashref ) = @_;
 582
 583     my $subject = $allvariableshashref->{'PRODUCTNAME'} . " " . $allvariableshashref->{'PRODUCTVERSION'};
 584
 585     $subject = "\"" . $subject . "\"";
 586
 587     return $subject;
 588 }
 589
 590 ######################################################################
 591 # Returning the security for the Summary Information Stream
 592 ######################################################################
 593
 594 sub get_security_for_sis
 595 {
 596     my $security = "0";
 597     return $security;
 598 }
 599
 600 #################################################################
 601 # Writing the Summary information stream into the msi database
 602 # This works only on Windows
 603 #################################################################
 604
 605 sub write_summary_into_msi_database
 606 {
 607     my ($msifilename, $language, $languagefile, $allvariableshashref) = @_;
 608
 609     # -g : required msi version
 610     # -c : codepage
 611     # -p : template
 612
 613     installer::logger::include_header_into_logfile("Writing summary information stream");
 614
 615     my $msiinfo = "msiinfo.exe";    # Has to be in the path
 616     if ( $installer::globals::isunix )
 617     {
 618         $msiinfo = "$ENV{'WORKDIR_FOR_BUILD'}/LinkTarget/Executable/msiinfo.exe";
 619     }
 620
 621     my $msiversion = get_msiversion_for_sis();
 622     my $codepage = 0; # PID_CODEPAGE summary property in a signed short, therefore it is impossible to set 65001 here.
 623     my $template = get_template_for_sis($language, $allvariableshashref);
 624     my $guid = get_packagecode_for_sis();
 625     my $title = "\"Installation database\"";
 626     my $author = get_author_for_sis();
 627     my $subject = get_subject_for_sis($allvariableshashref);
 628     my $comment = "\"" . $allvariableshashref->{'PRODUCTNAME'} ."\"";
 629     my $keywords = "\"Install,MSI\"";
 630     my $appname = "\"Windows Installer\"";
 631     my $security = get_security_for_sis();
 632     my $wordcount = get_wordcount_for_sis();
 633
 634     $msifilename = installer::converter::make_path_conform($msifilename);
 635
 636     my $systemcall = $msiinfo . " " . $msifilename . " -g " . $msiversion . " -c " . $codepage
 637                     . " -p " . $template . " -v " . $guid . " -t " . $title . " -a " . $author
 638                     . " -j " . $subject . " -o " . $comment . " -k " . $keywords . " -n " . $appname
 639                     . " -u " . $security . " -w " . $wordcount;
 640
 641     my $returnvalue = system($systemcall);
 642
 643     my $infoline = "Systemcall: $systemcall\n";
 644     push( @installer::globals::logfileinfo, $infoline);
 645
 646     if ($returnvalue)
 647     {
 648         $infoline = "ERROR: Could not execute $systemcall (return $returnvalue)\n";
 649         push( @installer::globals::logfileinfo, $infoline);
 650     }
 651     else
 652     {
 653         $infoline = "Success: Executed $msiinfo successfully!\n";
 654         push( @installer::globals::logfileinfo, $infoline);
 655     }
 656 }
 657
 658 #########################################################################
 659 # For more than one language in the installation set:
 660 # Use one database and create Transformations for all other languages
 661 #########################################################################
 662
 663 sub create_transforms
 664 {
 665     my ($languagesarray, $defaultlanguage, $installdir, $allvariableshashref) = @_;
 666
 667     installer::logger::include_header_into_logfile("Creating Transforms");
 668
 669     my $cscript = "cscript.exe";    # Has to be in the path
 670     my $msitran = "msitran.exe";    # Has to be in the path
 671     my $msidb = "msidb.exe";    # Has to be in the path
 672     if ( $installer::globals::isunix )
 673     {
 674         $infoline = "ERROR: We cannot create transformations yet (we cannot use cscript.exe when cross-compiling)\n";
 675         push( @installer::globals::logfileinfo, $infoline);
 676     }
 677     my $wilangid = $ENV{WINDOWS_SDK_WILANGID};
 678
 679     my $from = cwd();
 680
 681     my $templatevalue = "1033";
 682
 683     $installdir = installer::converter::make_path_conform($installdir);
 684
 685     # Syntax for creating a transformation
 686     # msitran.exe -g <baseDB> <referenceDB> <transformfile> [<errorhandling>}
 687
 688     my $basedbname = get_msidatabasename($allvariableshashref, $defaultlanguage);
 689     $basedbname = $installdir . $installer::globals::separator . $basedbname;
 690
 691     my $errorhandling = "f";    # Suppress "change codepage" error
 692
 693     # Iterating over all files
 694
 695     foreach ( @{$languagesarray} )
 696     {
 697         my $onelanguage = $_;
 698
 699         if ( $onelanguage eq $defaultlanguage ) { next; }
 700
 701         my $referencedbname = get_msidatabasename($allvariableshashref, $onelanguage);
 702         $referencedbname = $installdir . $installer::globals::separator . $referencedbname;
 703
 704         my $windowslanguage = installer::windows::language::get_windows_language($onelanguage);
 705         my $transformfile = $installdir . $installer::globals::separator .  $windowslanguage;
 706
 707         my $systemcall = $msitran . " " . " -g " . $basedbname . " " . $referencedbname . " " . $transformfile . " " . $errorhandling;
 708
 709         my $returnvalue = system($systemcall);
 710
 711         my $infoline = "Systemcall: $systemcall\n";
 712         push( @installer::globals::logfileinfo, $infoline);
 713
 714         # Problem: msitran.exe in version 4.0 always returns "1", even if no failure occurred.
 715         # Therefore it has to be checked, if this is version 4.0. If yes, if the mst file
 716         # exists and if it is larger than 0 bytes. If this is true, then no error occurred.
 717         # File Version of msitran.exe: 4.0.6000.16384 has checksum: "b66190a70145a57773ec769e16777b29".
 718         # Same for msitran.exe from wntmsci12: "aa25d3445b94ffde8ef0c1efb77a56b8"
 719
 720         if ($returnvalue)
 721         {
 722             $infoline = "WARNING: Returnvalue of $msitran is not 0. Checking version of $msitran!\n";
 723             push( @installer::globals::logfileinfo, $infoline);
 724
 725             open(FILE, "<$installer::globals::msitranpath") or die "ERROR: Can't open $installer::globals::msitranpath for creating file hash";
 726             binmode(FILE);
 727             my $digest = Digest::MD5->new->addfile(*FILE)->hexdigest;
 728             close(FILE);
 729
 730             my @problemchecksums = ("b66190a70145a57773ec769e16777b29", "aa25d3445b94ffde8ef0c1efb77a56b8", "748206e54fc93efe6a1aaa9d491f3ad1");
 731             my $isproblemchecksum = 0;
 732
 733             foreach my $problemchecksum ( @problemchecksums )
 734             {
 735                 $infoline = "Checksum of problematic MsiTran.exe: $problemchecksum\n";
 736                 push( @installer::globals::logfileinfo, $infoline);
 737                 $infoline = "Checksum of used MsiTran.exe: $digest\n";
 738                 push( @installer::globals::logfileinfo, $infoline);
 739                 if ( $digest eq $problemchecksum ) { $isproblemchecksum = 1; }
 740             }
 741
 742             if ( $isproblemchecksum )
 743             {
 744                 # Check existence of mst
 745                 if ( -f $transformfile )
 746                 {
 747                     $infoline = "File $transformfile exists.\n";
 748                     push( @installer::globals::logfileinfo, $infoline);
 749                     my $filesize = ( -s $transformfile );
 750                     $infoline = "Size of $transformfile: $filesize\n";
 751                     push( @installer::globals::logfileinfo, $infoline);
 752
 753                     if ( $filesize > 0 )
 754                     {
 755                         $infoline = "Info: Returnvalue $returnvalue of $msitran is no problem :-) .\n";
 756                         push( @installer::globals::logfileinfo, $infoline);
 757                         $returnvalue = 0; # reset the error
 758                     }
 759                     else
 760                     {
 761                         $infoline = "Filesize indicates that an error occurred.\n";
 762                         push( @installer::globals::logfileinfo, $infoline);
 763                     }
 764                 }
 765                 else
 766                 {
 767                     $infoline = "File $transformfile does not exist -> An error occurred.\n";
 768                     push( @installer::globals::logfileinfo, $infoline);
 769                 }
 770             }
 771             else
 772             {
 773                 $infoline = "This is not a problematic version of msitran.exe. Therefore the error is not caused by problematic msitran.exe.\n";
 774                 push( @installer::globals::logfileinfo, $infoline);
 775             }
 776         }
 777
 778         if ($returnvalue)
 779         {
 780             $infoline = "ERROR: Could not execute $msitran!\n";
 781             push( @installer::globals::logfileinfo, $infoline);
 782         }
 783         else
 784         {
 785             $infoline = "Success: Executed $msitran successfully!\n";
 786             push( @installer::globals::logfileinfo, $infoline);
 787         }
 788
 789         # The reference database can be deleted
 790
 791         my $result = unlink($referencedbname);
 792         # $result contains the number of deleted files
 793
 794         if ( $result == 0 )
 795         {
 796             $infoline = "ERROR: Could not remove file $$referencedbname !\n";
 797             push( @installer::globals::logfileinfo, $infoline);
 798             installer::exiter::exit_program($infoline, "create_transforms");
 799         }
 800
 801         chdir($installdir);
 802         $systemcall = $msidb . " " . " -d " . $basedbname . " -r " . $windowslanguage;
 803         system($systemcall);
 804         # fdo#46181 - zh-HK and zh-MO should have fallen back to zh-TW not to zh-CN
 805         # we need to hack zh-HK and zh-MO LCIDs directly into the MSI
 806         if($windowslanguage eq '1028')
 807         {
 808             rename 1028,3076;
 809             $systemcall = $msidb . " " . " -d " . $basedbname . " -r " . 3076;
 810             system($systemcall);
 811             rename 3076,5124;
 812             $systemcall = $msidb . " " . " -d " . $basedbname . " -r " . 5124;
 813             system($systemcall);
 814             $templatevalue = $templatevalue . "," . 3076 . "," . 5124;
 815             rename 5124,1028;
 816         }
 817         chdir($from);
 818         unlink($transformfile);
 819
 820         $infoline = "Systemcall: $systemcall\n";
 821         push( @installer::globals::logfileinfo, $infoline);
 822
 823         if ( $windowslanguage ne '1033')
 824         {
 825             $templatevalue = $templatevalue . "," . $windowslanguage;
 826         }
 827     }
 828
 829     $systemcall = "TEMP=$ENV{'TMPDIR'} $cscript \"$wilangid\" $basedbname Package $templatevalue";
 830
 831     $returnvalue = system($systemcall);
 832
 833     $infoline = "Systemcall: $systemcall\n";
 834     push( @installer::globals::logfileinfo, $infoline);
 835
 836     if ($returnvalue)
 837     {
 838         $infoline = "ERROR: $returnvalue from $systemcall\n";
 839         push( @installer::globals::logfileinfo, $infoline);
 840     }
 841     else
 842     {
 843         $infoline = "Success: Executed WiLangId.vbs successfully!\n";
 844         push( @installer::globals::logfileinfo, $infoline);
 845     }
 846 }
 847
 848 #########################################################################
 849 # The default language msi database does not need to contain
 850 # the language in the database name. Therefore the file
 851 # is renamed. Example: "openofficeorg20_01.msi" to "openofficeorg20.msi"
 852 #########################################################################
 853
 854 sub rename_msi_database_in_installset
 855 {
 856     my ($defaultlanguage, $installdir, $allvariableshashref) = @_;
 857
 858     installer::logger::include_header_into_logfile("Renaming msi database");
 859
 860     my $olddatabasename = get_msidatabasename($allvariableshashref, $defaultlanguage);
 861     $olddatabasename = $installdir . $installer::globals::separator . $olddatabasename;
 862
 863     my $newdatabasename = get_msidatabasename($allvariableshashref);
 864
 865     $installer::globals::shortmsidatabasename = $newdatabasename;
 866
 867     $newdatabasename = $installdir . $installer::globals::separator . $newdatabasename;
 868
 869     installer::systemactions::rename_one_file($olddatabasename, $newdatabasename);
 870
 871     $installer::globals::msidatabasename = $newdatabasename;
 872 }
 873
 874 #################################################################
 875 # Copying MergeModules for the Windows installer into the
 876 # installation set. The list of MergeModules is located
 877 # in %installer::globals::copy_msm_files
 878 #################################################################
 879
 880 sub copy_merge_modules_into_installset
 881 {
 882     my ($installdir) = @_;
 883
 884     installer::logger::include_header_into_logfile("Copying Merge files into installation set");
 885
 886     my $cabfile;
 887     foreach $cabfile ( keys  %installer::globals::copy_msm_files )
 888     {
 889         my $sourcefile  = $installer::globals::copy_msm_files{$cabfile};
 890         my $destfile = $installdir . $installer::globals::separator . $cabfile;
 891
 892         installer::systemactions::copy_one_file($sourcefile, $destfile);
 893     }
 894 }
 895
 896 #################################################################
 897 # Getting a list of GUID using uuidgen.exe.
 898 # This works only on Windows
 899 #################################################################
 900
 901 sub get_guid_list
 902 {
 903     my ($number, $log) = @_;
 904
 905     if ( $log ) { installer::logger::include_header_into_logfile("Generating $number GUID"); }
 906
 907     my $uuidgen = $ENV{'UUIDGEN'};        # Has to be in the path
 908
 909     # "-c" for uppercase output
 910
 911     my $systemcall = "$uuidgen -n$number |";
 912     if ( $installer::globals::isunix )
 913     {
 914         # -n is not present in the non-windows uuidgen
 915         $systemcall = "for I in `seq 1 $number` ; do uuidgen ; done |";
 916     }
 917     open (UUIDGEN, "$systemcall" ) or die("uuidgen is missing.");
 918     my @uuidlist = <UUIDGEN>;
 919     close (UUIDGEN);
 920
 921     my $infoline = "Systemcall: $systemcall\n";
 922     if ( $log ) { push( @installer::globals::logfileinfo, $infoline); }
 923
 924     my $comparenumber = $#uuidlist + 1;
 925
 926     if ( $comparenumber == $number )
 927     {
 928         $infoline = "Success: Executed $uuidgen successfully!\n";
 929         if ( $log ) { push( @installer::globals::logfileinfo, $infoline); }
 930     }
 931     else
 932     {
 933         $infoline = "ERROR: Could not execute $uuidgen successfully!\n";
 934         if ( $log ) { push( @installer::globals::logfileinfo, $infoline); }
 935     }
 936
 937     # uppercase, no longer "-c", because this is only supported in uuidgen.exe v.1.01
 938     for ( my $i = 0; $i <= $#uuidlist; $i++ ) { $uuidlist[$i] = uc($uuidlist[$i]); }
 939
 940     return \@uuidlist;
 941 }
 942
 943 #################################################################
 944 # Calculating a GUID with a string using md5.
 945 #################################################################
 946
 947 sub calculate_guid
 948 {
 949     my ( $string ) = @_;
 950
 951     my $guid = "";
 952
 953     my $md5 = Digest::MD5->new;
 954     $md5->add($string);
 955     my $digest = $md5->hexdigest;
 956     $digest = uc($digest);
 957
 958     my ($first, $second, $third, $fourth, $fifth) = unpack ('A8 A4 A4 A4 A12', $digest);
 959     $guid = "$first-$second-$third-$fourth-$fifth";
 960
 961     return $guid;
 962 }
 963
 964 #################################################################
 965 # Calculating a ID with a string using md5 (very fast).
 966 #################################################################
 967
 968 sub calculate_id
 969 {
 970     my ( $string, $length ) = @_;
 971
 972     my $id = "";
 973
 974     my $md5 = Digest::MD5->new;
 975     $md5->add($string);
 976     my $digest = lc($md5->hexdigest);
 977     $id = substr($digest, 0, $length);
 978
 979     return $id;
 980 }
 981
 982 #################################################################
 983 # Filling real component GUID into the component table.
 984 # This works only on Windows
 985 #################################################################
 986
 987 sub set_uuid_into_component_table
 988 {
 989     my ($idtdirbase, $allvariables) = @_;
 990
 991     my $componenttablename  = $idtdirbase . $installer::globals::separator . "Componen.idt";
 992
 993     my $componenttable = installer::files::read_file($componenttablename);
 994
 995     # For update and patch reasons (small update) the GUID of an existing component must not change!
 996     # The collection of component GUIDs is saved in the directory $installer::globals::idttemplatepath in the file "components.txt"
 997
 998     my $infoline = "";
 999     my $counter = 0;
1000
1001     for ( my $i = 3; $i <= $#{$componenttable}; $i++ )  # ignoring the first three lines
1002     {
1003         my $oneline = ${$componenttable}[$i];
1004         my $componentname = "";
1005         if ( $oneline =~ /^\s*(\S+?)\t/ ) { $componentname = $1; }
1006
1007         my $uuid = "";
1008
1009             if ( exists($installer::globals::calculated_component_guids{$componentname}))
1010             {
1011                 $uuid = $installer::globals::calculated_component_guids{$componentname};
1012             }
1013             else
1014             {
1015                 # Calculating new GUID with the help of the component name.
1016
1017                 if ( ! exists($allvariables->{'PRODUCTVERSION'}) ) { installer::exiter::exit_program("ERROR: Could not find variable \"PRODUCTVERSION\" (required value for GUID creation)!", "set_uuid_into_component_table"); }
1018                 my $sourcestring = $componentname . "_" . $allvariables->{'PRODUCTVERSION'};
1019                 $uuid = calculate_guid($sourcestring);
1020                 $counter++;
1021
1022                 # checking, if there is a conflict with an already created guid
1023                 if ( exists($installer::globals::allcalculated_guids{$uuid}) ) { installer::exiter::exit_program("ERROR: \"$uuid\" was already created before!", "set_uuid_into_component_table"); }
1024                 $installer::globals::allcalculated_guids{$uuid} = 1;
1025                 $installer::globals::calculated_component_guids{$componentname} = $uuid;
1026             }
1027
1028         ${$componenttable}[$i] =~ s/COMPONENTGUID/$uuid/;
1029     }
1030
1031     installer::files::save_file($componenttablename, $componenttable);
1032 }
1033
1034 #########################################################################
1035 # Adding final 64 properties into msi database, if required.
1036 # RegLocator : +16 in type column to search in 64 bit registry.
1037 # All conditions: "VersionNT" -> "VersionNT64" (several tables).
1038 # Already done: "+256" in Attributes column of table "Component".
1039 # Still following: Setting "x64" instead of "Intel" in Summary
1040 # Information Stream of msi database in "get_template_for_sis".
1041 #########################################################################
1042
1043 sub prepare_64bit_database
1044 {
1045     my ($basedir, $allvariables) = @_;
1046
1047     my $infoline = "";
1048
1049     if (( $allvariables->{'64BITPRODUCT'} ) && ( $allvariables->{'64BITPRODUCT'} == 1 ))
1050     {
1051         # 1. Beginning with table "RegLocat.idt". Adding "16" to the type.
1052
1053         my $reglocatfile = "";
1054         my $reglocatfilename = $basedir . $installer::globals::separator . "RegLocat.idt";
1055
1056         if ( -f $reglocatfilename )
1057         {
1058             my $saving_required = 0;
1059             $reglocatfile = installer::files::read_file($reglocatfilename);
1060
1061             for ( my $i = 3; $i <= $#{$reglocatfile}; $i++ )    # ignoring the first three lines
1062             {
1063                 my $oneline = ${$reglocatfile}[$i];
1064
1065                 if ( $oneline =~ /^\s*\#/ ) { next; }   # this is a comment line
1066                 if ( $oneline =~ /^\s*$/ ) { next; }
1067
1068                 if ( $oneline =~ /^\s*(.*?)\t(.*?)\t(.*?)\t(.*?)\t(\d+)\s*$/ )
1069                 {
1070                     # Syntax: Signature_ Root Key Name Type
1071                     my $sig = $1;
1072                     my $root = $2;
1073                     my $key = $3;
1074                     my $name = $4;
1075                     my $type = $5;
1076
1077                     $type = $type + 16;
1078
1079                     my $newline = $sig . "\t" . $root . "\t" . $key . "\t" . $name . "\t" . $type . "\n";
1080                     ${$reglocatfile}[$i] = $newline;
1081
1082                     $saving_required = 1;
1083                 }
1084             }
1085
1086             if ( $saving_required )
1087             {
1088                 # Saving the files
1089                 installer::files::save_file($reglocatfilename ,$reglocatfile);
1090                 $infoline = "Making idt file 64 bit conform: $reglocatfilename\n";
1091                 push(@installer::globals::logfileinfo, $infoline);
1092             }
1093         }
1094
1095         # 2. Replacing all occurrences of "VersionNT" by "VersionNT64"
1096
1097         my @versionnt_files = ("Componen.idt", "InstallE.idt", "InstallU.idt", "LaunchCo.idt");
1098
1099         foreach my $onefile ( @versionnt_files )
1100         {
1101             my $fullfilename = $basedir . $installer::globals::separator . $onefile;
1102
1103             if ( -f $fullfilename )
1104             {
1105                 my $saving_required = 0;
1106                 $filecontent = installer::files::read_file($fullfilename);
1107
1108                 for ( my $i = 3; $i <= $#{$filecontent}; $i++ )     # ignoring the first three lines
1109                 {
1110                     my $oneline = ${$filecontent}[$i];
1111
1112                     if ( $oneline =~ /\bVersionNT\b/ )
1113                     {
1114                         ${$filecontent}[$i] =~ s/\bVersionNT\b/VersionNT64/g;
1115                         $saving_required = 1;
1116                     }
1117                 }
1118
1119                 if ( $saving_required )
1120                 {
1121                     # Saving the files
1122                     installer::files::save_file($fullfilename ,$filecontent);
1123                     $infoline = "Making idt file 64 bit conform: $fullfilename\n";
1124                     push(@installer::globals::logfileinfo, $infoline);
1125                 }
1126             }
1127         }
1128     }
1129
1130 }
1131
1132 #################################################################
1133 # Include all cab files into the msi database.
1134 # This works only on Windows
1135 #################################################################
1136
1137 sub include_cabs_into_msi
1138 {
1139     my ($installdir) = @_;
1140
1141     installer::logger::include_header_into_logfile("Including cabs into msi database");
1142
1143     my $from = cwd();
1144     my $to = $installdir;
1145
1146     chdir($to);
1147
1148     my $infoline = "Changing into directory: $to";
1149     push( @installer::globals::logfileinfo, $infoline);
1150
1151     my $msidb = "msidb.exe";    # Has to be in the path
1152     if ( $installer::globals::isunix )
1153     {
1154         $msidb = "$ENV{'WORKDIR_FOR_BUILD'}/LinkTarget/Executable/msidb.exe";
1155     }
1156     my $extraslash = "";        # Has to be set for non-ActiveState perl
1157
1158     my $msifilename = $installer::globals::msidatabasename;
1159
1160     $msifilename = installer::converter::make_path_conform($msifilename);
1161
1162     # msidb.exe really wants backslashes. (And double escaping because system() expands the string.)
1163     $msifilename =~ s/\//\\\\/g;
1164     $extraslash = "\\";
1165
1166     my $allcabfiles = installer::systemactions::find_file_with_file_extension("cab", $installdir);
1167
1168     for ( my $i = 0; $i <= $#{$allcabfiles}; $i++ )
1169     {
1170         my $systemcall = $msidb . " -d " . $msifilename . " -a " . ${$allcabfiles}[$i];
1171
1172         my $returnvalue = system($systemcall);
1173
1174         $infoline = "Systemcall: $systemcall\n";
1175         push( @installer::globals::logfileinfo, $infoline);
1176
1177         if ($returnvalue)
1178         {
1179             $infoline = "ERROR: Could not execute $systemcall !\n";
1180             push( @installer::globals::logfileinfo, $infoline);
1181         }
1182         else
1183         {
1184             $infoline = "Success: Executed $systemcall successfully!\n";
1185             push( @installer::globals::logfileinfo, $infoline);
1186         }
1187
1188         # deleting the cab file
1189
1190         unlink(${$allcabfiles}[$i]);
1191
1192         $infoline = "Deleted cab file: ${$allcabfiles}[$i]\n";
1193         push( @installer::globals::logfileinfo, $infoline);
1194     }
1195
1196     $infoline = "Changing back into directory: $from";
1197     push( @installer::globals::logfileinfo, $infoline);
1198
1199     chdir($from);
1200 }
1201
1202 #################################################################
1203 # Executing the created batch file to pack all files.
1204 # This works only on Windows
1205 #################################################################
1206
1207 sub execute_packaging
1208 {
1209     my ($localpackjobref, $loggingdir, $allvariables) = @_;
1210
1211     installer::logger::include_header_into_logfile("Packaging process");
1212
1213     installer::logger::include_timestamp_into_logfile("Performance Info: Execute packaging start");
1214
1215     my $infoline = "";
1216     my $from = cwd();
1217     my $to = $loggingdir;
1218
1219     chdir($to);
1220     $infoline = "chdir: $to \n";
1221     push( @installer::globals::logfileinfo, $infoline);
1222
1223     # the ddf file contains relative paths, it is necessary to change into the temp directory
1224     $to = $installer::globals::temppath;
1225     chdir($to);
1226     $infoline = "chdir: $to \n";
1227     push( @installer::globals::logfileinfo, $infoline);
1228
1229     my $maxmakecabcalls = 3;
1230     my $allmakecabcalls = $#{$localpackjobref} + 1;
1231
1232     for ( my $i = 0; $i <= $#{$localpackjobref}; $i++ )
1233     {
1234         my $systemcall = ${$localpackjobref}[$i];
1235
1236         my $callscounter = $i + 1;
1237
1238         installer::logger::print_message( "... makecab.exe ($callscounter/$allmakecabcalls) ... \n" );
1239
1240         for ( my $n = 1; $n <= $maxmakecabcalls; $n++ )
1241         {
1242             my @ddfoutput = ();
1243
1244             $infoline = "Systemcall: $systemcall";
1245             push( @installer::globals::logfileinfo, $infoline);
1246
1247             open (DDF, "$systemcall");
1248             while (<DDF>) {push(@ddfoutput, $_); }
1249             close (DDF);
1250
1251             my $returnvalue = $?;   # $? contains the return value of the systemcall
1252
1253             if ($returnvalue)
1254             {
1255                 if ( $n < $maxmakecabcalls )
1256                 {
1257                     installer::logger::print_message( "makecab_error (Try $n): Trying again \n" );
1258                     $infoline = "makecab_error (Try $n): $systemcall !";
1259                 }
1260                 else
1261                 {
1262                     installer::logger::print_message( "ERROR (Try $n): Abort packing \n" );
1263                     $infoline = "ERROR (Try $n): $systemcall !";
1264                 }
1265
1266                 push( @installer::globals::logfileinfo, $infoline);
1267
1268                 for ( my $m = 0; $m <= $#ddfoutput; $m++ )
1269                 {
1270                     if ( $ddfoutput[$m] =~ /(ERROR\:.*?)\s*$/ )
1271                     {
1272                         $infoline = $1 . "\n";
1273                         if ( $n < $maxmakecabcalls ) { $infoline =~ s/ERROR\:/makecab_error\:/i; }
1274                         installer::logger::print_message( $infoline );
1275                         push( @installer::globals::logfileinfo, $infoline);
1276                     }
1277                 }
1278
1279                 if ( $n == $maxmakecabcalls ) { installer::exiter::exit_program("ERROR: \"$systemcall\"!", "execute_packaging"); }
1280             }
1281             else
1282             {
1283                 $infoline = "Success (Try $n): $systemcall";
1284                 push( @installer::globals::logfileinfo, $infoline);
1285                 last;
1286             }
1287         }
1288     }
1289
1290     installer::logger::include_timestamp_into_logfile("Performance Info: Execute packaging end");
1291
1292     chdir($from);
1293     $infoline = "chdir: $from \n";
1294     push( @installer::globals::logfileinfo, $infoline);
1295 }
1296
1297 ###############################################################
1298 # Setting the global variables ProductCode and the UpgradeCode
1299 ###############################################################
1300
1301 sub set_global_code_variables
1302 {
1303     my ( $languagesref, $languagestringref, $allvariableshashref, $alloldproperties ) = @_;
1304
1305     # In the msi template directory a files "codes.txt" has to exist, in which the ProductCode
1306     # and the UpgradeCode for the product are defined.
1307     # The name "codes.txt" can be overwritten in Product definition with CODEFILENAME .
1308     # Default $installer::globals::codefilename is defined in parameter.pm.
1309
1310     if ( $allvariableshashref->{'CODEFILENAME'} )
1311     {
1312         $installer::globals::codefilename = $installer::globals::idttemplatepath  . $installer::globals::separator . $allvariableshashref->{'CODEFILENAME'};
1313         installer::files::check_file($installer::globals::codefilename);
1314     }
1315
1316     my $infoline = "Using Codes file: $installer::globals::codefilename \n";
1317     push( @installer::globals::logfileinfo, $infoline);
1318
1319     my $codefile = installer::files::read_file($installer::globals::codefilename);
1320
1321     my $onelanguage = "";
1322
1323     if ( $#{$languagesref} > 0 )    # more than one language
1324     {
1325         if (( $installer::globals::added_english ) && ( $#{$languagesref} == 1 )) # only multilingual because of added English
1326         {
1327             $onelanguage = ${$languagesref}[1];  # setting the first language, that is not english
1328         }
1329         else
1330         {
1331             if (( ${$languagesref}[1] =~ /jp/ ) ||
1332                 ( ${$languagesref}[1] =~ /ko/ ) ||
1333                 ( ${$languagesref}[1] =~ /zh/ ))
1334             {
1335                 $onelanguage = "multiasia";
1336             }
1337             else
1338             {
1339                 $onelanguage = "multiwestern";
1340             }
1341         }
1342     }
1343     else    # only one language
1344     {
1345         $onelanguage = ${$languagesref}[0];
1346     }
1347
1348     # ProductCode must not change, if Windows patches shall be applied
1349     if ( $installer::globals::updatedatabase )
1350     {
1351         $installer::globals::productcode = $alloldproperties->{'ProductCode'};
1352     }
1353     elsif ( $installer::globals::prepare_winpatch )
1354     {
1355         # ProductCode has to be specified in each language
1356         my $searchstring = "PRODUCTCODE";
1357         my $codeblock = installer::windows::idtglobal::get_language_block_from_language_file($searchstring, $codefile);
1358         $installer::globals::productcode = installer::windows::idtglobal::get_code_from_code_block($codeblock, $onelanguage);
1359     } else {
1360         my $guidref = get_guid_list(1, 1);  # only one GUID shall be generated
1361         ${$guidref}[0] =~ s/\s*$//;     # removing ending spaces
1362         $installer::globals::productcode = "\{" . ${$guidref}[0] . "\}";
1363     }
1364
1365     # UpgradeCode can take english as default, if not defined in specified language
1366
1367     $searchstring = "UPGRADECODE";  # searching in the codes.txt file
1368     $codeblock = installer::windows::idtglobal::get_language_block_from_language_file($searchstring, $codefile);
1369     $installer::globals::upgradecode = installer::windows::idtglobal::get_language_string_from_language_block($codeblock, $onelanguage, "");
1370
1371     if ( $installer::globals::upgradecode eq "" ) { installer::exiter::exit_program("ERROR: UpgradeCode not defined in $installer::globals::codefilename !", "set_global_code_variables"); }
1372
1373     $infoline = "Setting ProductCode to: $installer::globals::productcode \n";
1374     push( @installer::globals::logfileinfo, $infoline);
1375     $infoline = "Setting UpgradeCode to: $installer::globals::upgradecode \n";
1376     push( @installer::globals::logfileinfo, $infoline);
1377
1378     # Adding both variables into the variables array
1379
1380     $allvariableshashref->{'PRODUCTCODE'} = $installer::globals::productcode;
1381     $allvariableshashref->{'UPGRADECODE'} = $installer::globals::upgradecode;
1382
1383     $infoline = "Defined variable PRODUCTCODE: $installer::globals::productcode \n";
1384     push( @installer::globals::logfileinfo, $infoline);
1385
1386     $infoline = "Defined variable UPGRADECODE: $installer::globals::upgradecode \n";
1387     push( @installer::globals::logfileinfo, $infoline);
1388
1389 }
1390
1391 ###############################################################
1392 # Setting the product version used in property table and
1393 # upgrade table. Saving in global variable $msiproductversion
1394 ###############################################################
1395
1396 sub set_msiproductversion
1397 {
1398     my ( $allvariables ) = @_;
1399
1400     my $productversion = $allvariables->{'PACKAGEVERSION'};
1401
1402     if ( $productversion =~ /^\s*(\d+)\.(\d+)\.(\d+)\s*$/ )
1403     {
1404         $productversion = $1 . "\." . $2 . "\." . $3 . "\." . $installer::globals::buildid;
1405     }
1406
1407     $installer::globals::msiproductversion = $productversion;
1408
1409     # Setting $installer::globals::msimajorproductversion, to differ between old version in upgrade table
1410
1411     if ( $installer::globals::msiproductversion =~ /^\s*(\d+)\./ )
1412     {
1413         my $major = $1;
1414         $installer::globals::msimajorproductversion = $major . "\.0\.0";
1415     }
1416 }
1417
1418 #################################################################################
1419 # Including the msi product version into the bootstrap.ini, Windows only
1420 #################################################################################
1421
1422 sub put_msiproductversion_into_bootstrapfile
1423 {
1424     my ($filesref) = @_;
1425
1426     for ( my $i = 0; $i <= $#{$filesref}; $i++ )
1427     {
1428         my $onefile = ${$filesref}[$i];
1429
1430         if ( $onefile->{'gid'} eq "gid_Brand_Profile_Version_Ini" )
1431         {
1432             my $file = installer::files::read_file($onefile->{'sourcepath'});
1433
1434             for ( my $j = 0; $j <= $#{$file}; $j++ )
1435             {
1436                 ${$file}[$j] =~ s/\<msiproductversion\>/$installer::globals::msiproductversion/;
1437             }
1438
1439             installer::files::save_file($onefile->{'sourcepath'}, $file);
1440
1441             last;
1442         }
1443     }
1444 }
1445
1446 ####################################################################################
1447 # Updating the file Property.idt dynamically
1448 # Content:
1449 # Property Value
1450 ####################################################################################
1451
1452 sub update_reglocat_table
1453 {
1454     my ($basedir, $allvariables) = @_;
1455
1456     my $reglocatfilename = $basedir . $installer::globals::separator . "RegLocat.idt";
1457
1458     # Only do something, if this file exists
1459
1460     if ( -f $reglocatfilename )
1461     {
1462         my $reglocatfile = installer::files::read_file($reglocatfilename);
1463
1464         my $layername = "";
1465         if ( $allvariables->{'REGISTRYLAYERNAME'} )
1466         {
1467             $layername = $allvariables->{'REGISTRYLAYERNAME'};
1468         }
1469         else
1470         {
1471             for ( my $i = 0; $i <= $#{$reglocatfile}; $i++ )
1472             {
1473                 if ( ${$reglocatfile}[$i] =~ /\bLAYERNAMETEMPLATE\b/ )
1474                 {
1475                     installer::exiter::exit_program("ERROR: Variable \"REGISTRYLAYERNAME\" has to be defined", "update_reglocat_table");
1476                 }
1477             }
1478         }
1479
1480         if ( $layername ne "" )
1481         {
1482             # Updating the layername in
1483
1484             for ( my $i = 0; $i <= $#{$reglocatfile}; $i++ )
1485             {
1486                 ${$reglocatfile}[$i] =~ s/\bLAYERNAMETEMPLATE\b/$layername/;
1487             }
1488
1489             # Saving the file
1490             installer::files::save_file($reglocatfilename ,$reglocatfile);
1491             my $infoline = "Updated idt file: $reglocatfilename\n";
1492             push(@installer::globals::logfileinfo, $infoline);
1493         }
1494     }
1495 }
1496
1497
1498
1499 ####################################################################################
1500 # Updating the file RemoveRe.idt dynamically (RemoveRegistry.idt)
1501 # The name of the component has to be replaced.
1502 ####################################################################################
1503
1504 sub update_removere_table
1505 {
1506     my ($basedir) = @_;
1507
1508     my $removeregistryfilename = $basedir . $installer::globals::separator . "RemoveRe.idt";
1509
1510     # Only do something, if this file exists
1511
1512     if ( -f $removeregistryfilename )
1513     {
1514         my $removeregistryfile = installer::files::read_file($removeregistryfilename);
1515
1516         for ( my $i = 0; $i <= $#{$removeregistryfile}; $i++ )
1517         {
1518             for ( my $i = 0; $i <= $#{$removeregistryfile}; $i++ )
1519             {
1520                 ${$removeregistryfile}[$i] =~ s/\bREGISTRYROOTCOMPONENT\b/$installer::globals::registryrootcomponent/;
1521             }
1522         }
1523
1524         # Saving the file
1525         installer::files::save_file($removeregistryfilename ,$removeregistryfile);
1526         my $infoline = "Updated idt file: $removeregistryfilename \n";
1527         push(@installer::globals::logfileinfo, $infoline);
1528     }
1529 }
1530
1531 ##########################################################################
1532 # Reading saved mappings in Files.idt and Director.idt.
1533 # This is required, if installation sets shall be created,
1534 # that can be used for creation of msp files.
1535 ##########################################################################
1536
1537 sub read_saved_mappings
1538 {
1539     installer::logger::include_header_into_logfile("Reading saved mappings from older installation sets:");
1540
1541     installer::logger::include_timestamp_into_logfile("Performance Info: Reading saved mappings start");
1542
1543     if ( $installer::globals::previous_idt_dir )
1544     {
1545         my @errorlines = ();
1546         my $errorstring = "";
1547         my $error_occurred = 0;
1548         my $file_error_occurred = 0;
1549         my $dir_error_occurred = 0;
1550
1551         my $idtdir = $installer::globals::previous_idt_dir;
1552         $idtdir =~ s/\Q$installer::globals::separator\E\s*$//;
1553
1554         # Reading File.idt
1555
1556         my $idtfile = $idtdir . $installer::globals::separator . "File.idt";
1557         push( @installer::globals::globallogfileinfo, "\nAnalyzing file: $idtfile\n" );
1558         if ( ! -f $idtfile ) { push( @installer::globals::globallogfileinfo, "Warning: File $idtfile does not exist!\n" ); }
1559
1560         my $n = 0;
1561         open (F, "<$idtfile") || installer::exiter::exit_program("ERROR: Cannot open file $idtfile for reading", "read_saved_mappings");
1562         <F>; <F>; <F>;
1563         while (<F>)
1564         {
1565             m/^([^\t]+)\t([^\t]+)\t((.*)\|)?([^\t]*)/;
1566             print "OUT1: \$1: $1, \$2: $2, \$3: $3, \$4: $4, \$5: $5\n";
1567             next if ("$1" eq "$5") && (!defined($3));
1568             my $lc1 = lc($1);
1569
1570             if ( exists($installer::globals::savedmapping{"$2/$5"}))
1571             {
1572                 if ( ! $file_error_occurred )
1573                 {
1574                     $errorstring = "\nErrors in $idtfile: \n";
1575                     push(@errorlines, $errorstring);
1576                 }
1577                 $errorstring = "Duplicate savedmapping{" . "$2/$5}\n";
1578                 push(@errorlines, $errorstring);
1579                 $error_occurred = 1;
1580                 $file_error_occurred = 1;
1581             }
1582
1583             if ( exists($installer::globals::savedrevmapping{$lc1}))
1584             {
1585                 if ( ! $file_error_occurred )
1586                 {
1587                     $errorstring = "\nErrors in $idtfile: \n";
1588                     push(@errorlines, $errorstring);
1589                 }
1590                 $errorstring = "Duplicate savedrevmapping{" . "$lc1}\n";
1591                 push(@errorlines, $errorstring);
1592                 $error_occurred = 1;
1593                 $file_error_occurred = 1;
1594             }
1595
1596             my $shortname = $4 || '';
1597
1598             # Don't reuse illegal 8.3 mappings that we used to generate in 2.0.4
1599             if (index($shortname, '.') > 8 ||
1600                 (index($shortname, '.') == -1 && length($shortname) > 8))
1601             {
1602                 $shortname = '';
1603             }
1604
1605             if (( $shortname ne '' ) && ( index($shortname, '~') > 0 ) && ( exists($installer::globals::savedrev83mapping{$shortname}) ))
1606             {
1607                 if ( ! $file_error_occurred )
1608                 {
1609                     $errorstring = "\nErrors in $idtfile: \n";
1610                     push(@errorlines, $errorstring);
1611                 }
1612                 $errorstring = "Duplicate savedrev83mapping{" . "$shortname}\n";
1613                 push(@errorlines, $errorstring);
1614                 $error_occurred = 1;
1615                 $file_error_occurred = 1;
1616             }
1617
1618             $installer::globals::savedmapping{"$2/$5"} = "$1;$shortname";
1619             $installer::globals::savedrevmapping{lc($1)} = "$2/$5";
1620             $installer::globals::savedrev83mapping{$shortname} = "$2/$5" if $shortname ne '';
1621             $n++;
1622         }
1623
1624         close (F);
1625
1626         push( @installer::globals::globallogfileinfo, "Read $n old file table key or 8.3 name mappings from $idtfile\n" );
1627
1628         # Reading Director.idt
1629
1630         $idtfile = $idtdir . $installer::globals::separator . "Director.idt";
1631         push( @installer::globals::globallogfileinfo, "\nAnalyzing file $idtfile\n" );
1632         if ( ! -f $idtfile ) { push( @installer::globals::globallogfileinfo, "Warning: File $idtfile does not exist!\n" ); }
1633
1634         $n = 0;
1635         open (F, "<$idtfile") || installer::exiter::exit_program("ERROR: Cannot open file $idtfile for reading", "read_saved_mappings");
1636         <F>; <F>; <F>;
1637         while (<F>)
1638         {
1639             m/^([^\t]+)\t([^\t]+)\t(([^~]+~\d.*)\|)?([^\t]*)/;
1640             next if (!defined($3));
1641             my $lc1 = lc($1);
1642
1643             print "OUT2: \$1: $1, \$2: $2, \$3: $3\n";
1644
1645             if ( exists($installer::globals::saved83dirmapping{$1}) )
1646             {
1647                 if ( ! $dir_error_occurred )
1648                 {
1649                     $errorstring = "\nErrors in $idtfile: \n";
1650                     push(@errorlines, $errorstring);
1651                 }
1652                 $errorstring = "Duplicate saved83dirmapping{" . "$1}\n";
1653                 push(@errorlines, $errorstring);
1654                 $error_occurred = 1;
1655                 $dir_error_occurred = 1;
1656             }
1657
1658             $installer::globals::saved83dirmapping{$1} = $4;
1659             $n++;
1660         }
1661         close (F);
1662
1663         push( @installer::globals::globallogfileinfo, "Read $n old directory 8.3 name mappings from $idtfile\n" );
1664
1665         # Analyzing errors
1666
1667         if ( $error_occurred )
1668         {
1669             for ( my $i = 0; $i <= $#errorlines; $i++ )
1670             {
1671                 print "$errorlines[$i]";
1672                 push( @installer::globals::globallogfileinfo, "$errorlines[$i]");
1673             }
1674             installer::exiter::exit_program("ERROR: Duplicate entries in saved mappings!", "read_saved_mappings");
1675         }
1676     } else {
1677         installer::exiter::exit_program("ERROR: Windows patch shall be prepared, but environment variable PREVIOUS_IDT_DIR is not set!", "read_saved_mappings");
1678     }
1679
1680     installer::logger::include_timestamp_into_logfile("Performance Info: Reading saved mappings end");
1681 }
1682
1683 1;
1684
1685 # vim:set shiftwidth=4 softtabstop=4 expandtab: