Subversion Repositories DevTools

########################################################################

########################################################################

# Copyright (C) 1998-2013 Vix Technology, All rights reserved

# COPYRIGHT - VIX IP PTY LTD ("VIX"). ALL RIGHTS RESERVED.

#

#

# Module name   : DebianPackager.pl

# Module name   : DebianPackager.pl

# Module type   : Makefile system

# Module type   : Makefile system

# Compiler(s)   : Perl

# Compiler(s)   : Perl

# Environment(s): jats

# Environment(s): jats

#

#

# Description   : This program is invoked by the MakeDebianPackage

# Description   : This program is invoked by the MakeDebianPackage and MakeRpmPackage

#                 directive, that is a part of this package

#                 directive that is a part of this package

#

#

#                 The program will use a user-provided script in order

#                 The program will use a user-provided script in order

#                 to create a Debian Package.

#                 to create the output Package.

#

#

#                 The user script may call a number of directives in order to

#                 The user script may call a number of directives in order to

#                 construct an image of the package being installed.

#                 construct an image of the package being installed.

#

#

#                 The script specifies Debian configuration scaripts that

#                 The script specifies Debian/RPM configuration scripts that

#                 will be embedded in the package.

#                 will be embedded in the package.

#

#

#                 This program will:

#                 This program will:

#                   Construct a filesystem image under control of the directives

#                   Construct a filesystem image under control of the directives

#                   within the user script

#                   within the user script

#

#

#                   Massage the Debian control file

#                   Debian:

#

#                       Massage the Debian control file

#                   Create a Debian Package

#                       Create a Debian Package

#

#                       Transfer it to the users 'BIN' directory, where it is available to be packaged.

#                   Transfer it to the users 'BIN' directory, where it is

#                       

#                   available to be packaged.

#                   RedHat Package:    

#

#                       Generate rpmBuilder control files

#                 Summary of directives available to the user-script:

#                       Create the RPM image

#                       Message                 - Display progress text

#                       Transfer it to the users 'BIN' directory, where it is available to be packaged.

#                       AddInitScript           - Add an init script

#                   

#                       CatFile                 - Append to a file

#                   TarFile:

#                       ConvertFile             - Convert file(s) to Unix or Dos Text

#                       Tar Gzip the image

#                       CopyDir                 - Copy directory tree

#                       Transfer it to the users 'BIN' directory, where it is available to be packaged.

#                       CopyFile                - Copy a file

#

#                       CopyBinFile             - Copy an executable file

#                 Summary of directives available to the user-script:

#                       CopyLibFile             - Copy a library file

#                       Message                 - Display progress text

#                       CopyDebPackage          - Copy a Debian Package

#                       Verbose                 - Display progress text

#                       CreateDir               - Create a directory

#                       AddInitScript           - Add an init script

#                       DebianFiles             - Specify control and script files

#                       CatFile                 - Append to a file

#                       DebianControlFile       - Specify control and script files

#                       ConvertFile             - Convert file(s) to Unix or Dos Text

#                       DebianDepends           - Add Depends entry to control file

#                       CopyDir                 - Copy directory tree

#                       EchoFile                - Place text into a file

#                       CopyFile                - Copy a file

#                       MakeSymLink             - Create a symbolic link

#                       CopyBinFile             - Copy an executable file

#                       PackageDescription      - Specify the package description

#                       CopyLibFile             - Copy a library file

#                       ReplaceTags             - Replace Tags on target file

#                       CopyDebPackage          - Copy a Debian Package

#                       SetFilePerms            - Set file permissions

#                       CreateDir               - Create a directory

#                       SetVerbose              - Control progress display

#                       AllFiles                - Specify control and script files 

#                       IsProduct               - Flow control

#                       DebianFiles             - Specify control and script files (Debian Only)

#                       IsPlatform              - Flow control

#                       RpmFiles                - Specify control and script files (RPM Only)

#                       IsTarget                - Flow control

#                       AllControlFile          - Specify control and script files

#                       IsVariant               - Flow control

#                       DebianControlFile       - Specify control and script files (Debian Only)

#                       IsAlias                 - Flow control

#                       RpmControlFile          - Specify control and script files (RPM Only)

#

#                       AllDepends              - Add Depends entry to control file

#                 Thoughts for expansion:

#                       DebianDepends           - Add Depends entry to control file (Debian Only)

#                       SrcDir                  - Extend path for resolving local files

#                       RpmDepends              - Add Depends entry to control file (RPM Only)

#

#                       EchoFile                - Place text into a file

#                   Less used:

#                       MakeSymLink             - Create a symbolic link

#                        ExpandLinkFiles        - Expand .LINK files

#                       PackageDescription      - Specify the package description

#

#                       ReplaceTags             - Replace Tags on target file

#                   Internal Use:

#                       SetFilePerms            - Set file permissions

#                        FindFiles              - Find a file

#                       SetVerbose              - Control progress display

#                        ResolveFile            - Resolve a 'local' source file

#                       IsProduct               - Flow control

#                        chmodItem              - Set file or directory permissions

#                       IsPlatform              - Flow control

#                        

#                       IsTarget                - Flow control

#......................................................................#

#                       IsVariant               - Flow control

#                       IsAlias                 - Flow control

require 5.006_001;

#                       RpmSetDefAttr           - Specify default file properties (RPM Only)

use strict;

#                       RpmSetAttr              - Specify file properties (RPM Only)    

use warnings;

#                       SetBaseDir              - Sets base for installed files (RPM Hint for directory ownership)

#                       Section                 - Set current section

use Getopt::Long;

#                       PackageVersion          - Return the version of a named package

use File::Path;

#                       ExtractTar              - Extract a tar file into the target

use File::Copy;

#

use File::Find;

#                 Thoughts for expansion:

use JatsSystem;

#                       SrcDir                  - Extend path for resolving local files

use FileUtils;

#

use JatsError;

#                   Less used:

use JatsLocateFiles;

#                        ExpandLinkFiles        - Expand .LINK files

use ReadBuildConfig;

#

use JatsCopy ();                            # Don't import anything

#                   Internal Use:

#                        FindFiles              - Find a file

#

#                        ResolveFile            - Resolve a 'local' source file

#   Globals

#                        chmodItem              - Set file or directory permissions

#

#                        

my $DebianWorkDirBase;                      # Workspace

#......................................................................#

my $DebianWorkDir;                          # Dir to create file system image within

require 5.006_001;

#

use strict;

#   Command line options

use warnings;

#

my $opt_debug   = $ENV{'GBE_DEBUG'};        # Allow global debug

use Getopt::Long;

my $opt_verbose = $ENV{'GBE_VERBOSE'};      # Allow global verbose

use File::Path;

