xref: /trunk/main/solenv/bin/modules/installer/windows/registry.pm (revision d62abd1a)

#**************************************************************
#
#  Licensed to the Apache Software Foundation (ASF) under one
#  or more contributor license agreements.  See the NOTICE file
#  distributed with this work for additional information
#  regarding copyright ownership.  The ASF licenses this file
#  to you under the Apache License, Version 2.0 (the
#  "License"); you may not use this file except in compliance
#  with the License.  You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing,
#  software distributed under the License is distributed on an
#  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
#  KIND, either express or implied.  See the License for the
#  specific language governing permissions and limitations
#  under the License.
#
#**************************************************************



package installer::windows::registry;

use installer::files;
use installer::globals;
use installer::worker;
use installer::windows::msiglobal;
use installer::windows::idtglobal;

use strict;

#####################################################
# Generating the component name from a registryitem
#####################################################

sub get_registry_component_name
{
	my ($registryref, $allvariables) = @_;

	# In this function exists the rule to create components from registryitems
	# Rule:
	# The componentname can be directly taken from the ModuleID.
	# All registryitems belonging to one module can get the same component.

	my $componentname = "";
	my $isrootmodule = 0;

	if ($registryref->{'ModuleID'})
    {
        $componentname = $registryref->{'ModuleID'};
    }

	$componentname =~ s/\\/\_/g;
	$componentname =~ s/\//\_/g;
	$componentname =~ s/\-/\_/g;
	$componentname =~ s/\_\s*$//g;

	$componentname = lc($componentname);	# componentnames always lowercase

	if ( $componentname eq "gid_module_root" )
    {
        $isrootmodule = 1;
    }

	# Attention: Maximum length for the componentname is 72

	# identifying this component as registryitem component
	$componentname = "registry_" . $componentname;

	$componentname =~ s/gid_module_/g_m_/g;
	$componentname =~ s/_optional_/_o_/g;
	$componentname =~ s/_javafilter_/_jf_/g;

	# This componentname must be more specific
	my $addon = "_";
	if ($allvariables->{'PRODUCTNAME'})
    {
        $addon .= $allvariables->{'PRODUCTNAME'};
    }

    # Append the version number.
    # Previously that was the full version number as provided by 'PRODUCTVERSION'.
    # But MSI patches introduce the restriction that component names must not change.
    # Use just the major version number.
    my $version = $allvariables->{"BRANDPACKAGEVERSION"};
    $version = "" unless defined $version;
    $addon .= $version;
	$addon = lc($addon);
	$addon =~ s/ //g;
	$addon =~ s/-//g;
	$addon =~ s/\.//g;

	$componentname = $componentname . $addon;

	my $styles = $registryref->{'Styles'};
	if (defined $styles)
    {
        if (($styles =~ /\bLANGUAGEPACK\b/) && $installer::globals::languagepack)
        {
            $componentname .= "_lang";
        }
        if ($styles =~ /\bALWAYS_REQUIRED\b/)
        {
            $componentname .= "_forced";
        }
    }

	# Attention: Maximum length for the componentname is 72
	# %installer::globals::allregistrycomponents_in_this_database_ : resetted for each database
	# %installer::globals::allregistrycomponents_ : not resetted for each database
	# Component strings must be unique for the complete product, because they are used for
	# the creation of the globally unique identifier.

	my $fullname = $componentname;  # This can be longer than 72

	if (exists($installer::globals::allregistrycomponents_{$fullname})
        && ! exists($installer::globals::allregistrycomponents_in_this_database_{$fullname}))
	{
		# This is not allowed: One component cannot be installed with different packages.
		installer::exiter::exit_program(
            "ERROR: Windows registry component \"$fullname\" is already included into another package. This is not allowed.",
            "get_registry_component_name");
	}

	if ( exists($installer::globals::allregistrycomponents_{$fullname}) )
	{
		$componentname = $installer::globals::allregistrycomponents_{$fullname};
	}
	else
	{
		if ( length($componentname) > 70 )
		{
			$componentname = generate_new_short_registrycomponentname($componentname); # This has to be unique for the complete product, not only one package
		}

		$installer::globals::allregistrycomponents_{$fullname} = $componentname;
		$installer::globals::allregistrycomponents_in_this_database_{$fullname} = 1;
	}

	if ( $isrootmodule )
    {
        $installer::globals::registryrootcomponent = $componentname;
    }

	return $componentname;
}

