WebSVN – DevTools – Diff – /manifest-tool/trunk/src/gbe/DIRECTIVES/ManifestFiles.pm

 our $pkgBase;                       # Where the package is being sourced from
 our $noSigs = 1;                    # Control signature generation (Force noSigs. could use use undef)
+#
 #   Internal
+#   Used while generating a manifest
+#
 my $certName;                       # Signing Cert Name
 my $certFile;                       # Path to the certificate
 my $keyFile;                        # Path to the keyfile
 my $opensslProg;                    # Path to openssl program
 my $opensslConf;                    # Path to openssl config
+my $manifestName;                   # Name of the current manifest file
 BEGIN {
     my $path = rel2abs( __FILE__ );
     $pkgBase = dirname( $path );
+}
+    #
     #   Determine the target packaging directory
     #   Default is .../mug
+    #
-    my $pkgdir = 'mug';
+    $pkg_subdir = 'mug';
     if ( exists $Manifests[0]->{pkgsubdir} && defined $Manifests[0]->{pkgsubdir} )
+    {
         my $subdir = $Manifests[0]->{pkgsubdir};
-        $pkgdir .= '/' . $subdir;
+        $pkg_subdir .= '/' . $subdir;
-        $pkgdir =~ s~^mug/mug~mug~;
+        $pkg_subdir =~ s~^mug/mug~mug~;
+    }
+    #
     #   Create the Manifest File as we process the lists
     #   Place this in the 'lib' directory:
     Error ("ManifestFiles: Needs local directory specified in build.pl") unless ( $::ScmLocal );
     my $manifest_dir = "$::ScmPlatform.LIB";
     System( "$::GBE_BIN/mkdir -p $manifest_dir" );
-    my $manifest_file = $manifest_dir . '/Manifest';
+    $manifestName = $manifest_dir . '/Manifest';
-    $manifest_file .= '_' . $::ScmBuildVersion if ( $Manifest_has_version );
+    $manifestName .= '_' . $::ScmBuildVersion if ( $Manifest_has_version );
-    ::ToolsetGenerate( $manifest_file );
+    ::PackageFile ('*', $manifestName, '--Subdir=' . $pkg_subdir, '--Strip' );
-    Verbose ("Generate: File: $manifest_file");
+    ::ToolsetGenerate( $manifestName );
-    PackageManifestFile ($manifest_file, $pkgdir);
+    Verbose ("Generate: File: $manifestName");
-    open (MF, '>', $manifest_file ) || Error ("Cannot create the Manifest file: $manifest_file");
+    open (MF, '>', $manifestName ) || Error ("Cannot create the Manifest file: $manifestName");
     binmode (MF);
     if ($Manifests[0]->{is_sub_manifest} == 1) {
         print_mf ("# Package $::ScmBuildPackage $::ScmBuildVersion built: $::CurrentTime");
     } else {
         print_mf ("");
         print_mf ("#");
         print_mf ("# Signing Certificate");
         print_mf ("[Certificate],$certName");
-        ::PackageFile ('*', $certFile, '--Subdir=' . $pkgdir, '--Strip' );
+        ::PackageFile ('*', $certFile, '--Subdir=' . $pkg_subdir, '--Strip' );
+    }
+    #
     #   Process each tier in the order presented in the source file
+    #
+                }
                 if (exists $entry->{fileVersions} && exists $entry->{fileVersions}{$file} ) {
                     push @items, "VERSION=" . $entry->{fileVersions}{$file};
+                }
                 print_mf (join (',', @items));
-                PackageManifestFile ($file, $pkgdir);
+                PackageManifestFile ($name, $tier, $file );
                 $last_was_comment = 0;
+            }
             if ( my $file = $fentry->{'filenocopy'} )
+            {
                             if ($include_md5 && $md5_added == 0) { # add md5 if requested and not already added from submanifest
                                 my $md5 = digest_file_hex($emf->{'file_base'} . '/' . $item->{'file_name'}, 'MD5');
                                 push @items, "MD5=$md5";
+                            }
                             print_mf (join (',', @items));
-                            PackageManifestFile ( $emf->{'file_base'} . '/' . $item->{'file_name'}, $pkgdir);
+                            PackageManifestFile ( $name, $tier, $emf->{'file_base'} . '/' . $item->{'file_name'} );
+                        }
                         elsif (defined($item->{'comment'})) {
                             print_mf($item->{'comment'});
+                        }
+                    }
+                }
                 else {
                     print_mf ($_) foreach  ( @{$emf->{'contents'}} );
                     foreach my $item ( @{$emf->{'items'}}) {
                         if (defined($item->{'file_name'})) {
-                            PackageManifestFile ( $emf->{'file_base'} . '/' . $item->{'file_name'}, $pkgdir);
+                            PackageManifestFile ( $name, $tier, $emf->{'file_base'} . '/' . $item->{'file_name'} );
+                        }
+                    }
                     print_mf('#');
+                }
+            }
                 if ($include_md5) {
                     my $md5 = digest_file_hex($file, 'MD5');
                     push @items, "MD5=$md5" ;
+                }
                 print_mf (join (',', @items));