my $opt_vargs;                              # Verbose arg

use File::Copy;

my $opt_help = 0;

use File::Find;

my $opt_manual = 0;

use JatsSystem;

my $opt_clean = 0;

use FileUtils;

my $opt_interfacedir;

use ArrayHashUtils;

my $opt_package_script;

use JatsError;

my $opt_interfaceincdir;

use JatsLocateFiles;

my $opt_interfacelibdir;

use ReadBuildConfig;

my $opt_interfacebindir;

use JatsCopy ();                            # Don't import anything

my $opt_libdir;

use PackagerUtils;

my $opt_bindir;

my $opt_localincdir;

#

my $opt_locallibdir;

#   Command line options

my $opt_localbindir;

#

my $opt_pkgdir;

my $opt_debug   = $ENV{'GBE_DEBUG'};        # Allow global debug

my $opt_pkglibdir;

my $opt_verbose = $ENV{'GBE_VERBOSE'};      # Allow global verbose

my $opt_pkgbindir;

my $opt_vargs;                              # Verbose arg

my $opt_pkgpkgdir;

my $opt_help = 0;

my $opt_output;

my $opt_manual = 0;

my $opt_tarFile;

my $opt_clean = 0;

my $opt_noarch;

my $opt_interfacedir;

my $opt_package_script;

#

my $opt_interfaceincdir;

#   Options marked as 'our' so that they are visible within the users script

my $opt_interfacelibdir;

#   Don't give the user too much

my $opt_interfacebindir;

#

my $opt_libdir;

our $opt_platform;

my $opt_bindir;

our $opt_type;

my $opt_localincdir;

our $opt_buildname;

my $opt_locallibdir;

our $opt_buildversion;

my $opt_localbindir;

our $opt_target;

my $opt_pkgdir;

our $opt_product;

my $opt_pkglibdir;

our $opt_name;

my $opt_pkgbindir;

our $opt_variant;

my $opt_pkgpkgdir;

our $opt_pkgarch;

my $opt_noarch;

my $opt_tarFile;

#

my $opt_tarOnly;

#   Options derived from script directives

my $opt_rpm = 0;

#

my $opt_debian = 0;

my $opt_description;

my $opt_output;

#

#

#   Globals

#   Options marked as 'our' so that they are visible within the users script

#

#   Don't give the user too much

my @ResolveFileList;                    # Cached Package File List

#

my @ResolveBinFileList;                 # Cached PackageBin File List

our $opt_platform;

my @ResolveDebFileList;                 # Cached PackageDeb File List

our $opt_type;

my @ResolveLibFileList;                 # Cached PackageLib File List

our $opt_buildname;

my %DebianControlFiles;                 # Control Files

our $opt_buildversion;

my %DebianControlFileNames;             # Control Files by name

our $opt_target;

my @DependencyList;                     # Package Dependencies

our $opt_product;

my @ConfigList;                         # Config Files

our $opt_name;

my %opt_aliases;                        # Cached Alias Names

our $opt_variant;

our $opt_pkgarch;

#-------------------------------------------------------------------------------

our $opt_rpmRelease = '';

# Function        : Main Entry point

#

#

# Description     : This function will be called when the package is initialised

#   Options derived from script directives

#                   Extract arguments from the users environment

#

#

my $opt_description;

#                   Done here to greatly simplify the user script

my $opt_specFile;

#                   There should be no junk in the user script - keep it simple

#

#

# Inputs          :

#   Globals

#

#

# Returns         : 

my $WorkDirBase;                            # Workspace

#

my $WorkDirInit;                            # Initial Dir to create file system image within

main();

my $WorkDir;                                # Dir to create file system image within

sub main

my $WorkSubDir = '';                        # Diff between $WorkDirInit and $WorkDir

