tls

type CloserFunc func() error

type ContainerScanResult struct {
	// SharedLibraries is a map of probe name to (library path -> scan result)
	SharedLibraries map[string]map[string]ProbeScanResult
}

type ExeAttachable struct {
	// PID is the process ID of the process that is being attached.
	PID int
	// Path is the path to the executable of the process that is being attached.
	Path string
	// Root is the root fs path of the process that is being attached.
	Root string
}

type ExeElfScannable struct {
	ExeScannable

	// Elf is the parsed ELF file. This the primary source of information in most cases.
	Elf *binutils.Elf
}

type ExeLibraryAttachable struct {
	Path string
	Exe  *link.Executable
}

type ExeLinkAttachable struct {
	ExeAttachable

	Exe *link.Executable
}

type ExeScannable struct {
	// Path is the path to the executable
	Path string
	// Cmdline is the command+args that was used to start this process
	Cmdline []string
	// Root is the container root filesystem path for this process
	Root string
}

type KeyedCoordinator[K comparable] struct {
	// contains filtered or unexported fields
}

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

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

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

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

type MultiCloser []io.Closer

type Probe interface {
	// Name returns the unique identifier for this probe (e.g., "openssl")
	Name() string

	// Scan performs detailed analysis of the binary to gather all information needed for attaching probes.
	// If the probe does not detect anything, it should return a ProbeScanResult with ProbeDetected() == false.
	//
	// The returned ProbeScanResult may be cached and reused across process restarts for future Attach calls.
	Scan(ctx context.Context, target *ExeElfScannable) (ProbeScanResult, error)

	// Attach attaches probes to the process using the scan result.
	//
	// Returns a Closer that must be called when the process exits to clean up the probes.
	Attach(ctx context.Context, target *ExeLinkAttachable, result ProbeScanResult) (io.Closer, error)

	// SharedLibraries returns the name prefix of the shared libraries this probe can attach to.
	//
	// The string is a library name prefix (e.g., "libssl.so", "libcrypto.so")
	SharedLibraries() string

	// ScanLibrary scans a shared library for TLS probe attachment points.
	// This will be called for each of the libraries returned by SharedLibraries() that were found.
	ScanLibrary(ctx context.Context, ef *binutils.Elf) (ProbeScanResult, error)

	// AttachLibrary attaches probes to a shared library.
	AttachLibrary(ctx context.Context, target *ExeLibraryAttachable, result ProbeScanResult) (io.Closer, error)

	// Close cleans up any global resources used by the probe.
	Close() error
}

type ProbeScanResult interface {
	// ProbeName returns the name of the probe that produced this result
	ProbeName() string

	// ProbeDetected returns true if the probe was detected in the binary.
	ProbeDetected() bool
}

type ScanResult struct {
	Hash  string
	Mtime int64
	// ProbeResults is a map of probe name to scan result
	ProbeResults map[string]ProbeScanResult
}

type SharedLibrary struct {
	// Name corresponds to the library name prefix.
	Name string

	// Paths is a list of unique filesystem paths to the library.
	Paths []string
}

type TargetScanner interface {
	Scan(ctx context.Context, target *ExeScannable) (*ScanResult, error)
	Attach(ctx context.Context, attachable *ExeAttachable, res *ScanResult) (io.Closer, error)
	ScanContainer(ctx context.Context, id, root string) (*ContainerScanResult, error)
	AttachContainer(ctx context.Context, res *ContainerScanResult) (io.Closer, error)
	Close() error
}

type TargetScannerOption func(*targetScanner)

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

type TlsObserver interface {
	ProcessScanStarted(ctx context.Context, proc *process.Process) error
	ProcessAttachCompleted(ctx context.Context, proc *process.Process) error
	ProcessStopped(ctx context.Context, proc *process.Process) error
	ContainerScanStarted(ctx context.Context, id string) error
	ContainerAttachCompleted(ctx context.Context, id string) error
}