Subversion Repositories DevTools

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

# Copyright (C) 2008 ERG Limited, All rights reserved

#

# Module name   : Proc_day0fs_script.pl

# Module type   : Makefile system

# Compiler(s)   : Perl

# Environment(s): jats

#

# Description   :

#

# Usage:

#

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

require 5.008_002;

use strict;

use warnings;

use Pod::Usage;

use Getopt::Long;

use File::Path;

use File::Copy;

use FindBin;                                    # Determine the current directory

use lib "$FindBin::Bin";                        # Allow Modules in current directory

use JatsError;

use JatsSystem;

use FileUtils;

use JatsCopy qw(SetCopyDirDefaults DeleteDir CopyDir CreateDir);

use CreateSdImage qw( CreateSdImage );

#

#

#   Global Variables

#

my $VERSION = 1.0;

our $AUTOLOAD;

my $BUILD = 'build';                        # Build subdir

my $WORK = "${BUILD}/image";

my $source_specified = 0;                   # Ensure that source is specified

my $output_image = 0;                       # Ensure output is specified

my $output_sd = 0;

#

#   Command line options

#

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

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

my $opt_vargs;                              # Verbose arg

my $opt_help = 0;

my $opt_manual = 0;

my $opt_clean = 0;

my $opt_platform;

my $opt_type;

my $opt_buildname;

my $opt_packagedir;

my $opt_interfacedir;

my $opt_compilerpath;

my $opt_product;

my $opt_packagebindir;

our $opt_buildroot;

my $opt_target;

my $opt_version;

my $opt_userscript;

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

# Function        : Mainline Entry Point

#

# Description     :

#

# Inputs          :

#

my $result = GetOptions (

                "help+"             => \$opt_help,

                "manual"            => \$opt_manual,

                "verbose:s"         => \$opt_vargs,

                "clean"             => \$opt_clean,

                "Platform=s"        => \$opt_platform,

                "Type=s"            => \$opt_type,

                "BuildName=s"       => \$opt_buildname,

                "PackageDir=s"      => \$opt_packagedir,

                "InterfaceDir=s"    => \$opt_interfacedir,

                "CompilerPath=s"    => \$opt_compilerpath,

                "Product=s"         => \$opt_product,

                "PackageBinDir=s"   => \$opt_packagebindir,

                "BuildRoot=s"       => \$opt_buildroot,

                "Target=s"          => \$opt_target,

                "BuildVersion=s"    => \$opt_version,

                "UserScript=s"      => \$opt_userscript,

    );

#

#   Process help and manual options

#

pod2usage(-verbose => 0, -message => "Version: $VERSION")  if ($opt_help == 1  || ! $result);

pod2usage(-verbose => 1)  if ($opt_help == 2 );

pod2usage(-verbose => 2)  if ($opt_manual || ($opt_help > 2));

#

#   Configure the error reporting process now that we have the user options

#

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

ErrorConfig( 'name'    => 'Proc_Day0fs',

             'verbose' => $opt_verbose );

#

#   Configure the System command to fail on any error

#

SystemConfig ( ExitOnError => 1 );

SetCopyDirDefaults ( 'EmptyDirs' => 1 ,Log => 0 );

#

#   Init the FileSystem Uiltity interface

#

InitFileUtils();

#

#   Ensure that we have all required options

#

Error ("CompilePath not set")       unless ( $opt_compilerpath );

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

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

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

Error ("PackageBinDir not set")     unless ( $opt_packagebindir );

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

Error ("CompilePath not set")       unless ( $opt_compilerpath );

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

Error ("BuildRoot not set")         unless ( $opt_buildroot );

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

Error ("User Script not set")       unless ( $opt_userscript );

#

#   Calculate a few paths

#

my $TOOLSUITE = $opt_compilerpath;

$TOOLSUITE =~ s~^.*/~~;

$TOOLSUITE =~ s~-gcc$~~;

my $CROSSLIBS = $opt_compilerpath;

$CROSSLIBS =~ s~/bin/.*$~~;

$CROSSLIBS .= "/${TOOLSUITE}/lib";

my $CROSSEXE = $opt_compilerpath;

$CROSSEXE =~ s~/bin/.*$~~;