{

my @ResolveFileList;                        # Cached Package File List

    my $result = GetOptions (

my @ResolveBinFileList;                     # Cached PackageBin File List

                "verbose:s"         => \$opt_vargs,

my @ResolveDebFileList;                     # Cached PackageDeb File List

                "clean"             => \$opt_clean,

my @ResolveLibFileList;                     # Cached PackageLib File List

                "Type=s"            => \$opt_type,

my %ControlFiles;                           # Control Files

                "BuildName=s"       => \$opt_buildname,                     # Raw Jats Package Name (Do not use)

my %ControlFileNames;                       # Control Files by name

                "Name=s"            => \$opt_name,                          # Massaged Debian Package Name

my @DependencyList;                         # Package Dependencies

                "BuildVersion=s"    => \$opt_buildversion,

my @ConfigList;                             # Config Files

                "Platform=s"        => \$opt_platform,

my %opt_aliases;                            # Cached Alias Names

                "Target=s"          => \$opt_target,

my @RpmDefAttr = ('-','root','root','-');   # RPM: Default File Attributes

                "Product=s"         => \$opt_product,

my @RpmAttrList;                            # RPM: File attributes

                "DebianPackage=s"   => \$opt_package_script,

my %OwnedDirs;                              # RPM: Dirs marked as owned

                "InterfaceDir=s"    => \$opt_interfacedir,

my $ActiveSection = 1;                      # Indicates if the section is active

                "InterfaceIncDir=s" => \$opt_interfaceincdir,

                "InterfaceLibDir=s" => \$opt_interfacelibdir,

#-------------------------------------------------------------------------------

                "InterfaceBinDir=s" => \$opt_interfacebindir,

# Function        : Main Entry point

                "LibDir=s"          => \$opt_libdir,

#

                "BinDir=s"          => \$opt_bindir,

# Description     : This function will be called when the package is initialised

                "LocalIncDir=s"     => \$opt_localincdir,

#                   Extract arguments from the users environment

                "LocalLibDir=s"     => \$opt_locallibdir,

#

                "LocalBinDir=s"     => \$opt_localbindir,

#                   Done here to greatly simplify the user script

                "PackageDir=s"      => \$opt_pkgdir,

#                   There should be no junk in the user script - keep it simple

                "PackageLibDir=s"   => \$opt_pkglibdir,

#

                "PackageBinDir=s"   => \$opt_pkgbindir,

# Inputs          :

                "PackagePkgDir=s"   => \$opt_pkgpkgdir,

#

                "Output=s"          => \$opt_output,

# Returns         : 

                "tarFile=s"         => \$opt_tarFile,

#

                "Variant:s"         => \$opt_variant,

main();

                "PkgArch:s"         => \$opt_pkgarch,

sub main

                "NoArch"            => \$opt_noarch,

{

    );

    my $result = GetOptions (

    $opt_verbose++ unless ( $opt_vargs eq '@' );

                'verbose:s'         => \$opt_vargs,

                'clean'             => \$opt_clean,

    ErrorConfig( 'name'    => 'DebianUtils',

                'Type=s'            => \$opt_type,

                 'verbose' => $opt_verbose,

                'BuildName=s'       => \$opt_buildname,                     # Raw Jats Package Name (Do not use)

                 'debug'   => $opt_debug );

                'Name=s'            => \$opt_name,                          # Massaged Debian Package Name

                'BuildVersion=s'    => \$opt_buildversion,

    #

                'Platform=s'        => \$opt_platform,

    #   Init the FileSystem Uiltity interface

                'Target=s'          => \$opt_target,

    #

                'Product=s'         => \$opt_product,

    InitFileUtils();

                'InterfaceDir=s'    => \$opt_interfacedir,

                'InterfaceIncDir=s' => \$opt_interfaceincdir,

    #

                'InterfaceLibDir=s' => \$opt_interfacelibdir,

    #   Ensure that we have all required options

                'InterfaceBinDir=s' => \$opt_interfacebindir,

    #

                'LibDir=s'          => \$opt_libdir,

    Error ("Platform not set")                  unless ( $opt_platform );

                'BinDir=s'          => \$opt_bindir,

    Error ("Type not set")                      unless ( $opt_type );

                'LocalIncDir=s'     => \$opt_localincdir,

    Error ("BuildName not set")                 unless ( $opt_buildname );

                'LocalLibDir=s'     => \$opt_locallibdir,

    Error ("Debian Package Name not set")       unless ( $opt_name );

                'LocalBinDir=s'     => \$opt_localbindir,

    Error ("BuildVersion not set")              unless ( $opt_buildversion );

                'PackageDir=s'      => \$opt_pkgdir,

    Error ("InterfaceDir not set")              unless ( $opt_interfacedir );

                'PackageLibDir=s'   => \$opt_pkglibdir,

    Error ("Target not set")                    unless ( $opt_target );

                'PackageBinDir=s'   => \$opt_pkgbindir,

    Error ("Product not set")                   unless ( $opt_product );

                'PackagePkgDir=s'   => \$opt_pkgpkgdir,

    Error ("DebianPackage not set")             unless ( $opt_package_script );

                'Variant:s'         => \$opt_variant,

    Error ("Ouput File not set")                unless ( $opt_output );

                'PkgArch:s'         => \$opt_pkgarch,

                'NoArch'            => \$opt_noarch,

    #

                'tarFile=s'         => \$opt_tarFile,

    #   Read in relevent config information

                'tarOnly'           => \$opt_tarOnly,

    #

                'genRpm'            => \$opt_rpm,

    ReadBuildConfig ($opt_interfacedir, $opt_platform, '--NoTest' );

                'genDeb'            => \$opt_debian,

                'output=s'          => \$opt_output,

    #

                'script=s'          => \$opt_package_script,

    #   Build the package image in a directory based on the target being created

                'rpmRelease=s'      => \$opt_rpmRelease,

    #

    );

    $DebianWorkDirBase = uc("$opt_platform$opt_type.image");

    $opt_verbose++ unless ( $opt_vargs eq '@' );

    $DebianWorkDir = "$DebianWorkDirBase/$opt_name";

    ErrorConfig( 'name'    => 'PackagerUtils',

    #

                 'verbose' => $opt_verbose,

    #   Configure the System command to fail on any error

                 'debug'   => $opt_debug );

    #

    SystemConfig ( ExitOnError => 1 );

    #

    #   Init the FileSystem Uiltity interface

    #

    #

    #   Defaults

    InitFileUtils();

    #

    $opt_pkgarch = $opt_platform unless ( $opt_pkgarch );

    #

    $opt_pkgarch = 'all' if ( $opt_noarch );

    #   Ensure that we have all required options

    #

    #

    Error ("Platform not set")                  unless ( $opt_platform );

    #   Display variables used

    Error ("Type not set")                      unless ( $opt_type );

    #

    Error ("BuildName not set")                 unless ( $opt_buildname );

    Message    ("=Building Debian Package =============================================");

    Error ("Package Name not set")              unless ( $opt_name );

    Message    ("Build $opt_name");

    Error ("BuildVersion not set")              unless ( $opt_buildversion );

    Message    ("       Package: $opt_buildname");

    Error ("InterfaceDir not set")              unless ( $opt_interfacedir );

    Message    ("       Variant: $opt_variant") if ($opt_variant);

    Error ("Target not set")                    unless ( $opt_target );

    Message    ("       Version: $opt_buildversion");

    Error ("Product not set")                   unless ( $opt_product );

    Message    ("  Building for: $opt_platform, $opt_target");

    Error ("Packaging Script not set")          unless ( $opt_package_script );

    Message    ("       Product: $opt_product");

    Message    ("          Type: $opt_type");

    #

    Message    ("      Pkg Arch: $opt_pkgarch") if ($opt_pkgarch);

    #   Read in relevent config information

    Verbose    ("       Verbose: $opt_verbose");

    #

    Verbose    ("  InterfaceDir: $opt_interfacedir");

    ReadBuildConfig ($opt_interfacedir, $opt_platform, '--NoTest' );

    Message    ("       Package: " . StripDirExt($opt_output));

    Message    ("       TarFile: " . StripDirExt($opt_tarFile)) if ($opt_tarFile);

    #

    Message    ("======================================================================");

    #   Build the package image in a directory based on the target being created

    #

    #

    $WorkDirBase = uc("$opt_platform$opt_type.image");

    #   Perform Clean up

    $WorkDirInit = "$WorkDirBase/$opt_name";

    #   Invoked during "make clean" or "make clobber"

    $WorkDir = $WorkDirInit;

    #

    if ( $opt_clean )

    #

    {

    #   Configure the System command to fail on any error

        Message ("Remove packaging directory: $DebianWorkDir");

    #

    SystemConfig ( ExitOnError => 1 );

        #

        #   Remove the directory for this package

    #

        #   Remove the general work dir - if all packages have been cleaned

    #   Defaults

        #

    #

        rmtree( $DebianWorkDir );

    $opt_pkgarch = $opt_platform unless ( $opt_pkgarch );

        rmdir( $DebianWorkDirBase );

        rmtree ($opt_output) if ( -f $opt_output );

    #

        exit;

    #   Determine build operations

    }

    #   

    my $genDebian = $opt_debian;

    #

    my $genRpm = $opt_rpm;

    #   NoArch sanity test

    if ($opt_tarOnly) {

    #   MUST only build no-arch for production

        $genDebian = $genRpm = 0; 

    #   User MUST do this in the build.pl file

    }

    #

    if ($opt_noarch && $opt_type ne 'P')

    {

    #

        Error ("Debian Packages marked as NoArch (all) must be built ONLY for production",

    #   Display variables used

               "This must be configured in the build.pl" );

    #

    }

    Message    ("= Building Installer ================================================");

    Message    ("        Format: Debian") if ($genDebian);

    #

    Message    ("        Format: RPM") if ($genRpm);

    #   Clean  out the WORK directory

    Message    ("        Format: TGZ") if ($opt_tarFile);

    #   Always start with a clean slate

    Message    ("          Name: $opt_name");

    #

    Message    ("       Package: $opt_buildname");

    #   Ensure that the base of the directory tree does not have 'setgid'

    Message    ("       Variant: $opt_variant") if ($opt_variant);

    #       This will upset the debian packager

    Message    ("       Version: $opt_buildversion");

    #       This may be an artifact from the users directory and not expected

    Message    ("  Building for: $opt_platform");

    #

    Message    ("        Target: $opt_target") if ( $opt_platform ne $opt_target);

    rmtree( $DebianWorkDir );

    Message    ("       Product: $opt_product") if ($opt_product ne $opt_platform);

    mkpath( $DebianWorkDir );

    Message    ("          Type: $opt_type");

    Message    ("   RPM Release: $opt_rpmRelease") if ($opt_rpmRelease);

    my $perm = (stat $DebianWorkDir)[2] & 0777;

    Message    ("      Pkg Arch: $opt_pkgarch") if ($opt_pkgarch);

    chmod ( $perm & 0777, $DebianWorkDir );

    Verbose    ("       Verbose: $opt_verbose");

    Verbose    ("  InterfaceDir: $opt_interfacedir");

    #

    Message    ("        Output: " . StripDir($opt_output))  if ($genDebian || $genRpm);

    #   Invoke the user script to do the hard work

    Message    ("        Output: " . StripDir($opt_tarFile)) if $opt_tarFile;

    #

    Message    ("======================================================================");

    unless (my $return = do $opt_package_script) {

            Error ("Couldn't parse $opt_package_script: $@") if $@;

    #

            Error ("Couldn't do $opt_package_script: $!")    unless defined $return;

    #   Perform Clean up

        }

    #   Invoked during "make clean" or "make clobber"

    #

    #

    if ( $opt_clean )

    #   Complete the building of the package

    {

    #

        Message ("Remove packaging directory: $WorkDirInit");

    if ($opt_tarFile)

    {

        #

        BuildTarFile();

        #   Remove the directory for this package

        Message ("Created TGZ file");

        #   Remove the general work dir - if all packages have been cleaned

    }

        #

        rmtree( $WorkDirBase );

        rmtree ($opt_tarFile) if ( defined($opt_tarFile) && -f $opt_tarFile );

    BuildDebianPackage ();

        rmtree ($opt_output) if ( -f $opt_output );

    Message ("Created Debian Package");

        exit;

}

    }

#-------------------------------------------------------------------------------

    #

# Function        : BuildDebianPackage

    #   NoArch sanity test

#

    #       MUST only build no-arch for production

# Description     : This function will create the Debian Package

    #       User MUST do this in the build.pl file

#                   and transfer it to the target directory

    #

#

    if ($opt_noarch && $opt_type ne 'P')

# Inputs          : None

    {

#

        Error ("Installer Packages marked as NoArch (all) must be built ONLY for production",

# Returns         : Nothing

               "This must be configured in the build.pl" );

#

    }

sub BuildDebianPackage

{

    #

    Error ("BuildDebianPackage: No Control File or Package Description")

    #   Clean  out the WORK directory

        unless ( exists($DebianControlFiles{'control'}) || $opt_description );

    #   Always start with a clean slate

    #

    #

    #   Ensure that the base of the directory tree does not have 'setgid'

    #   Convert the FileSystem Image into a Debian Package

    #       This will upset the debian packager

    #       Insert Debian control files

    #       This may be an artifact from the users directory and not expected

    #

    #

    Verbose ("Copy in the Debian Control Files");

    rmtree( $WorkDirInit );

    mkdir ( "$DebianWorkDir/DEBIAN" );

    mkpath( $WorkDirInit );

    #

    my $perm = (stat $WorkDirInit)[2] & 0777;

    #   Copy in all the named Debian Control files

    chmod ( $perm & 0777, $WorkDirInit );

    #       Ignore any control file. It will be done next

    #

    #

    foreach my $key ( keys %DebianControlFiles )

    #   Invoke the user script to do the hard work

    {

    #       Use abs path to avoid issues:

        next if ($key eq 'control');

    #           * '.' not buing in search path

        CopyFile ( $DebianControlFiles{$key}, '/DEBIAN', $key  );

    #           * Script name = DebianPackager.pl

    }

    $opt_package_script = AbsPath($opt_package_script);

    unless (my $return = do $opt_package_script) {

    #

            Error ("Couldn't parse $opt_package_script: $@") if $@;

    #   Create 'conffiles'

            Error ("Couldn't do $opt_package_script: $!") unless defined $return;

    #       Append to any user provided file

        };

    if ( @ConfigList )

    $ActiveSection = 1;

    {

        my $conffiles = "$DebianWorkDir/DEBIAN/conffiles";

    #

        Warning("Appending user specified entries to conffiles") if ( -f $conffiles);

    #   Now have an image of the directory that we wish to package

        FileAppend( $conffiles, @ConfigList );

    #   Complete the building of the package

    }

    #

    if ($opt_tarFile) {

    #

        BuildTarFile();

    #   Massage the 'control' file

        Message ("Created TGZ file");

    #

    }

    UpdateControlFile ($DebianControlFiles{'control'} );

    #

    #

    #   Create an RPM

    #   Mark all files in the debian folder as read-execute

    #

    #

    if ($genRpm) {

    System ( 'chmod', '-R', 'a+rx', "$DebianWorkDir/DEBIAN" );

        BuildRPM ();

    System ( 'build_dpkg.sh', '-b', $DebianWorkDir);

        Message ("Created RPM");

    System ( 'mv', '-f', "$DebianWorkDir.deb", $opt_output );

    }

    System ("build_dpkg.sh", '-I', $opt_output) if (IsVerbose(1));

    #

    #   Create a Debian Package

}

    #

    if ($genDebian) {

#-------------------------------------------------------------------------------

        BuildDebianPackage ();

# Function        : BuildTarFile 

        Message ("Created Debian Package");

#

    }

# Description     : This function will create a TGZ file of the constructed package

}