-                PackageManifestFile ($file, 'mug');
+                PackageManifestFile ($name, $tier, $file );
+            }
+        }
+    }
+    #
 # Description     : Process and package a manifest file
 #                       Reatin a list of files in the mnifest to allow postprocessing
 #                       such as signature generation
+#
+#
-# Inputs          : $srcFile        - Full path to the source file
+# Inputs          : $name           - Target platform name
+#                   $tier           - Target tier
-#                   $pkgPath        - Target path within the package
+#                   $srcFile        - Full path to the source file
+#
 # Returns         : Nothing
+#
 sub PackageManifestFile {
-    my ($srcFile, $pkgPath) = @_;
+    my ($name, $tier, $srcFile ) = @_;
-    push @{$ManifestFiles}, ({srcFile => $srcFile, pkgPath => $pkgPath});
+    push @{$ManifestFiles}, ({srcFile => $srcFile, name =>$name, tier => $tier});
-    ::PackageFile ('*', $srcFile, '--Subdir=' . $pkgPath, '--Strip' );
+    ::PackageFile ('*', $srcFile, '--Subdir=' . $pkg_subdir, '--Strip' );
+}
 #-------------------------------------------------------------------------------
 # Function        : GenSigInit
+#
 sub GenSignatures
+{
     Debug("GenSignatures:", $noSigs);
     return if $noSigs;
+    my %sigManifest;
     foreach my $entry ( @{$ManifestFiles}) {
-        Verbose("PostProcess: $entry->{srcFile}, $entry->{pkgPath}");
+        Verbose("PostProcess: $entry->{srcFile}");
+        #
         #   Generate the name of the signature file
         #   Generate Packaging directives for the signature
+        #
         my $sigFileName = CatPaths( "$::ScmPlatform.LIB", StripDir($entry->{srcFile}) . '.sig' );
-        ::PackageFile ('*', $sigFileName, '--Subdir=' . $entry->{pkgPath}, '--Strip' );
+        ::PackageFile ('*', $sigFileName, '--Subdir=' . $pkg_subdir, '--Strip' );
         ::ToolsetGenerate($sigFileName);
+        #
-        #   Generate package signature
+        #   Generate the name/tier for the manifest signature
-        #   The required custom(vix) 'sig' file has the format:
+        #       ie: Manifest_<name>_<tier>.sig
-        #       line-1 : name of the certificate to decode
+        #   Generate the name for the manifest signature
-        #                Assume its the keyname with .key -> .crt - with no path elements
-        #       line-2 : Text representation of the signature
+        #       ie: Manifest_<name>.sig
-        #                The openssl dgst command generates a binary output by default
-        #                This is then converted into base64 with -A option
+        #   Will generate signature of signatures
         #
-        my $tmp1 = CatPaths( "$::ScmPlatform.LIB", 'temp1');
+        my $sigManifest =  join('_', $entry->{name}, $entry->{tier});
-        my $tmp2 = CatPaths( "$::ScmPlatform.LIB", 'temp2');
+        push @{$sigManifest{$sigManifest}}, $sigFileName;
-        ::ToolsetGenerate($tmp1, $tmp2);
+        push @{$sigManifest{$entry->{name}}}, $sigFileName;
-        Verbose("Signing: " . StripDir($entry->{srcFile}));
+        # Generate the signature over the file
-        System( '--Exit', '--NoShell', $opensslProg, 'dgst', '-sha256', '-sign', $keyFile, '-out', $tmp1, $entry->{srcFile} );
-        System( '--Exit', '--NoShell', $opensslProg, 'base64', '-A', '-in', $tmp1, '-out', $tmp2 );
-        my $base64 = TagFileRead($tmp2);
+        genSigForFile($entry->{srcFile}, $sigFileName);
+    }
-        #
+    #
-        #   In a development environment we don't want to create the signature file
+    #   Create a file of signatures
-        #   every time we run. Its noisy. Solution:
+    #   Create one for each platform/tier
+    #
-        #       Only generate a signature file if:
+    foreach my $nameTier ( keys %sigManifest)
+    {
-        #           It doesn't exist
+        Verbose("PostProcessSig: $nameTier");
-        #           A copy of the signed digest doesn't exist (.fpp)
+        my $sigSigTemp = $manifestName . '_' . $nameTier . '.sig';
-        #           The signed digest has changed
+        my $sigSigTempCat = $sigSigTemp . '.content';
+        ::ToolsetGenerate($sigSigTemp, $sigSigTempCat);
+        ::PackageFile ('*', $sigSigTemp, '--Subdir=' . $pkg_subdir, '--Strip' );
         #
-        my $fppFileName = CatPaths( "$::ScmPlatform.LIB", StripDir($entry->{srcFile}) . '.fpp' );
+        #   Concatenate the contents of the required .sig files
-        ::ToolsetGenerate($fppFileName);
+        #   Treat them as binary files.
+        #
+        open  (my $ofh, '>', $sigSigTempCat ) || Error( "Cannot create file: $sigSigTempCat", "Reason: $!" );
-        my $genSig = 0;
+        binmode ($ofh);
-        $genSig = 1 unless ( -e $sigFileName &&  -e $fppFileName);
+        foreach my $entry (@{$sigManifest{$nameTier}}) {
-        unless ($genSig) {
+            Verbose("PostProcessSig: $entry");
+            open( my $file, '<', $entry ) || Error("Cannot open '$entry'. $!");
-            my $ffp = TagFileRead($fppFileName);
+            binmode ($file);
-            $genSig = ($ffp ne $base64);
+            my @lines = <$file>;
-        }
+            close $file;
-        if ($genSig) {
+            foreach my $entry ( @lines ) {
-            FileCreate($sigFileName, $certName, $base64);
+                print $ofh $entry;
-            rename $tmp2, $fppFileName ;
+            }
+        }
+        close $ofh;
+        #
+        #   Generate a signature over the file
-        unlink $tmp1;
+        #
+        genSigForFile($sigSigTempCat, $sigSigTemp);
-        unlink $tmp2;
+        #unlink $sigSigTempCat;
+    }
     unlink $opensslConf;
+}
+#-------------------------------------------------------------------------------
+# Function        : genSigForFile
+#
+# Description     : Generate a .sig file for a named file (internal)
+#                   Will be smart and only 'touch' the output file if the input has chnaged
+#                       It will maintain a fingerprint file to do this.
+#
+#                   Generate package signature
+#                   The required custom(vix) 'sig' file has the format:
+#                       line-1 : name of the certificate to decode
+#                                Assume its the keyname with .key -> .crt - with no path elements
+#                       line-2 : Text representation of the signature (base64)
+#                                The openssl dgst command generates a binary output by default
+#                                This is then converted into base64 with -A option
+#
+# Inputs          : $srcFile        - Source file to process
+#                   $tgtFile        - Output file name
+#
+# Returns         :
+#
+sub genSigForFile
+{
+    my ($srcFile, $tgtFile) = @_;
+    my $tmp1 = CatPaths( "$::ScmPlatform.LIB", 'temp1');
+    my $tmp2 = CatPaths( "$::ScmPlatform.LIB", 'temp2');
+    ::ToolsetGenerate($tmp1, $tmp2);
+    Verbose("Signing: " . StripDir($srcFile));
+    System( '--Exit', '--NoShell', $opensslProg, 'dgst', '-sha256', '-sign', $keyFile, '-out', $tmp1, $srcFile );
+    System( '--Exit', '--NoShell', $opensslProg, 'base64', '-A', '-in', $tmp1, '-out', $tmp2 );
+    my $base64 = TagFileRead($tmp2);
+    #
+    #   In a development environment we don't want to create the signature file every time we run. Its noisy.
+    #   Solution: Only generate a signature file if:
+    #               It doesn't exist
+    #               A copy of the signed digest doesn't exist (.fpp)
+    #               The signed digest has changed
+    #
+    my $fppFileName = CatPaths( "$::ScmPlatform.LIB", StripDir($srcFile) . '.fpp' );
+    ::ToolsetGenerate($fppFileName);
+    my $genSig = 0;
+    $genSig = 1 unless ( -e $tgtFile &&  -e $fppFileName);
+    unless ($genSig) {
+        my $ffp = TagFileRead($fppFileName);
+        $genSig = ($ffp ne $base64);
+    }
+    if ($genSig) {
+        FileCreate($tgtFile, $certName, $base64);
+        rename $tmp2, $fppFileName ;
+    }
+    unlink $tmp1;
+    unlink $tmp2;
+}
 #-------------------------------------------------------------------------------
 # Function        : DmfGenerate
+#
 # Description     : Import an existing manifest

Subversion Repositories DevTools

(root)/manifest-tool/trunk/src/gbe/DIRECTIVES/ManifestFiles.pm – Rev 6943 → 6962