Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 00c8a387 authored by Bob Badour's avatar Bob Badour
Browse files

license metadata shipped libraries list 

Introduce the below command-line tool:

shippedlibs outputs a text file listing 1 library per line containing
the libraries the shipped image is derived from.

Bug: 68860345
Bug: 151177513
Bug: 151953481
Bug: 213388645
Bug: 210912771

Test: m all
Test: m systemlicense
Test: m shippedlibs; out/soong/host/linux-x85/shippedlibs ...

where ... is the path to the .meta_lic file for the system image. In my
case if

$ export PRODUCT=$(realpath $ANDROID_PRODUCT_OUT --relative-to=$PWD)

... can be expressed as:

${PRODUCT}/gen/META/lic_intermediates/${PRODUCT}/system.img.meta_lic

Change-Id: I98e2c1eec94ad7878e911eee2458a26e12ee2b19
parent 6ea1457c

tools/compliance/Android.bp

+7 −0
Original line number Original line Diff line number Diff line
@@ -52,6 +52,13 @@ blueprint_go_binary { 
    testSrcs: ["cmd/htmlnotice_test.go"],

    testSrcs: ["cmd/htmlnotice_test.go"],

}

}





blueprint_go_binary {

    name: "shippedlibs",

    srcs: ["cmd/shippedlibs.go"],

    deps: ["compliance-module"],

    testSrcs: ["cmd/shippedlibs_test.go"],

}