#                   Not often used 

#

#-------------------------------------------------------------------------------

# Inputs          : None

# Function        : BuildRPM 

#

#

# Returns         : Nothing

# Description     : This function will create the Debian Package

#

#                   and transfer it to the target directory

sub BuildTarFile

#

{

# Inputs          : None

    Verbose ("Create TGZ file containing body of the package");

#

    System ('tar', 

# Returns         : Nothing

            '--create',

# 

            '--auto-compress',

sub BuildRPM

            '--owner=0' ,

{

            '--group=0' ,

    #

            '--one-file-system' ,

    #   Sanity Checks

            '--exclude=./DEBIAN' ,

    #

            '-C', $DebianWorkDir,  

    Error ("BuildRPM: Release")

            '--file', $opt_tarFile,

        unless ( $opt_rpmRelease );

            '.'

    Error ("BuildRPM: No Control File or Package Description")

            );

        unless ( exists($ControlFiles{'control'}) || $opt_description );

}

    #

    #   Massage the 'control' file

#-------------------------------------------------------------------------------

    #   Generate or Massage

# Function        : UpdateControlFile

    #

#

    $opt_specFile = catfile($WorkDirBase, 'RPM.spec' );

# Description     : Update the Debian 'control' file to fix up various fields

    UpdateRedHatControlFile ($ControlFiles{'control'} );

#                   within the file.

#

    #   Generate a dummy rc file

#                   If the files has not been specified, then a basic control

    my $rcFile = catdir($WorkDirBase,'tmprc');

#                   file will be provided.

    TouchFile($rcFile);

#

#                   This routine knows where the control file will be placed

    #

#                   within the output work space.

    #   Run the RPM builder

#

    #   Expect it to be installed on the build machine

# Inputs          : $src            - Path to source file

    #

#                   Uses global variables

    my $prog = LocateProgInPath( 'rpmbuild', '--All');

#

    Error ("RPM Packager: The rpmbuild utility is not installed") unless $prog;

# Returns         : Nothing

    System ($prog, '-bb', $opt_specFile, 

#

                   '--buildroot', AbsPath($WorkDirInit) ,

sub UpdateControlFile

                   '--define', '_rpmdir ' . StripFileExt($opt_output),

{

                   '--define', '_rpmfilename ' .  StripDir($opt_output),

    my($src) = @_;

                   '--define', '_topdir ' . catfile($WorkDirBase, 'RPMBUILD' ),

    my $dst = "$DebianWorkDir/DEBIAN/control";

                   '--noclean',

                   $opt_verbose ? '-v' : '--quiet',

    unless ( $src )

                   #$opt_noarch ?  '--target=noarch' : undef,

    {

                   '--rcfile', $rcFile ,

        CreateControlFile();

                   );

        return;

    }

}

    #

    #   User has provided a control file

#-------------------------------------------------------------------------------

    #       Tweak the internals

# Function        : BuildDebianPackage

    #

#

    Verbose ("UpdateControlFile: $dst" );

# Description     : This function will create the Debian Package

    $src = ResolveFile( 0, $src );

#                   and transfer it to the target directory

#

    #   Calc depends line

# Inputs          : None

    my $depData = join (', ', @DependencyList );

#

# Returns         : Nothing

    open (SF, '<', $src) || Error ("UpdateControlFile: Cannot open:$src, $!");

#

    open (DF, '>', $dst) || Error ("UpdateControlFile: Cannot create:$dst, $!");

sub BuildDebianPackage

    while ( <SF> )

{

    {

    Error ("BuildDebianPackage: No Control File or Package Description")

        s~\s*$~~;

        unless ( exists($ControlFiles{'control'}) || $opt_description );

        if ( m~^Package:~ ) {

            $_ = "Package: $opt_name";

    #

    #   Convert the FileSystem Image into a Debian Package

        } elsif ( m~^Version:~ ) {

    #       Insert Debian control files

            $_ = "Version: $opt_buildversion";

    #

    Verbose ("Copy in the Debian Control Files");

        } elsif ( m~^Architecture:~ ) {

    mkdir ( "$WorkDirInit/DEBIAN" );

            $_ = "Architecture: $opt_pkgarch";

    #

        } elsif ( $opt_description && m~^Description:~ ) {

    #   Copy in all the named Debian Control files

            $_ = "Description: $opt_description";

    #       Ignore any control file. It will be done next

    #

        } elsif ( m~^Depends:~ ) {

    foreach my $key ( keys %ControlFiles )

            $_ = "Depends: $depData";

    {

            $depData = '';

        next if ($key eq 'control');

        }

        CopyFile ( $ControlFiles{$key}, '/DEBIAN', $key  );

        print DF $_ , "\n";

    }

    }

    #

    close (SF);

    #   Create 'conffiles'

    close (DF);

    #       Append to any user provided file

    if ( @ConfigList )

    #

    {

    #   Warn if Depends section is needed

        my $conffiles = "$WorkDirInit/DEBIAN/conffiles";

    #

        Warning("Appending user specified entries to conffiles") if ( -f $conffiles);

    Error ("No Depends section seen in user control file") 

        FileAppend( $conffiles, @ConfigList );

        if ($depData);

    }

}

    #

#-------------------------------------------------------------------------------

    #   Massage the 'control' file

# Function        : CreateControlFile

    #

#

    UpdateDebianControlFile ($ControlFiles{'control'} );

# Description     : Craete a basic debian control file

#

    #

# Inputs          : Uses global variables

    #   Mark all files in the debian folder as read-execute

#

    #

# Returns         : 

    System ( 'chmod', '-R', 'a+rx', "$WorkDirInit/DEBIAN" );

#

    System ( 'build_dpkg.sh', '-b', $WorkDirInit);

sub CreateControlFile

    System ( 'mv', '-f', "$WorkDirInit.deb", $opt_output );

{

    my $dst = "$DebianWorkDir/DEBIAN/control";

    System ("build_dpkg.sh", '-I', $opt_output) if (IsVerbose(1));

    Verbose ("CreateControlFile: $dst" );

}

    my $depData = join (', ', @DependencyList );

#-------------------------------------------------------------------------------

# Function        : BuildTarFile 

    open (DF, '>', $dst) || Error ("CreateControlFile: Cannot create:$dst");

#

    print DF "Package: $opt_name\n";

# Description     : This function will create a TGZ file of the constructed package

    print DF "Version: $opt_buildversion\n";

#                   Not often used 

    print DF "Section: main\n";

#

    print DF "Priority: standard\n";

# Inputs          : None

    print DF "Architecture: $opt_pkgarch\n";

#

    print DF "Essential: No\n";

# Returns         : Nothing

    print DF "Maintainer: Vix Technology\n";

#

    print DF "Description: $opt_description\n";

sub BuildTarFile

    print DF "Depends: $depData\n" if ($depData);

{

    Verbose ("Create TGZ file containing body of the package");

    close (DF);

    System ('tar', 

}

            '--create',

            '--auto-compress',

#-------------------------------------------------------------------------------

            '--owner=0' ,

# Function        : SetVerbose

            '--group=0' ,

#

            '--one-file-system' ,

# Description     : Set the level of verbosity

            '--exclude=./DEBIAN' ,

#                   Display activity

            '-C', $WorkDirInit,  

#

            '--file', $opt_tarFile,

# Inputs          : Verbosity level

            '.'

#                       0 - Use makefile verbosity (Default)

            );

#                       1..2

}