#########################################################
# Create a shorter version of a long component name,
# because maximum length in msi database is 72.
# Attention: In multi msi installation sets, the short
# names have to be unique over all packages, because
# this string is used to create the globally unique id
# -> no resetting of
# %installer::globals::allshortregistrycomponents
# after a package was created.
#########################################################

sub generate_new_short_registrycomponentname
{
	my ($componentname) = @_;

	my $startversion = substr($componentname, 0, 60); # taking only the first 60 characters
	my $subid = installer::windows::msiglobal::calculate_id($componentname, 9); # taking only the first 9 digits
	my $shortcomponentname = $startversion . "_" . $subid;

	if ( exists($installer::globals::allshortregistrycomponents{$shortcomponentname}) ) { installer::exiter::exit_program("Failed to create unique component name: \"$shortcomponentname\"", "generate_new_short_registrycomponentname"); }

	$installer::globals::allshortregistrycomponents{$shortcomponentname} = 1;

	return $shortcomponentname;
}

##############################################################
# Returning identifier for registry table.
##############################################################

sub get_registry_identifier
{
	my ($registry) = @_;

	my $identifier = "";

	if ( $registry->{'gid'} ) { $identifier = $registry->{'gid'}; }

	$identifier = lc($identifier);	# always lower case

	# Attention: Maximum length is 72

	$identifier =~ s/gid_regitem_/g_r_/;
	$identifier =~ s/_soffice_/_s_/;
	$identifier =~ s/_clsid_/_c_/;
	$identifier =~ s/_currentversion_/_cv_/;
	$identifier =~ s/_microsoft_/_ms_/;
	$identifier =~ s/_manufacturer_/_mf_/;
	$identifier =~ s/_productname_/_pn_/;
	$identifier =~ s/_productversion_/_pv_/;
	$identifier =~ s/_staroffice_/_so_/;
	$identifier =~ s/_software_/_sw_/;
	$identifier =~ s/_capabilities_/_cap_/;
	$identifier =~ s/_classpath_/_cp_/;
	$identifier =~ s/_extension_/_ex_/;
	$identifier =~ s/_fileassociations_/_fa_/;
	$identifier =~ s/_propertysheethandlers_/_psh_/;
	$identifier =~ s/__/_/g;

	# Saving this in the registry collector

	$registry->{'uniquename'} = $identifier;

	return $identifier;
}

##################################################################
# Returning root value for registry table.
##################################################################

sub get_registry_root
{
	my ($registry) = @_;

	my $rootvalue = 0;	# Default: Parent is KKEY_CLASSES_ROOT
	my $scproot = "";

	if ( $registry->{'ParentID'} ) { $scproot = $registry->{'ParentID'}; }

	if ( $scproot eq "PREDEFINED_HKEY_LOCAL_MACHINE" ) { $rootvalue = -1; }

	if ( $scproot eq "PREDEFINED_HKEY_CLASSES_ROOT" ) { $rootvalue = 0; }

	if ( $scproot eq "PREDEFINED_HKEY_CURRENT_USER_ONLY" ) { $rootvalue = 1; }

	if ( $scproot eq "PREDEFINED_HKEY_LOCAL_MACHINE_ONLY" ) { $rootvalue = 2; }

	return $rootvalue;
}

##############################################################
# Returning key for registry table.
##############################################################

sub get_registry_key
{
	my ($registry, $allvariableshashref) = @_;

	my $key = "";

	if ( $registry->{'Subkey'} ) { $key = $registry->{'Subkey'}; }

	if ( $key =~ /\%/ ) { $key = installer::worker::replace_variables_in_string($key, $allvariableshashref); }

	return $key;
}

##############################################################
# Returning name for registry table.
##############################################################

sub get_registry_name
{
	my ($registry, $allvariableshashref) = @_;

	my $name = "";

	if ( $registry->{'Name'} ) { $name = $registry->{'Name'}; }

	if ( $name =~ /\%/ ) { $name = installer::worker::replace_variables_in_string($name, $allvariableshashref); }

	return $name;
}

##############################################################
# Returning value for registry table.
##############################################################

sub get_registry_value
{
	my ($registry, $allvariableshashref) = @_;

	my $value = "";

	if ( $registry->{'Value'} ) { $value = $registry->{'Value'}; }

	$value =~ s/\\\"/\"/g;	# no more masquerading of '"'
	$value =~ s/\\\\\s*$/\\/g;	# making "\\" at end of value to "\"
	$value =~ s/\<progpath\>/\[INSTALLLOCATION\]/;
	$value =~ s/\[INSTALLLOCATION\]\\/\[INSTALLLOCATION\]/;	# removing "\" after "[INSTALLLOCATION]"

	if ( $value =~ /\%/ ) { $value = installer::worker::replace_variables_in_string($value, $allvariableshashref); }

	return $value;
}