blueprint_go_binary {

blueprint_go_binary {

    name: "textnotice",

    name: "textnotice",

    srcs: ["cmd/textnotice.go"],

    srcs: ["cmd/textnotice.go"],

tools/compliance/cmd/shippedlibs.go

0 → 100644
+137 −0
Original line number Original line Diff line number Diff line 
// Copyright 2021 Google LLC

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

//      http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.



package main



import (

	"bytes"

	"compliance"

	"flag"

	"fmt"

	"io"

	"io/fs"

	"os"

	"path/filepath"

)



var (

	outputFile  = flag.String("o", "-", "Where to write the library list. (default stdout)")



	failNoneRequested = fmt.Errorf("\nNo license metadata files requested")

	failNoLicenses    = fmt.Errorf("No licenses found")

)



type context struct {

	stdout      io.Writer

	stderr      io.Writer

	rootFS      fs.FS

}



func init() {

	flag.Usage = func() {

		fmt.Fprintf(os.Stderr, `Usage: %s {options} file.meta_lic {file.meta_lic...}



Outputs a list of libraries used in the shipped images.



Options:

`, filepath.Base(os.Args[0]))

		flag.PrintDefaults()

	}

}



func main() {

	flag.Parse()



	// Must specify at least one root target.

	if flag.NArg() == 0 {

		flag.Usage()

		os.Exit(2)

	}



	if len(*outputFile) == 0 {

		flag.Usage()

		fmt.Fprintf(os.Stderr, "must specify file for -o; use - for stdout\n")

		os.Exit(2)

	} else {

		dir, err := filepath.Abs(filepath.Dir(*outputFile))

		if err != nil {

			fmt.Fprintf(os.Stderr, "cannot determine path to %q: %w\n", *outputFile, err)

			os.Exit(1)

		}

		fi, err := os.Stat(dir)

		if err != nil {

			fmt.Fprintf(os.Stderr, "cannot read directory %q of %q: %w\n", dir, *outputFile, err)

			os.Exit(1)

		}

		if !fi.IsDir() {

			fmt.Fprintf(os.Stderr, "parent %q of %q is not a directory\n", dir, *outputFile)

			os.Exit(1)

		}

	}



	var ofile io.Writer

	ofile = os.Stdout

	if *outputFile != "-" {

		ofile = &bytes.Buffer{}

	}



	ctx := &context{ofile, os.Stderr, os.DirFS(".")}



	err := shippedLibs(ctx, flag.Args()...)

	if err != nil {

		if err == failNoneRequested {

			flag.Usage()

		}

		fmt.Fprintf(os.Stderr, "%s\n", err.Error())

		os.Exit(1)

	}

	if *outputFile != "-" {

		err := os.WriteFile(*outputFile, ofile.(*bytes.Buffer).Bytes(), 0666)

		if err != nil {

			fmt.Fprintf(os.Stderr, "could not write output to %q: %w\n", *outputFile, err)

			os.Exit(1)

		}

	}

	os.Exit(0)

}



// shippedLibs implements the shippedlibs utility.

func shippedLibs(ctx *context, files ...string) error {

	// Must be at least one root file.

	if len(files) < 1 {

		return failNoneRequested

	}



	// Read the license graph from the license metadata files (*.meta_lic).

	licenseGraph, err := compliance.ReadLicenseGraph(ctx.rootFS, ctx.stderr, files)

	if err != nil {

		return fmt.Errorf("Unable to read license metadata file(s) %q: %v\n", files, err)

	}

	if licenseGraph == nil {

		return failNoLicenses

	}



	// rs contains all notice resolutions.

	rs := compliance.ResolveNotices(licenseGraph)



	ni, err := compliance.IndexLicenseTexts(ctx.rootFS, licenseGraph, rs)

	if err != nil {

		return fmt.Errorf("Unable to read license text file(s) for %q: %v\n", files, err)

	}



	for lib := range ni.Libraries() {

		fmt.Fprintln(ctx.stdout, lib)

	}

	return nil

}

tools/compliance/cmd/shippedlibs_test.go

0 → 100644
+227 −0
Original line number Original line Diff line number Diff line 
// Copyright 2021 Google LLC

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

//      http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.



package main



import (

	"bufio"

	"bytes"

	"os"

	"strings"

	"testing"

)



func Test(t *testing.T) {

	tests := []struct {

		condition   string

		name        string

		roots       []string

		expectedOut []string

	}{

		{

			condition: "firstparty",

			name:      "apex",

			roots:     []string{"highest.apex.meta_lic"},

			expectedOut: []string{"Android"},

		},

		{

			condition: "firstparty",

			name:      "container",

			roots:     []string{"container.zip.meta_lic"},

			expectedOut: []string{"Android"},

		},

		{

			condition: "firstparty",

			name:      "application",

			roots:     []string{"application.meta_lic"},

			expectedOut: []string{"Android"},

		},

		{

			condition: "firstparty",

			name:      "binary",

			roots:     []string{"bin/bin1.meta_lic"},

			expectedOut: []string{"Android"},

		},

		{

			condition: "firstparty",

			name:      "library",

			roots:     []string{"lib/libd.so.meta_lic"},

			expectedOut: []string{"Android"},

		},

		{

			condition: "notice",

			name:      "apex",

			roots:     []string{"highest.apex.meta_lic"},

			expectedOut: []string{"Android", "Device", "External"},

		},

		{

			condition: "notice",

			name:      "container",

			roots:     []string{"container.zip.meta_lic"},

			expectedOut: []string{"Android", "Device", "External"},

		},

		{

			condition: "notice",

			name:      "application",

			roots:     []string{"application.meta_lic"},

			expectedOut: []string{"Android", "Device"},

		},

		{

			condition: "notice",

			name:      "binary",

			roots:     []string{"bin/bin1.meta_lic"},

			expectedOut: []string{"Android", "Device", "External"},

		},

		{

			condition: "notice",

			name:      "library",

			roots:     []string{"lib/libd.so.meta_lic"},

			expectedOut: []string{"External"},

		},

		{

			condition: "reciprocal",

			name:      "apex",

			roots:     []string{"highest.apex.meta_lic"},

			expectedOut: []string{"Android", "Device", "External"},

		},

		{

			condition: "reciprocal",

			name:      "container",

			roots:     []string{"container.zip.meta_lic"},

			expectedOut: []string{"Android", "Device", "External"},

		},

		{

			condition: "reciprocal",

			name:      "application",

			roots:     []string{"application.meta_lic"},

			expectedOut: []string{"Android", "Device"},

		},

		{

			condition: "reciprocal",

			name:      "binary",

			roots:     []string{"bin/bin1.meta_lic"},

			expectedOut: []string{"Android", "Device", "External"},

		},

		{

			condition: "reciprocal",

			name:      "library",

			roots:     []string{"lib/libd.so.meta_lic"},

			expectedOut: []string{"External"},

		},

		{

			condition: "restricted",

			name:      "apex",

			roots:     []string{"highest.apex.meta_lic"},

			expectedOut: []string{"Android", "Device", "External"},

		},

		{

			condition: "restricted",

			name:      "container",

			roots:     []string{"container.zip.meta_lic"},

			expectedOut: []string{"Android", "Device", "External"},

		},

		{

			condition: "restricted",

			name:      "application",

			roots:     []string{"application.meta_lic"},

			expectedOut: []string{"Android", "Device"},

		},

		{

			condition: "restricted",

			name:      "binary",

			roots:     []string{"bin/bin1.meta_lic"},

			expectedOut: []string{"Android", "Device", "External"},

		},

		{

			condition: "restricted",

			name:      "library",

			roots:     []string{"lib/libd.so.meta_lic"},

			expectedOut: []string{"External"},

		},

		{

			condition: "proprietary",

			name:      "apex",

			roots:     []string{"highest.apex.meta_lic"},

			expectedOut: []string{"Android", "Device", "External"},

		},

		{

			condition: "proprietary",

			name:      "container",

			roots:     []string{"container.zip.meta_lic"},

			expectedOut: []string{"Android", "Device", "External"},

		},

		{

			condition: "proprietary",

			name:      "application",

			roots:     []string{"application.meta_lic"},

			expectedOut: []string{"Android", "Device"},

		},

		{

			condition: "proprietary",

			name:      "binary",

			roots:     []string{"bin/bin1.meta_lic"},

			expectedOut: []string{"Android", "Device", "External"},

		},

		{

			condition: "proprietary",

			name:      "library",

			roots:     []string{"lib/libd.so.meta_lic"},

			expectedOut: []string{"External"},

		},

	}

	for _, tt := range tests {

		t.Run(tt.condition+" "+tt.name, func(t *testing.T) {

			stdout := &bytes.Buffer{}

			stderr := &bytes.Buffer{}



			rootFiles := make([]string, 0, len(tt.roots))

			for _, r := range tt.roots {

				rootFiles = append(rootFiles, "testdata/"+tt.condition+"/"+r)

			}



			ctx := context{stdout, stderr, os.DirFS(".")}



			err := shippedLibs(&ctx, rootFiles...)

			if err != nil {

				t.Fatalf("shippedLibs: error = %w, stderr = %v", err, stderr)

				return

			}

			if stderr.Len() > 0 {

				t.Errorf("shippedLibs: gotStderr = %v, want none", stderr)

			}



			t.Logf("got stdout: %s", stdout.String())



			t.Logf("want stdout: %s", strings.Join(tt.expectedOut, "\n"))



			out := bufio.NewScanner(stdout)

			lineno := 0

			for out.Scan() {

				line := out.Text()

				if strings.TrimLeft(line, " ") == "" {

					continue

				}

				if len(tt.expectedOut) <= lineno {

					t.Errorf("shippedLibs: unexpected output at line %d: got %q, want nothing (wanted %d lines)", lineno+1, line, len(tt.expectedOut))

				} else if tt.expectedOut[lineno] != line {

					t.Errorf("shippedLibs: unexpected output at line %d: got %q, want %q", lineno+1, line, tt.expectedOut[lineno])

				}

				lineno++

			}

			for ; lineno < len(tt.expectedOut); lineno++ {

				t.Errorf("shippedLibs: missing output line %d: ended early, want %q", lineno+1, tt.expectedOut[lineno])

			}

		})

	}

}

tools/compliance/noticeindex.go

+17 −0
Original line number Original line Diff line number Diff line
@@ -270,6 +270,23 @@ func (ni *NoticeIndex) InstallHashLibs(installPath string, h hash) []string { 
	return result

	return result

}

}





// Libraries returns the ordered channel of indexed library names.

func (ni *NoticeIndex) Libraries() chan string {

	c := make(chan string)

	go func() {

		libs := make([]string, 0, len(ni.libHash))

		for lib := range ni.libHash {

			libs = append(libs, lib)

		}

		sort.Strings(libs)

		for _, lib := range libs {

			c <- lib

		}

		close(c)

	}()

	return c

}



// HashText returns the file content of the license text hashed as `h`.

// HashText returns the file content of the license text hashed as `h`.

func (ni *NoticeIndex) HashText(h hash) []byte {

func (ni *NoticeIndex) HashText(h hash) []byte {

	return ni.text[h]

	return ni.text[h]