#

# Returns         : 

#-------------------------------------------------------------------------------

#

# Function        : Section 

sub SetVerbose

#

{

# Description     : Allows the Package file to be split into section

    my ($level) = @_;

#                   This direcive is always active.

#

    $level = $opt_verbose unless ( $level );

# Inputs          : Selector

    $opt_verbose = $level;

#                       ALL     - Active

    ErrorConfig( 'verbose' => $level);

#                       RPM     - Active section when building an RPM

}

#                       DEBIAN  - Active section if build a Debian package

#                       TAR     - Active section if building a TAR

#

#-------------------------------------------------------------------------------

# Returns         : Nothing

# Function        : DebianFiles

#                   Will fkag to indicate if directives are active. 

#

#

# Description     : Name Debian builder control files

sub Section

#                   May be called multiple times

{

#

    my $newActiveSection;

# Inputs          : Options

    my $flip = sub {

#                       --Control=file

        my ($val, $mode) = @_;

#                       --PreRm=file

        if ( defined $mode) {

#                       --PostRm=file

            return $val ? 0 : 1;

#                       --PreInst=file

        }

#                       --PostInst=file

        return $val;

#                         

    };

#

# Returns         : Nothing

    $newActiveSection = 1 unless (@_);

#

    foreach my $arg ( @_)

sub DebianFiles

    {

{

        if ($arg =~ m/^(!)*DEBIAN/i) {

    #

            $newActiveSection = 1 if  $flip->($opt_debian, $1);

    #   Extract names

    #

        } elsif ($arg =~ m/^(!)*RPM/i) {

    Verbose ("Specify Debian Control Files and Scripts");

            $newActiveSection = 1 if  $flip->($opt_rpm, $1);

    foreach  ( @_ )

    {

        } elsif ($arg =~ m/^(!)*TAR/i) {

        if ( m/^--Control=(.+)/i ) {

            $newActiveSection = 1 if $flip->($opt_tarFile, $1);

            DebianControlFile('control',$1)

        } elsif (uc($arg) eq 'ALL') {

        } elsif ( m/^--PreRm=(.+)/i ) {

            $newActiveSection = 1;

            DebianControlFile('prerm',$1)

        } elsif ( $arg eq 1  ) {

        } elsif ( m/^--PostRm=(.+)/i ) {

                $newActiveSection = 1;

            DebianControlFile('postrm',$1)

        } elsif ( $arg eq 0  ) {

        } elsif ( m/^--PreInst=(.+)/i ) {

            DebianControlFile('preinst',$1)

        } else {

            Warning ("Section: Unknown argument $arg");

        } elsif ( m/^--PostInst=(.+)/i ) {

        }

            DebianControlFile('postinst',$1)

    }

        } else {

    $ActiveSection = $newActiveSection ? 1: 0;

            Error ("DebianFiles: Unknown option: $_");

    Verbose ("Section State: $ActiveSection");

        }

    }

}

}