$CROSSEXE .= "/${TOOLSUITE}";

my $CROSS_COMPILE = $opt_compilerpath;

$CROSS_COMPILE =~ s~gcc$~~;

my $CROSS_STRIP = ${CROSS_COMPILE} . "strip";

#

#   Display variables used

#

Message    "======================================================================";

Message    "Build day0 file system";

Message    "           Package: ${opt_buildname}";

Message    "           Version: ${opt_version}";

Message    "      Building for: ${opt_platform}, $opt_target";

Message    "           Product: ${opt_product}";

Message    "              Type: ${opt_type}";

Message    "            Script: ${opt_userscript}";

Verbose    "           Verbose: ${opt_verbose}";

Message    "         BuildRoot: ${opt_buildroot}";

Verbose    "         BuildRoot: ${opt_buildroot}";

Verbose    "      InterfaceDir: ${opt_interfacedir}";

Verbose    "     CROSS_COMPILE: ${CROSS_COMPILE}";

Verbose    "         CROSSLIBS: ${CROSSLIBS}";

Verbose    "       CROSS_STRIP: ${CROSS_STRIP}";

Message    "======================================================================";

#

#   Perform Clean up

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

#

if ( $opt_clean )

{

    Message ("Remove build directory: $BUILD");

    rmtree( $BUILD );

    exit;

}

#

#   Have setup the basics

#   Invoke the user script to drive the remainder of the process

#       The script should only contain known directives

#       The directives will build up data structures that will be processed

#       after the script has been read

#

#

Message ("Process User Script: $opt_userscript");

Error ("Board Specfic file Not found: $opt_userscript") unless ( -f $opt_userscript );

require $opt_userscript;

#

#   The process of requiring the user script

#   will have done all the required work

#   Perform minor sanity testing

#

#

#   All done

#

Error ( "No package output specified" )

    unless ( $output_image || $output_sd );

exit 0;

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

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

#

#   The following functions are intended to be used to manipulate files within

#   the output image.

#

#   These may be used by the board specfic functions.

#

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

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

# Function        : Day0Source

#

# Description     : Determine the source of the Day0 File System

#                   Use of this directive is mandatory

#

#

# Inputs          : Options

#                       --Dir=name              - Source dir

#                       --Image=name            - Source image

#

# Returns         : Nothing

#

sub Day0Source

{

    my ($opt) = @_;

    #

    #   Can only use this directive ONCE

    #

    Error ("Multiple Day0Source directives not allowed")

        if ( $source_specified++ );

    #

    #   Start with a clean slate

    #

    DeleteDir ( $WORK );

    #

    #   Process options

    #

    if ( $opt =~ /^--Dir=(.+)/ ) {

        #

        #   User has specified a directory

        #   Copy the entire directory to the work area

        #

        Message ("Copy in Day0 source directory: $WORK");

        CopyDir ( $1, $WORK, 'DeleteFirst' => 1 );

    } elsif ( $opt =~ /^--Image=(.+)/ ) {

        #

        #   User has specified an Image

        #   Locate the image and extract it into the work area

        #

        my $name = $1;

        Message ("Extract File System Image: $name");

        #

        #   File will come from a Package

        #   This is where the tool places output files

        #

        my $fname = Internal::LocateFile ('bin', $name . '.tgz' );

        Error ("Cannot locate Day0 source image: $name")

            unless $fname;

        #

        #   Create a Tar command

        #   Assumes the presence of a GNU style tar

        #

        CreateDir ( $WORK );

        System ( 'gtar',

                 '--extract',

                 '--file',  $fname,

                 '--gzip',

                 IsVerbose(1) ? ( '--verbose' ) : (),

                 '--directory', $WORK,

                 );

    } else {

        Error ("Unknown Day0Source option: $opt");

    }

}

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

# Function        : Day0Operation

#

# Description     : Perform one of the special Day0 Operations

#

# Inputs          : $subfunction            - Sub function to perform

#                   @opts                   - Sub function options

#

# Returns         : Nothing

#

sub Day0Operation

