file

type ContentResolver interface {
	FileContentsByLocation(Location) (io.ReadCloser, error)
}

type CoordinateSet struct {
	// contains filtered or unexported fields
}

type Coordinates struct {
	// RealPath is the canonical absolute form of the path accessed (all symbolic links have been followed and relative path components like '.' and '..' have been removed).
	RealPath string `json:"path" cyclonedx:"path"`

	// FileSystemID is an ID representing and entire filesystem. For container images, this is a layer digest. For directories or a root filesystem, this is blank.
	FileSystemID string `json:"layerID,omitempty" cyclonedx:"layerID"`
}

type Digest struct {
	// Algorithm specifies the hash algorithm used (e.g., "sha256", "md5").
	Algorithm string `json:"algorithm"`

	// Value is the hexadecimal string representation of the hash.
	Value string `json:"value"`
}

type ELFSecurityFeatures struct {
	// SymbolTableStripped indicates whether debugging symbols have been removed.
	SymbolTableStripped bool `json:"symbolTableStripped" yaml:"symbolTableStripped" mapstructure:"symbolTableStripped"`

	// StackCanary indicates whether stack smashing protection is enabled.
	StackCanary *bool `json:"stackCanary,omitempty" yaml:"stackCanary" mapstructure:"stackCanary"`

	// NoExecutable indicates whether NX (no-execute) protection is enabled for the stack.
	NoExecutable bool `json:"nx" yaml:"nx" mapstructure:"nx"`

	// RelocationReadOnly indicates the RELRO protection level.
	RelocationReadOnly RelocationReadOnly `json:"relRO" yaml:"relRO" mapstructure:"relRO"`

	// PositionIndependentExecutable indicates whether the binary is compiled as PIE.
	PositionIndependentExecutable bool `json:"pie" yaml:"pie" mapstructure:"pie"`

	// DynamicSharedObject indicates whether the binary is a shared library.
	DynamicSharedObject bool `json:"dso" yaml:"dso" mapstructure:"dso"`

	// LlvmSafeStack represents a compiler-based security mechanism that separates the stack into a safe stack for storing return addresses and other critical data, and an unsafe stack for everything else, to mitigate stack-based memory corruption errors
	// see https://clang.llvm.org/docs/SafeStack.html
	LlvmSafeStack *bool `json:"safeStack,omitempty" yaml:"safeStack" mapstructure:"safeStack"`

	// ControlFlowIntegrity represents runtime checks to ensure a program's control flow adheres to the legal paths determined at compile time, thus protecting against various types of control-flow hijacking attacks
	// see https://clang.llvm.org/docs/ControlFlowIntegrity.html
	LlvmControlFlowIntegrity *bool `json:"cfi,omitempty" yaml:"cfi" mapstructure:"cfi"`

	// ClangFortifySource is a broad suite of extensions to libc aimed at catching misuses of common library functions
	// see https://android.googlesource.com/platform//bionic/+/d192dbecf0b2a371eb127c0871f77a9caf81c4d2/docs/clang_fortify_anatomy.md
	ClangFortifySource *bool `json:"fortify,omitempty" yaml:"fortify" mapstructure:"fortify"`
}

type Executable struct {
	// Format denotes either ELF, Mach-O, or PE
	Format ExecutableFormat `json:"format" yaml:"format" mapstructure:"format"`

	// HasExports indicates whether the binary exports symbols.
	HasExports bool `json:"hasExports" yaml:"hasExports" mapstructure:"hasExports"`

	// HasEntrypoint indicates whether the binary has an entry point function.
	HasEntrypoint bool `json:"hasEntrypoint" yaml:"hasEntrypoint" mapstructure:"hasEntrypoint"`

	// ImportedLibraries lists the shared libraries required by this executable.
	ImportedLibraries []string `json:"importedLibraries" yaml:"importedLibraries" mapstructure:"importedLibraries"`

	// ELFSecurityFeatures contains ELF-specific security hardening information when Format is ELF.
	ELFSecurityFeatures *ELFSecurityFeatures `json:"elfSecurityFeatures,omitempty" yaml:"elfSecurityFeatures" mapstructure:"elfSecurityFeatures"`
}