##############################################################
# Returning 64 bit value for registry table.
##############################################################

sub get_registry_val64
{
	my ($registry, $allvariableshashref) = @_;

	my $value = "";

	if ( $registry->{'Val64'} ) { $value = $registry->{'Val64'}; }

	$value =~ s/\\\"/\"/g;	# no more masquerading of '"'
	$value =~ s/\\\\\s*$/\\/g;	# making "\\" at end of value to "\"
	$value =~ s/\<progpath\>/\[INSTALLLOCATION\]/;
	$value =~ s/\[INSTALLLOCATION\]\\/\[INSTALLLOCATION\]/;	# removing "\" after "[INSTALLLOCATION]"

	if ( $value =~ /\%/ ) { $value = installer::worker::replace_variables_in_string($value, $allvariableshashref); }

	return $value;
}


######################################################
# Adding the content of
# @installer::globals::userregistrycollector
# to the registry table. The content was collected
# in create_files_table() in file.pm.
######################################################

sub add_userregs_to_registry_table
{
	my ( $registrytable, $allvariables ) = @_;

	for ( my $i = 0; $i <= $#installer::globals::userregistrycollector; $i++ )
	{
		my $onefile = $installer::globals::userregistrycollector[$i];

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

		my %registry = ();

		$registry{'Registry'} = $onefile->{'userregkeypath'};
		$registry{'Root'} = "1";  # always HKCU
		$registry{'Key'} = "Software\\$allvariables->{'MANUFACTURER'}\\$allvariables->{'PRODUCTNAME'} $allvariables->{'PRODUCTVERSION'}\\";
		if ( $onefile->{'needs_user_registry_key'} ) { $registry{'Key'} = $registry{'Key'} . "StartMenu"; }
		else { $registry{'Key'} = $registry{'Key'} . "ShellNew"; }
		$registry{'Name'} = $onefile->{'Name'};
		$registry{'Value'} = "1";
		$registry{'Component_'} = $onefile->{'componentname'};

		my $oneline = $registry{'Registry'} . "\t" . $registry{'Root'} . "\t" . $registry{'Key'} . "\t"
					. $registry{'Name'} . "\t" . $registry{'Value'} . "\t" . $registry{'Component_'} . "\n";

		push(@{$registrytable}, $oneline);
	}
}

######################################################
# Creating the file Registry.idt dynamically
# Content:
# Registry Root Key Name Value Component_
######################################################
sub prepare_registry_table ($$$)
{
	my ($registryref, $languagesarrayref, $allvariableshashref) = @_;

    my %table_data = ();
	foreach my $onelanguage (@$languagesarrayref)
	{
        my $table_items = [];
		foreach my $oneregistry (@$registryref)
		{
			# Controlling the language!
			# Only language independent folderitems or folderitems with the correct language
			# will be included into the table

			next if $oneregistry->{'ismultilingual'}
                && $oneregistry->{'specificlanguage'} ne $onelanguage;

			my %registry = ();

			$registry{'Registry'} = get_registry_identifier($oneregistry);
			$registry{'Root'} = get_registry_root($oneregistry);
			$registry{'Key'} = get_registry_key($oneregistry, $allvariableshashref);
			$registry{'Name'} = get_registry_name($oneregistry, $allvariableshashref);
			$registry{'Value'} = get_registry_value($oneregistry, $allvariableshashref);
			$registry{'Val64'} = get_registry_val64($oneregistry, $allvariableshashref);
            my $component_name = get_registry_component_name($oneregistry, $allvariableshashref);
            $oneregistry->{'componentname'} = $component_name;
			$registry{'Component_'} = $component_name;

			# Collecting all components with DONT_DELETE style
			my $style = $oneregistry->{'Styles'};
            $style = "" unless defined $style;
            $registry{'styles'} = $style;

			if ( $style =~ /\bDONT_DELETE\b/ )
            {
                $installer::globals::dontdeletecomponents{$component_name} = 1;
            }

			# Saving upgradekey to write this into setup.ini for minor upgrades
			if ( $style =~ /\bUPGRADEKEY\b/ )
            {
                $installer::globals::minorupgradekey = $registry{'Key'};
            }

			# Collecting all registry components with ALWAYS_REQUIRED style
			if ( ! ( $style =~ /\bALWAYS_REQUIRED\b/ ))
			{
				# Setting a component condition for unforced registry components!
				# Only write into registry, if WRITE_REGISTRY is set.
				if ( $oneregistry->{'ComponentCondition'} ) { $oneregistry->{'ComponentCondition'} = "(" . $oneregistry->{'ComponentCondition'} . ") AND (WRITE_REGISTRY=1)"; }
				else { $oneregistry->{'ComponentCondition'} = "WRITE_REGISTRY=1"; }
			}

			# Collecting all component conditions
			if ( $oneregistry->{'ComponentCondition'} )
			{
				if ( ! exists($installer::globals::componentcondition{$registry{'Component_'}}))
				{
					$installer::globals::componentcondition{$registry{'Component_'}} = $oneregistry->{'ComponentCondition'};
				}
			}

            push @$table_items, \%registry;
		}
        $table_data{$onelanguage} = $table_items;
    }

    return \%table_data;
}




sub collect_registry_components ($)
{
    my ($table_data) = @_;

    my %components = ();
    foreach my $language_data (values %$table_data)
    {
        foreach my $item (@$language_data)
        {
			$components{$item->{'Component_'}} = 1;
        }
    }
    return keys %components;
}




sub translate_component_names ($$$)
{
    my ($translation_map, $registry_items, $table_data) = @_;

    my $replacement_count = 0;
    foreach my $item (@$registry_items)
    {
        my $translated_name = $translation_map->{$item->{'componentname'}};
        if (defined $translated_name)
        {
            $item->{'componentname'} = $translated_name;
            ++$replacement_count;
        }
    }
    $installer::logger::Lang->printf("replaced %d component names in registry items\n", $replacement_count);

    $replacement_count = 0;
    foreach my $language_data (values %$table_data)
    {
        foreach my $item (@$language_data)
        {
            my $translated_name = $translation_map->{$item->{'Component_'}};
            if (defined $translated_name)
            {
                $item->{'Component_'} = $translated_name;
                ++$replacement_count;
            }
        }
    }
    $installer::logger::Lang->printf("replaced %d component names in registry table\n", $replacement_count);
}




sub create_registry_table_32 ($$$$)
{
	my ($basedir, $languagesarrayref, $allvariableshashref, $table_data) = @_;

	foreach my $onelanguage (@$languagesarrayref)
	{
		my @registrytable = ();
        installer::windows::idtglobal::write_idt_header(\@registrytable, "registry");

		foreach my $item (@{$table_data->{$onelanguage}})
		{
			next if $item->{'styles'} =~ /\bX64_ONLY\b/;

			my $oneline = join("\t",
                $item->{'Registry'},
                $item->{'Root'},
                $item->{'Key'},
                $item->{'Name'},
                $item->{'Value'},
                $item->{'Component_'})
                . "\n";

            push(@registrytable, $oneline);
		}

		# If there are added user registry keys for files collected in
		# @installer::globals::userregistrycollector (file.pm), then
		# this registry keys have to be added now. This is necessary for
		# files in PREDEFINED_OSSHELLNEWDIR, because their component
		# needs as KeyPath a RegistryItem in HKCU.

		if ( $installer::globals::addeduserregitrykeys )
        {
            add_userregs_to_registry_table(\@registrytable, $allvariableshashref);
        }

		# Save the database file.
		my $registrytablename = $basedir . $installer::globals::separator . "Registry.idt" . "." . $onelanguage;
		installer::files::save_file($registrytablename ,\@registrytable);
        $installer::logger::Lang->printf("Created idt file: %s\n", $registrytablename);
	}
}




sub create_registry_table_64 ($$$$)
{
	my ($basedir, $languagesarrayref, $allvariableshashref, $table_data) = @_;

	foreach my $onelanguage (@$languagesarrayref)
	{
        my @reg64table = ();
		installer::windows::idtglobal::write_idt_header(\@reg64table, "reg64");
		foreach my $item (@{$table_data->{$onelanguage}})
        {
			next unless $item->{'styles'} =~ /\b(X64|X64_ONLY)\b/;

            my $oneline64 = join("\t",
                $item->{'Registry'},
                $item->{'Root'},
                $item->{'Key'},
                $item->{'Name'},
                $item->{'Val64'},
                $item->{'Component_'})
                . "\n";

            push(@reg64table , $oneline64);
        }

        # Save the database file.
		my $registrytablename = $basedir . $installer::globals::separator . "Reg64.idt" . "." . $onelanguage;
		installer::files::save_file($registrytablename ,\@reg64table );
        $installer::logger::Lang->printf("Created idt file: %s\n", $registrytablename);
	}
}

1;