{

    Error ("Day0Source must be specified first")

        unless ( $source_specified );

    #

    #   Perform the Day0Operation

    #   These are specialised operations and normally only performed on the

    #   the basic skelton.

    #

    #   Dispatch to the required function

    #

    my $opt = shift (@_);

    if ( my $fref = UNIVERSAL::can ( 'Day0Ops', lc($opt) ) )

    {

        &$fref( @_ );

    }

    else

    {

        Error ("Unknown Day0Operation option: $opt @_");

    }

}

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

# Function        : Day0BuildImage

#

# Description     : Package up the created image as a tar-zip file

#                   This allows the Image to be processed again later

#

# Inputs          : Options

#                       --name=Name             - Output Name

#

# Returns         : 

#

sub Day0BuildImage

{

    my $name = 'Day0Image';

    Message ("Create File System Image; $name");

    #

    #   Indicate that we have created some output

    #

    Error ("Day0Source must be specified first")

        unless ( $source_specified );

    $output_image++;

    #

    #   Process user options

    #

    foreach  ( @_ )

    {

        if ( m~^--Name=(.+)~i ) {

            $name = $1;

        } else {

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

        }

    }

    #

    #   Place the file in the BIN directory

    #   Have no reall good reason

    #

    $name = $opt_packagebindir . '/' . $name . '.tgz';

    CreateDir ( $opt_packagebindir);

    #

    #   Create a Tar command

    #   Assumes the presence of a GNU style tar

    #

    System ( 'gtar',

             '--create',

             '--file',  $name,

             '--gzip',

             IsVerbose(1) ? ( '--verbose' ) : (),

             '--directory', $WORK,

             '.' );

}

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

# Function        : Day0BuildSdImage

#

# Description     : Package up the created image and create an SD memory image

#                   This is destructive and can only be done one

#

# Inputs          : Options

#                       --disk_blocks           - Size the output disk

#

# Returns         : 

#

sub Day0BuildSdImage

