Subversion Repositories DevTools

#                       --Dmf                   - Generate the Device Management Framework

#                                                 combined archive ZIP file.

#                       --DmfVersion=xxxx       - Generate the Device Management Framework

#                                                 combined archive ZIP using a modified

#                                                 version number; only for testing!

    my $generate_dmf = 0;

    my $dmf_version = $::ScmBuildVersion;

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

            $generate_dmf = 1

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

            $generate_dmf = 1;

            $dmf_version = $1;

    $data{dmf} = $generate_dmf;

    $data{arch} = $default_arch;

    $data{dmf_version} = $dmf_version;

        if ( $entry->{dmf} )

        {

        	DmfGenerate($entry);

        }

# Bring in the DMF build requirements.

my $directory;

BEGIN {

    use File::Spec::Functions qw(rel2abs);

    use File::Basename qw(dirname);

    my $path = rel2abs( __FILE__ );

    $directory = dirname( $path );

}

use lib $directory;

use Archive::Zip qw( :ERROR_CODES :CONSTANTS );

use JSON;

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

# Function        : DmfGenerate

#

# Description     : Import an existing manifest

#

# Inputs          : entry   - The manifest that is being processed.

#

# Returns         : Nothing

#

sub DmfGenerate

{

    my ($entry) = @_;

    # Get the generation time.

    my $gen_time = time();

    my $work_dir = "$::ScmPlatform.BIN/";

    System( "$::GBE_BIN/mkdir -p $work_dir" );

    my $name = $entry->{name};

    my $version = $entry->{dmf_version};

    # Configure base manifest information.

    my %manifest;

    $manifest{'name'} = $name;

    $manifest{'version'} = $version;

    $manifest{'package_name'} = $::ScmBuildPackage;

    $manifest{'package_version'} = $::ScmBuildVersion;

    $manifest{'datetime'} = localtime($gen_time);

    $gen_time *= 1000;  # Make to milliseconds

    $manifest{'timestamp'} = $gen_time;

    $manifest{'architecture'} = $entry->{arch};

    $manifest{'tier'} = $entry->{tier};

    # Process each file.

    my @files = @{ $entry->{files} };

    my $zip = Archive::Zip->new();

    my $i = 0;

    foreach my $fentry ( @files )

    {

        if ( my $file = $fentry->{'file'} )

        {

        	my $order = $i + 1;

            my $base_file = StripDir( $file );

            my $publish_file = $name . '_' . $version . '_' . $order . '.aup';

            my $aup_file = $work_dir . $publish_file;

            GenerateCesFile($file, $aup_file, 0x3, $gen_time, $publish_file);

            my $file_member = $zip->addFile( $aup_file, $publish_file );

            $manifest{'tasks'}[$i]{'order'} = 1 * $order;

            $manifest{'tasks'}[$i]{'filename'} = $base_file;

            $manifest{'tasks'}[$i]{'download'} = $publish_file;

            if ($base_file =~ /\.sh$/)

            {

                $manifest{'tasks'}[$i]{'action'} = 'exec-shell';

            }

            elsif ($base_file =~ /\.deb$/)

            {

                $manifest{'tasks'}[$i]{'action'} = 'dpkg-install';

            }

            else

            {

                ReportError ("Manifest entry $base_file does not have a supported DMF install action");

            }

            $i = $i + 1;

        }

    }

    # Encode and commit the JSON.

    my $json_encoder = JSON->new->allow_nonref;

    my $json = $json_encoder->pretty->encode( \%manifest );

    my $manifest_filename = $name . '_' . $version;

    my $aum_filename = $manifest_filename . '_0.aum';

    my $manifest_file = $work_dir . $manifest_filename . '.json';

    my $aum_file = $work_dir . $aum_filename;

    # Save our manifest.

    open (J, '>', $manifest_file ) || Error ("Cannot create the DMF Manifest file");

    binmode (J);

    print J $json;

    close J;

    GenerateCesFile($manifest_file, $aum_file, 0x2, $gen_time, $aum_filename);

    $zip->addFile($aum_file, $aum_filename);

    my $zip_filename = $work_dir . $name . '_' . $version . '.zip';

    if ( $zip->writeToFileNamed($zip_filename) != AZ_OK )

    {

        ReportError("DMF ZIP file creation failed");

    }

    PackageFile('*', $zip_filename, '--Strip');

    PackageFile('*', $manifest_file, '--Strip');

}

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

# Function        : DmfGenerate

#

# Description     : Import an existing manifest

#

# Inputs          : src_file     - The input file.

#                   dst_file     - The output CES file.

#                   content_type - The content type to report.

#                   gen_time     - The generation time for the file.

#                   filename     - The filename to embed in the CES file.

#

#

# Returns         : Nothing

#

sub GenerateCesFile

{

    my ($src_file, $dst_file, $content_type, $gen_time, $filename) = @_;

    open (INF, '<', $src_file ) || Error ("Cannot open file $src_file for reading");

    binmode (INF);

    open (OUTF, '>', $dst_file ) || Error ("Cannot open file $dst_file for writing");

    binmode (OUTF);

    my $signing_key_name = "";

    my $signature_size = 0;

    my $format_version = 0xCE500000;

    my $compression_method = 0;

    my $encryption_method = 0;

    my $kek_name = "";

    my $encryption_key_size = 0;

    my $filename_size = length($filename);

    print OUTF pack("Z32", $signing_key_name);

    print OUTF pack("n", $signature_size);

    print OUTF pack("N", $format_version);

    print OUTF pack("N", $content_type);

    print OUTF pack("Q>", $gen_time);

    print OUTF pack("N", $compression_method);

    print OUTF pack("N", $encryption_method);

    print OUTF pack("Z32", $kek_name);

    print OUTF pack("n", $encryption_key_size);

    print OUTF pack("n", $filename_size);

    # Encryption key HERE

    print OUTF pack("A$filename_size", $filename);

    my $buf;

    while (read(INF,$buf,65536))

    {

        print OUTF $buf;

    }

    print OUTF $buf;

    close INF;

    # Signature HERE

    # Finish with file.

    close OUTF;

}