#-------------------------------------------------------------------------------

#-------------------------------------------------------------------------------

# Function        : UpdateDebianControlFile

# Function        : DebianControlFile 

#

#

# Description     : Update the Debian 'control' file to fix up various fields

# Description     : Add special control files to the Debian Installer 

#                   within the file.

#                   Not useful for embedded installers

#

#

#                   If the files has not been specified, then a basic control

#                   More general than DebianFiles()

#                   file will be provided.

#

#

# Inputs          : name            - Target Name

#                   This routine knows where the control file will be placed

#                                     If the name starts with 'package.' then it will be replaced

#                   within the output work space.

#                                     with the name of the current package

#

#                   file            - Source File Name

# Inputs          : $src            - Path to source file

#                   options         - Options include

#                   Uses global variables

#                                       --FromPackage

#

#

# Returns         : Nothing

# Returns         : 

#

#

sub UpdateDebianControlFile

sub DebianControlFile

{

{

    my($src) = @_;

    my ($name, $file, @options) = @_;

    return 1 unless ($ActiveSection);

    my $fromPackage = 0;

    my $dst = "$WorkDirInit/DEBIAN/control";

    #

    unless ( $src )

    #   Process options

    {

    foreach ( @options)

        CreateDebianControlFile();

    {

        return;

        if (m~^--FromPackage~) {

    }

            $fromPackage = 1;

        }

    #

        else  {

    #   User has provided a control file

            ReportError(("DebianControlFile: Unknown argument: $_"));

    #       Tweak the internals

        }

    #

    }

    Verbose ("UpdateDebianControlFile: $dst" );

    ErrorDoExit();

    $src = ResolveFile( 0, $src );

    #

    #   Calc depends line

    #   Some control files need to have the package name prepended

    my $depData = join (', ', @DependencyList );

    #

    $name =~ s~^package\.~$opt_name.~;

    open (SF, '<', $src) || Error ("UpdateDebianControlFile: Cannot open:$src, $!");

    open (DF, '>', $dst) || Error ("UpdateDebianControlFile: Cannot create:$dst, $!");

    #

    while ( <SF> )

    #   Only allow one file of each type

    {

    #       Try to protect the user by testing for names by lowercase

        s~\s*$~~;

    #

        if ( m~^Package:~ ) {

    my $simpleName = lc($name);

            $_ = "Package: $opt_name";

    Error("DebianControlFile: Multiple definitions for '$name' not allowed")

        if (exists $DebianControlFileNames{$simpleName});

        } elsif ( m~^Version:~ ) {

            $_ = "Version: $opt_buildversion";

    my $filePath = ResolveFile($fromPackage, $file);

        } elsif ( m~^Architecture:~ ) {

    #

            $_ = "Architecture: $opt_pkgarch";

    #   Add info to data structures

    #

        } elsif ( $opt_description && m~^Description:~ ) {

    $DebianControlFiles{$name} = $filePath;

            $_ = "Description: $opt_description";

    $DebianControlFileNames{$simpleName} = $name;

}

        } elsif ( m~^Depends:~ ) {

            $_ = "Depends: $depData";

#-------------------------------------------------------------------------------

            $depData = '';

# Function        : DebianDepends 

        }

#

        print DF $_ , "\n";

# Description     : This directive allows simple dependency information to be  

    }

#                   inserted into the control file

#

    close (SF);

#                   Not useful in embedded system

    close (DF);

#

# Inputs          : Entry             - A dependency entry

    #

#                   ...               - More entries

    #   Warn if Depends section is needed

#                   

    #

#

    Error ("No Depends section seen in user control file") 

# Returns         : Nothing

        if ($depData);

#

}