{

    my $size = 501248;

    my $debug;

    #

    #   Ensure that some work is being done

    #

    Error ("Day0Source must be specified first")

        unless ( $source_specified );

    Error ("Cannot create multiple SD images")

        if ( $output_sd++ );

    #

    #   Process user options

    #

    foreach  ( @_ )

    {

        if ( m~^--disk-blocks=(\d+)$~i ) {

            $size = $1;

        } elsif ( m~^--debug~i ) {

            $debug = 1;

        } else {

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

        }

    }

    #

    #   Perform specific processing on the image

    #

    #

    #   Scan the skeleton and process .LINKS files

    #   File links do not store well in version control systems

    #   NOTE: .LINKS are a local invention and not a part of e2fsimage like

    #         .DEVICES on which they are modelled.

    #

    Message ("Locate LINKFILES in $WORK");

    foreach my $linkfile ( Internal::FindFiles( $WORK, ".LINKS" ))

    {

        my $BASEDIR = StripFileExt( $linkfile );

        $BASEDIR =~ s~^$WORK/~~;

        Message "Expand links: $BASEDIR";

        open (LF, "<", $linkfile ) || Error ("Cannot open link file: $linkfile" );

        while ( <LF> )

        {

            chomp;

            next if ( m~^#~ );

            next unless ( $_ );

            my ($link, $file) = split;

            Internal::MakeSymLink($file ,"$BASEDIR/$link", '--NoDotDot' );

        }

        close (LF);

        unlink $linkfile;

    }

    #   Update the Shared Library Cache

    #

    Message ("Create Shared Library Cache");

    System ('/sbin/ldconfig', '-r', $WORK );

    #

    #   Make every thing executable

    #       This is good for directories

    #       This is good for all files. Shouldn't be an issue to files in /etc

    #

    Message ("Mark files as executable");

    foreach my $dir ( glob ("$WORK/*") )

    {

        next if ( $dir =~ m~/etc$~ );

        System ('chmod', '-R', 'a+rx', $dir );

    }

    foreach my $dir ( glob ("$WORK/etc/*") )

    {

        next unless ( -d $dir );

        System ('chmod', '-R', 'a+rx', $dir );

    }

    #

    #   Special considertaion

    #       /etc/busybox.conf   - Accessible by root

    #       /bin/busybox        - setuid

    #

    System ('chmod', '600',  "$WORK/etc/busybox.conf" );

    System ('chmod', '4755', "$WORK/bin/busybox" );

    #

    #   Stop here if debugging

    #   Don't create the actual image as the process destroys the image

    #

    Error ("Day0BuildSdImage: Debug Image. SD Image not built")

        if ( $debug );

    #

    #   Invoke SD build function

    #   Held in another package to make this one readable

    #

    my $name = "${opt_buildname}-${opt_version}-${opt_target}";

    CreateSdImage( $opt_packagebindir, $name, $WORK, $BUILD, $size );

}

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

# Function        : AddInitScript

#

# Description     : Add an Init Script to the target

#                   Optionally create start and stop links

#

#                   Existing links will always be delete

#

# Inputs          : $script     - Name of the init script

#                   $start      - Start Number

#                   $stop       - Stop Number

#                   Options:

#                       --NoCopy    - Don't copy the script, just add links

#

# Returns         : 

#

sub AddInitScript

{

    my ( $script, $start, $stop, @opts ) = @_;

    Error ("Day0Source must be specified first")

        unless ( $source_specified );

    Message ("AddInitScript: $script, $start, $stop");

    my $tdir = "/etc/init.d/init.d";

    my $base = StripDir($script);

    unless ( grep '^--NoCopy', @opts )

    {

        ::CopyFile( $script, $tdir );

    }

    #

    #   Delete any existing links

    #

    foreach my $file ( glob("$WORK/etc/init.d/*$base") )

    {

        next unless ( $file =~ m~/[KS][\d]+${base}~ );

        unlink $file;

    }

    my $link;

    if ( $start )

    {

        $link = sprintf ("/etc/init.d/S%2.2d%s", $start, $base );

        Internal::MakeSymLink( "$tdir/$base", $link);

    }

    if ( $stop )

    {

        $link = sprintf ("/etc/init.d/K%2.2d%s", $stop, $base );

        Internal::MakeSymLink( "$tdir/$base", $link);

    }

}

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

# Function        : EchoFile

#

# Description     : Echo simple text to a file

#

# Inputs          : $file   - Within the output workspace

#                   $text

#

# Returns         : 

#

sub EchoFile

{

    my ($file, $text) = @_;

    Error ("Day0Source must be specified first")

        unless ( $source_specified );

    $file = $WORK . '/' . $file;

    $file =~ s~//~/~;

    unlink $file;

    open (DT, ">", $file ) || Error ("Cannot create $file");

    print DT  $text || Error ("Cannot print to $file");

    close DT;

}

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

# Function        : CopyPkgDir

#

# Description     : Copy a directory to a target dir

#                   Source directory is within a 'package'

#                   Does not delete the target directory, but will add files

#

#                   Currently does not support

#                       Recursion

#                       Flattening

#

#

# Inputs          : $src_dir    - Within a package

#                   $dst_dir    - Within the output workspace

#

#                   Options:

#                       --FilterIn=Filter           Simple filter

#                       --FilterOut=Filter          Simple filter

#

# Returns         :

#

sub CopyPkgDir

{

    my @filter_out;

    my @filter_in;

    my @args;

    Error ("Day0Source must be specified first")

        unless ( $source_specified );

    #

    #   Process options

    #

    foreach  ( @_ )

    {

        if ( m/^--FilterIn=(.+)/ ) {

            push @filter_in, $1;

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

            push @filter_out, $1;

        } elsif ( m/^-/ ) {

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

        } else {

            push @args, $_;

        }

    }

    my ($src_dir, $dst_dir) = @args;

    #

    #   Calculate the destination path

    #

    $dst_dir = $WORK . '/' . $dst_dir;

    $dst_dir =~ s~//~/~;

    #

    #   Validate source dir

    #

    my $full_src_dir = "$opt_interfacedir/$src_dir";

    Error("CopyPkgDir: Source dir not found: $src_dir") unless ( -d $full_src_dir );

    #

    #   Copy as required

    #

    CopyDir ( $full_src_dir, $dst_dir,

                    'Flatten' => 1,

                    'NoSubDirs' => 1,

                    'Ignore' =>  \@filter_out,

                    'Match' => \@filter_in,

                    );

}

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

# Function        : CopyPackage

#

# Description     : Copy in files from a package located in the interface

#                   directory.

#

#                   The source directory may be:

#                       pkg/<platform>

#                       pkg/<product>

#                       pkg/<target>

#

# Inputs          : $section    - Section to search

#                   $file       - Source Path within a package

#                   @llist      - list of softlinks

#                                 Abs or Relative to destination dir

#

#                   Embedded Options:

#                               --Dest=Dir (Default is taken from $file)

#                               --LinkFile (Append to .LINKS file)

#                               --Rename=Name

#

# Returns         :  Path to the target file

#

sub CopyPackage

{

    my $dest;

    my $isa_linkfile;

    my @args;

    my $dfile;

    my @options;

    Error ("Day0Source must be specified first")

        unless ( $source_specified );

    #

    #   Process and Remove options

    #

    foreach  ( @_ )

    {

        if ( m/^--Dest=(.*)/ ) {

            $dest = $1 . '/xxx';

        } elsif ( m/^--LinkFile/ ) {

            $isa_linkfile = 1;

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

            push @options, $_;

        } elsif ( m/^--/ ) {

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

        } else {

            push @args, $_;

        }

    }

    my ($section, $file, @llist) = @args;

    #

    #   Default destination is the same as the source

    #

    $dest = $file unless ( $dest );

    my $dest_dir = StripFileExt($dest);

    my $tfile = Internal::LocateFile($section, $file);

    Error ("CopyPackage: File not found: $file") unless $tfile;

    #

    #   LinkFiles are special

    #   They get concatenated to any existing Link File

    #

    if ( $isa_linkfile )

    {

        CatFile ( $tfile, "$dest_dir/.LINKS" );

    }

    else

    {

        $dfile = CopyFile ($tfile, $dest_dir, @options );

        foreach my $lname ( @llist )

        {

            $lname = $dest_dir . '/' . $lname unless ( $lname =~ m ~^/~ );

            my $dest_file = $dest_dir . '/' . StripDir($dfile);

            Internal::MakeSymLink($dest_file ,$lname);

        }

    }

    return $dfile;

}

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

# Function        : CatFile

#

# Description     : Copy a file to the end of a file

#

# Inputs          : $src

#                   $dst    - Within the output workspace

#

# Returns         :

#

sub CatFile

{

    my ($src, $dst) = @_;

    $dst = $WORK . '/' . $dst;

    $dst =~ s~//~/~;

    Verbose ("CatFile: $src, $dst");

    Error ("Day0Source must be specified first")

        unless ( $source_specified );

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

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

    while ( <SF> )

    {

        print DF $_;

    }

    close (SF);

    close (DF);

}

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

# Function        : CopyFile

#

# Description     : Copy a file to a target dir

#

# Inputs          : $src

#                   $dst_dir    - Within the output workspace

#                   Options     - Optional flags

#                                 --Symlink

#                                   Copies symlink, not symlink target

#                                 --Rename=xxx

#                                   Renames file

#

# Returns         : Full path to destination file

#

sub CopyFile

{

    my ($src, $dst_dir, @opts ) = @_;

    my $tfile = StripDir($src);

    my %opts;

    Error ("Day0Source must be specified first")

        unless ( $source_specified );

    #

    #   Extract options

    #

    foreach  ( @opts )

    {

        if ( m/^--Symlink/ ) {

            $opts{DuplicateLinks} = 1;

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

            $tfile = $1;

        } else {

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

        }

    }

    #

    #   Calculate the destination path

    #

    $dst_dir = $WORK . '/' . $dst_dir;

    $dst_dir =~ s~//~/~;

    #

    #   Determine the full name of the target

    #

    my $dst_file = "$dst_dir/$tfile";

    Verbose ("CopyFile: $src, $dst_dir");

    return JatsCopy::CopyFile( $src, $dst_file, \%opts );

}

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

# Function        : AUTOLOAD

#

# Description     : Intercept bad user directives and issue a nice error message

#                   This is a simple routine to report unknown user directives

#                   It does not attempt to distinguish between user errors and

#                   programming errors. It assumes that the program has been

#                   tested. The function simply report filename and line number

#                   of the bad directive.

#

# Inputs          : Original function arguments ( not used )

#

# Returns         : This function does not return

#

sub AUTOLOAD

{

    my $fname = $::AUTOLOAD;

    $fname =~ s~^\w+::~~;

    my ($package, $filename, $line) = caller;

    Error ("Directive not known or not allowed in this context: $fname",

           "Directive: $fname( @_ );",

           "File: $filename, Line: $line" );

}

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

# Function        : FirstBoot

#

# Description     : Add a file to the first boot section

#                   Assumes that the firstboot directory is /var/afc/firstboot

#                   This is the default

#

# Inputs          : All options

#                       --Debian=xxx[,opts] - Locate debian package

#                                             Sub opts are:

#                                               --Arch=xxx

#                                               --Product=xxx

#                                               --Debug

#                                               --Prod

#                       --File=yyy          - Locate a files

#                       --Level=nn          - Level to run (default=50)

#

# Returns         : 

#

sub FirstBoot

{

    my  $file;

    my  $level = 50;

    Error ("Day0Source must be specified first")

        unless ( $source_specified );

    #

    #   Collect user items

    #

    foreach ( @_ )

    {

        if ( m~^--Debian=(.+)~ ) {

            Error ("FirstBoot: Multiple source files not supported in one directive: $_") if $file;

            $file = Internal::LocateDebianFile($1, $opt_target, $opt_product);

        } elsif ( m~^--File=(.+)~ ) {

            Error ("FirstBoot: Multiple source files not supported in one directive: $_") if $file;

            $file = $1;

        } elsif ( m~^--Level=(\d+)~ ) {

            $level = $1;

            Error ("FirstBoot: Invalid Level: $_") if ($level < 0 || $level > 99);

        } else {

            Error ("FirstBoot: Unknown option or argument: $_");

        }

    }

    #

    #   Insert the required file

    #       Prepend name with a two digit level

    #

    my $fname = sprintf ('%2.2d.%s', $level, StripDir($file)  );

    Message ("FirstBoot: $fname");

    CopyFile ( $file, '/var/afc/firstboot', "--Rename=$fname" );

}

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

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

#   

#   Package to contain DayOp opereration

#

package Day0Ops;

use strict;

use warnings;

use JatsError;

use JatsSystem;

use JatsCopy qw(SetCopyDirDefaults DeleteDir CopyDir CreateDir);

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

# Function        : hostname

#

# Description     : Insert hostname information into the target

#                       Insert /etc/devicetype

#                       Insert into hostname too

#

#

# Inputs          : 

#

# Returns         : 

#

sub hostname

{

    Message ("Insert Hostname an Devicename: ${opt_product}");

    ::EchoFile ( "/etc/devicetype", $opt_product );

    ::EchoFile ( "/etc/hostname", $opt_product );

    ::EchoFile ( "/etc/day0-version", "$opt_buildname $opt_version $opt_product $opt_platform $opt_target" );

}

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

# Function        : setupbusybox

#

# Description     : Insert busybox into the skeleton

#                   Locate busybox and associated links file

#

# Inputs          : None

#

# Returns         : Nothing

#

sub setupbusybox

{

    #

    #   Insert busybox into the skeleton

    #   Locate busybox and associated links file

    #

    Message ("Copy in busybox");

    my $bbfile  = ::CopyPackage ('bin', 'busybox',       "--Dest=bin" );

    my $bblinks = ::CopyPackage ('bin', 'busybox.links', "--Dest=bin" );

    #

    #   Expand the busybox links

    #   Use soft links. Expect that they will be easier to update in the field

    #   Keep the .links file on the target.

    #

    Message "Expand busybox links";

    open ( BBLINK, "<", $bblinks ) || Error ("Cannot open BusyBox Links file");

    while ( <BBLINK> )

    {

        s~\s+~~;

        Internal::MakeSymLink ("/bin/busybox", $_, '--NoDotDot'  );

    }

    close BBLINK;

    #

    #   May want to convert busybox.links into a .LINKS file and process

    #   it when we instantiate the file system

    #

}

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

# Function        : upgrade

#

# Description     : Insert day0 upgrade components

#

# Inputs          : None

#

# Returns         : Nothing

#

sub upgrade

{

    Message ("Copy in day0 upgrade");

    my $DAY0BIN="/afc/day-zero/bin";       #/day-zero