STRLCPY/syft

■ ■ ■ ■ ■ ■

syft/pkg/package.go

		skipped 58 lines
59	59		return fmt.Errorf("cannot merge packages with different IDs: %q vs %q", p.id, other.id)
60	60		}
61	61
	62	+	log.WithFields("id", p.id, "purl", p.PURL).Trace("merging similar packages")
	63	+
62	64		if p.PURL != other.PURL {
63	65		log.Warnf("merging packages have with different pURLs: %q=%q vs %q=%q", p.id, p.PURL, other.id, other.PURL)
64	66		}
		skipped 63 lines

■ ■ ■ ■ ■ ■

syft/source/image_all_layers_resolver.go

		skipped 17 lines
18	18		layers []int
19	19		}
20	20
21		-	// newAllLayersResolver returns a new resolver from the perspective of all image layers for the given image.
22		-	func newAllLayersResolver(img image.Image) (imageAllLayersResolver, error) {
	21	+	// newImageAllLayersResolver returns a new resolver from the perspective of all image layers for the given image.
	22	+	func newImageAllLayersResolver(img image.Image) (imageAllLayersResolver, error) {
23	23		if len(img.Layers) == 0 {
24	24		return nil, fmt.Errorf("the image does not contain any layers")
25	25		}
		skipped 176 lines
202	202		return nil, fmt.Errorf("cannot read contents of non-file %q", location.ref.RealPath)
203	203		}
204	204
205		-	return r.img.FileContentsByRef(location.ref)
	205	+	return r.img.OpenReference(location.ref)
206	206		}
207	207
208	208		func (r *imageAllLayersResolver) FilesByMIMEType(types ...string) ([]Location, error) {
		skipped 45 lines

■ ■ ■ ■ ■ ■

syft/source/image_all_layers_resolver_test.go

		skipped 90 lines
91	91		t.Run(c.name, func(t *testing.T) {
92	92		img := imagetest.GetFixtureImage(t, "docker-archive", "image-symlinks")
93	93
94		-	resolver, err := newAllLayersResolver(img)
	94	+	resolver, err := newImageAllLayersResolver(img)
95	95		if err != nil {
96	96		t.Fatalf("could not create resolver: %+v", err)
97	97		}
		skipped 107 lines
205	205		t.Run(c.name, func(t *testing.T) {
206	206		img := imagetest.GetFixtureImage(t, "docker-archive", "image-symlinks")
207	207
208		-	resolver, err := newAllLayersResolver(img)
	208	+	resolver, err := newImageAllLayersResolver(img)
209	209		if err != nil {
210	210		t.Fatalf("could not create resolver: %+v", err)
211	211		}
		skipped 45 lines
257	257		t.Run(test.fixtureName, func(t *testing.T) {
258	258		img := imagetest.GetFixtureImage(t, "docker-archive", test.fixtureName)
259	259
260		-	resolver, err := newAllLayersResolver(img)
	260	+	resolver, err := newImageAllLayersResolver(img)
261	261		assert.NoError(t, err)
262	262
263	263		locations, err := resolver.FilesByMIMEType(test.mimeType)
		skipped 10 lines
274	274		func Test_imageAllLayersResolver_hasFilesystemIDInLocation(t *testing.T) {
275	275		img := imagetest.GetFixtureImage(t, "docker-archive", "image-duplicate-path")
276	276
277		-	resolver, err := newAllLayersResolver(img)
	277	+	resolver, err := newImageAllLayersResolver(img)
278	278		assert.NoError(t, err)
279	279
280	280		locations, err := resolver.FilesByMIMEType("text/plain")
		skipped 53 lines
334	334		t.Run(test.name, func(t *testing.T) {
335	335		img := imagetest.GetFixtureImage(t, "docker-archive", "image-symlinks")
336	336
337		-	resolver, err := newAllLayersResolver(img)
	337	+	resolver, err := newImageAllLayersResolver(img)
338	338		assert.NoError(t, err)
339	339
340	340		refs, err := resolver.FilesByPath(test.fixture)
		skipped 20 lines
361	361
362	362		img := imagetest.GetFixtureImage(t, "docker-archive", "image-symlinks")
363	363
364		-	resolver, err := newAllLayersResolver(img)
	364	+	resolver, err := newImageAllLayersResolver(img)
365	365		assert.NoError(t, err)
366	366
367	367		var dirLoc *Location
		skipped 307 lines
675	675
676	676		img := imagetest.GetFixtureImage(t, "docker-archive", "image-symlinks")
677	677
678		-	resolver, err := newAllLayersResolver(img)
	678	+	resolver, err := newImageAllLayersResolver(img)
679	679		assert.NoError(t, err)
680	680
681	681		actual := test.runner(resolver)
		skipped 7 lines
689	689		func TestAllLayersResolver_AllLocations(t *testing.T) {
690	690		img := imagetest.GetFixtureImage(t, "docker-archive", "image-files-deleted")
691	691
692		-	resolver, err := newAllLayersResolver(img)
	692	+	resolver, err := newImageAllLayersResolver(img)
693	693		assert.NoError(t, err)
694	694
695	695		paths := strset.New()
		skipped 129 lines

■ ■ ■ ■ ■ ■

syft/source/image_squash_resolver.go

		skipped 167 lines
168	168		return nil, fmt.Errorf("unable to get file contents for directory: %+v", location)
169	169		}
170	170
171		-	return r.img.FileContentsByRef(location.ref)
	171	+	return r.img.OpenReference(location.ref)
172	172		}
173	173
174	174		func (r *imageSquashResolver) AllLocations() <-chan Location {
		skipped 38 lines

■ ■ ■ ■ ■ ■

syft/source/image_squash_with_all_layers_resolver.go

1	+	package source
2	+
3	+	import (
4	+	"github.com/anchore/stereoscope/pkg/image"
5	+	"io"
6	+	)
7	+
8	+	var _ FileResolver = (*imageSquashWithAllLayersResolver)(nil)
9	+
10	+	// imageSquashWithAllLayersResolver acts like a squash resolver, but additionally returns all paths in earlier layers
11	+	// that have been added/modified (like the all-layers resolver).
12	+	type imageSquashWithAllLayersResolver struct {
13	+	squashed *imageSquashResolver
14	+	allLayers *imageAllLayersResolver
15	+	}
16	+
17	+	// newImageSquashWithAllLayersResolver returns a new resolver from the perspective of the squashed representation for
18	+	// the given image, but additionally returns all instances of a path that have been added/modified.
19	+	func newImageSquashWithAllLayersResolver(img image.Image) (imageSquashWithAllLayersResolver, error) {
20	+	squashed, err := newImageSquashResolver(img)
21	+	if err != nil {
22	+	return nil, err
23	+	}
24	+
25	+	allLayers, err := newImageAllLayersResolver(img)
26	+	if err != nil {
27	+	return nil, err
28	+	}
29	+
30	+	return &imageSquashWithAllLayersResolver{
31	+	squashed: squashed,
32	+	allLayers: allLayers,
33	+	}, nil
34	+	}
35	+
36	+	func (i imageSquashWithAllLayersResolver) FileContentsByLocation(location Location) (io.ReadCloser, error) {
37	+	return i.squashed.FileContentsByLocation(location)
38	+	}
39	+
40	+	func (i imageSquashWithAllLayersResolver) HasPath(s string) bool {
41	+	return i.squashed.HasPath(s)
42	+	}
43	+
44	+	func (i imageSquashWithAllLayersResolver) filterLocations(locations []Location, err error) ([]Location, error) {
45	+	if err != nil {
46	+	return locations, err
47	+	}
48	+	var ret []Location
49	+	for _, l := range locations {
50	+	if i.squashed.HasPath(l.RealPath) {
51	+	// not only should the real path to the file exist, but the way we took to get there should also exist
52	+	// (e.g. if we are looking for /etc/passwd, but the real path is /etc/passwd -> /etc/passwd-1, then we should
53	+	// make certain that /etc/passwd-1 exists)
54	+	if l.VirtualPath != "" && !i.squashed.HasPath(l.VirtualPath) {
55	+	continue
56	+	}
57	+	ret = append(ret, l)
58	+	}
59	+	}
60	+	return ret, nil
61	+	}
62	+
63	+	func (i imageSquashWithAllLayersResolver) FilesByPath(paths ...string) ([]Location, error) {
64	+	return i.filterLocations(i.allLayers.FilesByPath(paths...))
65	+	}
66	+
67	+	func (i imageSquashWithAllLayersResolver) FilesByGlob(patterns ...string) ([]Location, error) {
68	+	return i.filterLocations(i.allLayers.FilesByGlob(patterns...))
69	+	}
70	+
71	+	func (i imageSquashWithAllLayersResolver) FilesByMIMEType(types ...string) ([]Location, error) {
72	+	return i.filterLocations(i.allLayers.FilesByMIMEType(types...))
73	+	}
74	+
75	+	func (i imageSquashWithAllLayersResolver) RelativeFileByPath(l Location, path string) *Location {
76	+	if !i.squashed.HasPath(path) {
77	+	return nil
78	+	}
79	+	return i.allLayers.RelativeFileByPath(l, path)
80	+	}
81	+
82	+	func (i imageSquashWithAllLayersResolver) AllLocations() <-chan Location {
83	+	var ret = make(chan Location)
84	+	go func() {
85	+	defer close(ret)
86	+	for l := range i.allLayers.AllLocations() {
87	+	if i.squashed.HasPath(l.RealPath) {
88	+	ret <- l
89	+	}
90	+	}
91	+	}()
92	+
93	+	return ret
94	+	}
95	+
96	+	func (i imageSquashWithAllLayersResolver) FileMetadataByLocation(location Location) (FileMetadata, error) {
97	+	return fileMetadataByLocation(i.squashed.img, location)
98	+	}
99	+

■ ■ ■ ■ ■ ■

syft/source/scope.go

		skipped 9 lines
10	10		UnknownScope Scope = "UnknownScope"
11	11		// SquashedScope indicates to only catalog content visible from the squashed filesystem representation (what can be seen only within the container at runtime)
12	12		SquashedScope Scope = "Squashed"
13		-	// AllLayersScope indicates to catalog content on all layers, irregardless if it is visible from the container at runtime.
	13	+	// AllLayersScope indicates to catalog content on all layers, regardless if it is visible from the container at runtime.
14	14		AllLayersScope Scope = "AllLayers"
	15	+	// SquashedWithAllLayersScope indicates to catalog content on all layers, but only include content visible from the squashed filesystem representation.
	16	+	SquashedWithAllLayersScope Scope = "SquashedWithAllLayers"
15	17		)
16	18
17	19		// AllScopes is a slice containing all possible scope options
18	20		var AllScopes = []Scope{
19	21		SquashedScope,
20	22		AllLayersScope,
	23	+	SquashedWithAllLayersScope,
21	24		}
22	25
23	26		// ParseScope returns a scope as indicated from the given string.
		skipped 3 lines
27	30		return SquashedScope
28	31		case "all-layers", strings.ToLower(AllLayersScope.String()):
29	32		return AllLayersScope
	33	+	case "squashed-with-all-layers", strings.ToLower(SquashedWithAllLayersScope.String()):
	34	+	return SquashedWithAllLayersScope
30	35		}
31	36		return UnknownScope
32	37		}
		skipped 5 lines

■ ■ ■ ■ ■ ■

syft/source/source.go

		skipped 465 lines
466	466		case SquashedScope:
467	467		resolver, err = newImageSquashResolver(s.Image)
468	468		case AllLayersScope:
469		-	resolver, err = newAllLayersResolver(s.Image)
	469	+	resolver, err = newImageAllLayersResolver(s.Image)
	470	+	case SquashedWithAllLayersScope:
	471	+	resolver, err = newImageSquashWithAllLayersResolver(s.Image)
470	472		default:
471	473		return nil, fmt.Errorf("bad image scope provided: %+v", scope)
472	474		}
		skipped 103 lines

add squashed with all layers resolver