sub DebianDepends

{

#-------------------------------------------------------------------------------

    push @DependencyList, @_;

# Function        : CreateDebianControlFile

}

#

# Description     : Create a basic debian control file

#

#-------------------------------------------------------------------------------

# Inputs          : Uses global variables

# Function        : PackageDescription

#

#

# Returns         : 

# Description     : Specify the Package Description

#

#                   Keep it short

sub CreateDebianControlFile

#

{

# Inputs          : $description

    return 1 unless ($ActiveSection);

#

    my $dst = "$WorkDirInit/DEBIAN/control";

# Returns         : 

#

    Verbose ("CreateDebianControlFile: $dst" );

sub PackageDescription

{

    my $depData = join (', ', @DependencyList );

    ($opt_description) = @_;

}

    open (DF, '>', $dst) || Error ("CreateDebianControlFile: Cannot create:$dst");

    print DF "Package: $opt_name\n";

#-------------------------------------------------------------------------------

    print DF "Version: $opt_buildversion\n";

# Function        : MakeSymLink

    print DF "Section: main\n";

#

    print DF "Priority: standard\n";

# Description     : Create a symlink - with error detection

    print DF "Architecture: $opt_pkgarch\n";

#

    print DF "Essential: No\n";

# Inputs          : old_file    - Link Target

    print DF "Maintainer: Vix Technology\n";

#                                 Path to the link target

    print DF "Description: $opt_description\n";

#                                 If an ABS path is provided, the routine will

    print DF "Depends: $depData\n" if ($depData);

#                                 attempt to create a relative link.

#                   new_file    - Relative to the output work space

    close (DF);

#                                 Path to where the 'link' file will be created

}

#                   Options     - Must be last

#                                 --NoClean         - Don't play with links

#-------------------------------------------------------------------------------

#                                 --NoDotDot        - Don't create symlinks with ..

# Function        : UpdateRedHatControlFile 

#

#

# Returns         : Nothing

# Description     : Update the Redhat 'control' file to fix up various fields

#

#                   within the file.

sub MakeSymLink

#

{

#                   If the files has not been specified, then a basic control

    my $no_clean;

#                   (spec) file will be provided.

    my $no_dot;

#                   Various tags will be replaced

    my @args;

#                       tag_name

#                       tag_version

    #

#                       tag_buildarch

    #   Extract options

#                       tag_release

    #

#                       tag_description

    foreach ( @_ )

#                       tag_requires

    {

#                       tag_filelist

        if ( m/^--NoClean/i ) {

#

            $no_clean = 1;

# Inputs          : $src            - Path to source file

#                   Uses global variables

        } elsif ( m/^--NoDotDot/i ) {

#

            $no_dot = 1;

# Returns         : Nothing

#

        } elsif ( m/^--/ ) {

sub UpdateRedHatControlFile

            Error ("MakeSymLink: Unknown option: $_");

{

    my($src) = @_;

        } else {

    return 1 unless ($ActiveSection);

            push @args, $_;

    my $dst = $opt_specFile;

        }

    unless ( $src )

    }

    {

        CreateRedHatControlFile();

    my ($old_file, $new_file) = @args;

        return;

    }

    my $tfile = $DebianWorkDir . '/' . $new_file;

    $tfile =~ s~//~/~;

    #

    Verbose ("Symlink $old_file -> $new_file" );

    #   User has provided a control file

    #       Tweak the internals

    #

    #

    #   Create the directory in which the link will be placed

    Verbose ("UpdateRedHatControlFile: $dst" );

    #   Remove any existing file of the same name

    $src = ResolveFile( 0, $src );

    #

    my $dir = StripFileExt( $tfile );

    my @depList = @DependencyList;

    mkpath( $dir) unless -d $dir;

    my $cleanSeen;

    unlink $tfile;

    open (my $sf, '<', $src) || Error ("UpdateRedHatControlFile: Cannot open:$src, $!");

    #

    open (my $df, '>', $dst) || Error ("UpdateRedHatControlFile: Cannot create:$dst, $!");

    #   Determine a good name of the link

    while ( <$sf> )

    #   Convert to a relative link in an attempt to prune them

    {

    #

        s~\s*$~~;

    my $sfile = $old_file;

        if ( m~^tag_Name~i ) {

    unless ( $no_clean )

            $_ = "Name: $opt_name";

    {

        $sfile = CalcRelPath( StripFileExt( $new_file ), $old_file );

        } elsif ( m~^tag_Version~i ) {

        $sfile = $old_file if ( $no_dot && $sfile =~ m~^../~ );

            $_ = "Version: $opt_buildversion";

    }

        } elsif ( m~^tag_BuildArch~i ) {

    my $result = symlink $sfile, $tfile;

            $_ = "BuildArch: $opt_pkgarch";

    Error ("Cannot create symlink. $old_file -> $new_file") unless ( $result );

}

        } elsif ( m~^tag_Release~i ) {

            $_ = "Release: $opt_rpmRelease";

#-------------------------------------------------------------------------------

# Function        : CopyFile

        } elsif ( $opt_description && m~^tag_Description~i ) {

#

            print $df "%description\n";

# Description     : Copy a file to a target dir

            print $df "$opt_description\n";

#                   Used for text files, or files with fixed names

            $_ = undef;

#

# Inputs          : $src

        } elsif ( m~^tag_Requires~i ) {

#                   $dst_dir    - Within the output workspace

            foreach my $item (@depList) {

#                   $dst_name   - Output Name [Optional]

                print $df "Requires:       $item\n";

#                   Options     - Common Copy Options

            }

#

            $_ = undef;

# Returns         : Full path to destination file

            @depList = ();

#

sub CopyFile

        } elsif ( m~^tag_filelist~i ) {

{

            GenerateRedHatFileList ($df);

    CopyFileCommon( \&ResolveFile, @_ );

            $_ = undef;

}

        } elsif ( m~^%clean~i ) {

#-------------------------------------------------------------------------------

            $cleanSeen  = 1;

# Function        : CopyBinFile

        }

#

        print $df ($_ , "\n") if defined ($_);

# Description     : Copy a file to a target dir

    }

#                   Used for executable programs. Will look in places where

#                   programs are stored.

    close ($sf);

#

    close ($df);

# Inputs          : $src

#                   $dst_dir    - Within the output workspace

    #

#                   $dst_name   - Output Name [Optional]

    #   Warn if Depends section is needed

#

    #

#                   Options:

    Error ("No %clean section seen in user control file") unless $cleanSeen; 

#                       --FromPackage

    Error ("No Requires tag seen in user control file") if (@depList);

#                       --SoftLink=xxxx

}