type ExecutableFormat string

type License struct {
	// Value is the raw license string as found in the file.
	Value string

	// SPDXExpression is the parsed SPDX license expression if available.
	SPDXExpression string

	// Type categorizes how the license was determined (e.g., declared, concluded -- following the same semantics as SPDX).
	Type license.Type

	LicenseEvidence *LicenseEvidence

	// Contents optionally stores the full license text.
	Contents string `hash:"ignore"`
}

type LicenseEvidence struct {
	// Confidence is a score indicating certainty of the license match.
	Confidence int

	// Offset is the byte position where the license text begins in the file.
	Offset int

	// Extent is the length in bytes of the matched license text.
	Extent int
}

type Location struct {
	LocationData     `cyclonedx:""`
	LocationMetadata `cyclonedx:""`
}

type LocationData struct {
	Coordinates `cyclonedx:""` // Empty string here means there is no intermediate property name, e.g. syft:locations:0:path without "coordinates"

	// AccessPath is the path used to retrieve file contents (which may or may not have hardlinks / symlinks in the path)
	AccessPath string `hash:"ignore" json:"accessPath"`
	// contains filtered or unexported fields
}

type LocationMetadata struct {
	Annotations map[string]string `json:"annotations,omitempty"` // Arbitrary key-value pairs that can be used to annotate a location
}

type LocationReadCloser struct {
	Location
	io.ReadCloser
}

type LocationResolver interface {
	// AllLocations returns a channel of all file references from the underlying source.
	// The implementation for this may vary, however, generally the following considerations should be made:
	// - NO symlink resolution should be performed on results
	// - returns locations for any file or directory
	AllLocations(ctx context.Context) <-chan Location
}

type LocationSet struct {
	// contains filtered or unexported fields
}

type Locations []Location

type Metadata = file.Metadata

type MetadataResolver interface {
	FileMetadataByLocation(Location) (Metadata, error)
}

type MockResolver struct {
	// contains filtered or unexported fields
}

type PathResolver interface {
	// HasPath indicates if the given path exists in the underlying source.
	// The implementation for this may vary, however, generally the following considerations should be made:
	// - full symlink resolution should be performed on all requests
	// - returns locations for any file or directory
	HasPath(string) bool

	// FilesByPath fetches a set of file references which have the given path (for an image, there may be multiple matches).
	// The implementation for this may vary, however, generally the following considerations should be made:
	// - full symlink resolution should be performed on all requests
	// - only returns locations to files (NOT directories)
	FilesByPath(paths ...string) ([]Location, error)

	// FilesByGlob fetches a set of file references for the given glob matches
	// The implementation for this may vary, however, generally the following considerations should be made:
	// - full symlink resolution should be performed on all requests
	// - if multiple paths to the same file are found, the best single match should be returned
	// - only returns locations to files (NOT directories)
	FilesByGlob(patterns ...string) ([]Location, error)

	// FilesByMIMEType fetches a set of file references which the contents have been classified as one of the given MIME Types.
	FilesByMIMEType(types ...string) ([]Location, error)

	// RelativeFileByPath fetches a single file at the given path relative to the layer squash of the given reference.
	// This is helpful when attempting to find a file that is in the same layer or lower as another file.
	RelativeFileByPath(_ Location, path string) *Location
}

type RelocationReadOnly string

type Resolver interface {
	ContentResolver
	PathResolver
	LocationResolver
	MetadataResolver
}

type SearchResult struct {
	// Classification identifies the type or category of the matched content.
	Classification string `json:"classification"`

	// LineNumber is the 1-indexed line number where the match was found.
	LineNumber int64 `json:"lineNumber"`

	// LineOffset is the character offset from the start of the line where the match begins.
	LineOffset int64 `json:"lineOffset"`

	// SeekPosition is the absolute byte offset from the start of the file.
	SeekPosition int64 `json:"seekPosition"`

	// Length is the size in bytes of the matched content.
	Length int64 `json:"length"`

	// Value optionally contains the actual matched content.
	Value string `json:"value,omitempty"`
}

type Selection string

type WritableResolver interface {
	Resolver

	Write(location Location, reader io.Reader) error
}