#                       --LinkFile=xxxx

#

#-------------------------------------------------------------------------------

#

# Function        : CreateRedHatControlFile

# Returns         : Full path to destination file

#

#

# Description     : Create a binary RedHat spec file

sub CopyBinFile

#

{

# Inputs          : Uses global variables

    CopyFileCommon( \&ResolveBinFile, @_ );

#

}

# Returns         : 

#

#-------------------------------------------------------------------------------

sub CreateRedHatControlFile

# Function        : CopyLibFile

{

#

    #

# Description     : Copy a file to a target dir

    #   Generate the RPM spec file

#                   Used for shared programs. Will look in places where

    #

#                   shared libraries are stored.

    open (my $sf, '>', $opt_specFile) || Error ("RPM Spec File: Cannot create: $opt_specFile, $!");

#

# Inputs          : $src        - Base for 'realname' (no lib, no extension)

    # Standard tags

#                   $dst_dir    - Within the output workspace

    print $sf ("# Standard SPEC Tags\n");

#                   $dst_name   - Output Name [Optional, but not suggested]

    print $sf "Summary:        Installer for the $opt_name Package\n";

#

    print $sf "Name:           $opt_name\n";

# Returns         : Full path to destination file

    print $sf "Version:        $opt_buildversion\n";

#

    print $sf "Release:        $opt_rpmRelease\n";

# Notes           : Copying 'lib' files

    print $sf "License:        COPYRIGHT - VIX IP PTY LTD (\"VIX\"). ALL RIGHTS RESERVED.\n";

#                   These are 'shared libaries. There is no provision for copying

    print $sf "Source:         None\n";

#                   static libraries.

    print $sf "BuildArch:      $opt_pkgarch\n";

#

    print $sf "Group:          VIX/System\n";

#                   The tool will attempt to copy a well-formed 'realname' library

    print $sf "Vendor:         Vix Technology\n";

#                   The soname of the library should be constructed on the target

    print $sf "Autoreq:        No\n";

#                   platform using ldconfig.

    #

#                   There is no provision to copy the 'linker' name

    #   Requires tags

#

    #

#                   Given a request to copy a library called 'fred', then the

    print $sf "\n# Dependencies\n" if @DependencyList;

#                   well formed 'realname' will be:

    foreach my $item (@DependencyList) {

#                           libfred[P|D|]].so.nnnnn

        print $sf "Requires:       $item\n";

#                   where:

    }

#                           nnnn is the library version

#                           [P|D|] indicates Production, Debug or None

    print $sf "\n";

#

    print $sf "%description\n";

#                   The 'soname' is held within the realname form of the library

    print $sf "$opt_description\n";

#                   and will be created by lsconfig.

#

    print $sf "\n";

#                   The 'linkername' would be libfred[P|D|].so. This is only

    print $sf "%clean\n";

#                   needed when linking against the library.

#

    #

#

    #   Insert various scripts

#                   The routine will also recognize Windows DLLs

    #

#                   These are of the form fred[P|D|].nnnnn.dll

    my $insertRpmControlFile = sub {

#

        my ($sname, $cname) = @_;

sub CopyLibFile

        if ( my $src = $ControlFiles{$cname} ) {

{

            print $sf "\n";

    CopyFileCommon( \&ResolveLibFile, @_ );

            print $sf '%' . $sname . "\n";

}

            open ( my $cf, '<', $src ) || Error ("BuildRPM: Cannot open:$src, $!");

            while ( <$cf> ) {

#-------------------------------------------------------------------------------

                $_ =~ s~\%~%%~g;

# Function        : CopyDebianPackage

                print $sf $_;

#

            }

# Description     : Copy a Debian Package to a target dir

            close ($cf);

#                   Will look in places where Debian Packages are stored.

            print $sf "\n";

#

        }

# Inputs          : $src        - BaseName for 'Debian Package' (no version, no extension)

    };

#                   $dst_dir    - Within the output workspace

#                   Optional arguments embedded into the BaseName

    #   Run the PreInstall script as %pretrans

#                   --Arch=XXXX         - Architecture - if not current

    #       %pretrans is the only script that can terminate the RPM installation

#                   --Product=XXXX      - Product - if required

    &$insertRpmControlFile ('pretrans', 'preinst');

#                   --Debug             - If not the current type

    &$insertRpmControlFile ('post',     'postinst');

#                   --Prod              - If not the current type

    &$insertRpmControlFile ('preun',    'prerm');

#

    &$insertRpmControlFile ('postun',   'postrm');

# Returns         : Full path to destination file

#

    #

# Notes           : Copying Debian Packages from external packages

    #   Insert the list of files to be processed

#

    #       Can't use /* as this will mess with permissions of the root directory. 

#                   The tool will attempt to copy a well-formed debian packages

    #       Can list Top Level directories and then use *

#                   These are:

    #

#                   

    print $sf "\n%files\n";

#                       "BaseName_VersionString[_Product]_Arch${PkgType}.deb";

    print $sf "%defattr(",join (',', @RpmDefAttr),")\n";

#                   

    GenerateRedHatFileList ($sf);

#                   Where 'Product' is optional (and rare)

    print $sf "\n";

#                   Where 'PkgType' is P or D or nothing

    close ($sf);

#                   Where 'Arch' may be 'all'

}

#                   

#                   The routine will locate Debian packages in

#-------------------------------------------------------------------------------

#                       - The root of the package

# Function        : GenerateRedHatFileList 

#                       - bin/TARGET[P|D/]

#

#                       - bin/Arch[P|D]

# Description     : Internal function

#

#                   Generate a file list to be inserted into an RPM spec file

#

#

sub CopyDebianPackage

# Inputs          : $fd     - File descriptor.

{

#                             Function will write directly to the output

    CopyFileCommon( \&ResolveDebPackage, '--FromPackage', @_ );

#

}

# Returns         : Nothing 

#

#-------------------------------------------------------------------------------

sub GenerateRedHatFileList

# Function        : CopyFileCommon

{

#

    my ($fd) = @_;

# Description     : Common ( internal File Copy )

#

    #

# Inputs          : $resolver           - Ref to function to resolve source file

    #   Sanity Test

#                   $src                - Source File Name

    #

#                   $dst_dir            - Target Dir

    Warning ("No directories has been marked as 'Owned'",

#                   $dst_name           - Target Name (optional)

             "Under RedHat a directory must be 'owned' by a package so that it can be removed.",