scanning

type ExecError struct {
	Op   string // Operation that failed
	Err  error  // Original error
	Host string // Host where the error occurred, if applicable
	Port uint16 // Port where the error occurred, if applicable
}

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

type Host struct {
	// Address is the IP address or hostname of the scanned host
	Address string
	// Status indicates whether the host is "up" or "down"
	Status string
	// Ports contains information about all scanned ports
	Ports []Port
	// OSName is the detected operating system name, if available
	OSName string
	// OSFamily is the detected operating system family (e.g. "Linux", "Windows")
	OSFamily string
	// OSVersion is the detected operating system version, if available
	OSVersion string
	// OSAccuracy is the confidence percentage (0-100) of the OS detection
	OSAccuracy int
}

type HostStats struct {
	// Up is the number of hosts that were up
	Up int
	// Down is the number of hosts that were down
	Down int
	// Total is the total number of hosts scanned
	Total int
}

type HostXML struct {
	Address string    `xml:"Address"`
	Status  string    `xml:"Status"`
	Ports   []PortXML `xml:"Ports,omitempty"`
}

type Job interface {
	// ID returns a stable identifier used for logging and deduplication.
	ID() string
	// Type returns the job category shown in the admin worker view (e.g. "scan", "discovery").
	Type() string
	// Target returns a human-readable description of the work target,
	// shown in the admin worker view (e.g. "192.168.1.0/24").
	Target() string
	// Execute runs the job to completion, respecting ctx for cancellation.
	Execute(ctx context.Context) error
}

type Port struct {
	// Number is the port number (1-65535)
	Number uint16
	// Protocol is the transport protocol ("tcp" or "udp")
	Protocol string
	// State indicates whether the port is "open", "closed", or "filtered"
	State string
	// Service is the name of the detected service, if any
	Service string
	// Version is the version of the detected service, if available
	Version string
	// ServiceInfo contains additional service details, if available
	ServiceInfo string
}

type PortXML struct {
	Number      uint16 `xml:"Number"`
	Protocol    string `xml:"Protocol"`
	State       string `xml:"State"`
	Service     string `xml:"Service"`
	Version     string `xml:"Version,omitempty"`
	ServiceInfo string `xml:"ServiceInfo,omitempty"`
}

type QueueStats struct {
	// QueueDepth is the number of scan requests currently waiting in the queue.
	QueueDepth int
	// ActiveScans is the number of scans currently being executed by workers.
	ActiveScans int
	// MaxConcurrent is the maximum number of simultaneous scans.
	MaxConcurrent int
	// MaxQueueSize is the maximum number of pending scan requests.
	MaxQueueSize int
	// TotalSubmitted is the total number of scan requests submitted.
	TotalSubmitted int64
	// TotalCompleted is the total number of scans completed successfully.
	TotalCompleted int64
	// TotalRejected is the total number of scan requests rejected (queue full or closed).
	TotalRejected int64
	// TotalFailed is the total number of scans that failed with an error.
	TotalFailed int64
}

type ResourceManager interface {
	// Acquire attempts to acquire a resource slot for the given scan ID.
	// It blocks until a slot is available or the context is cancelled.
	Acquire(ctx context.Context, scanID string) error

	// Release releases the resource slot for the given scan ID.
	Release(scanID string)

	// GetActiveScans returns the current number of active scans.
	GetActiveScans() int

	// GetAvailableSlots returns the number of available resource slots.
	GetAvailableSlots() int

	// IsHealthy returns true if the resource manager is operating normally.
	IsHealthy() bool

	// Close gracefully shuts down the resource manager.
	Close() error
}

type ScanConfig struct {
	// Targets is a list of targets to scan (IPs, hostnames, CIDR ranges)
	Targets []string
	// Ports specifies which ports to scan (e.g., "80,443" or "1-1000")
	Ports string
	// ScanType determines the type of scan: "connect", "syn", "ack", "udp", "aggressive", or "comprehensive"
	ScanType string
	// Timing sets the nmap timing template explicitly: "paranoid", "polite", "normal", "aggressive", "insane".
	// When set, this takes precedence over any timing derived from TimeoutSec.
	Timing string
	// OSDetection enables nmap OS fingerprinting (-O)
	OSDetection bool
	// TimeoutSec specifies scan timeout in seconds (0 = default timeout)
	TimeoutSec int
	// Concurrency specifies the number of concurrent scans (0 = auto)
	Concurrency int
	// RetryCount specifies the number of retry attempts for failed scans
	RetryCount int
	// RetryDelay specifies the delay between retries
	RetryDelay time.Duration
	// ScanID is the UUID of the existing scan_jobs row that triggered this scan.
	// When set, storeScanResults reuses this ID so that port_scans rows are
	// linked to the same UUID exposed to the API client via GetScanResults.
	// When nil a fresh UUID is generated (CLI / legacy path).
	ScanID *uuid.UUID
}

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

type ScanJobExecutor func(ctx context.Context, cfg *ScanConfig, database *db.DB) (*ScanResult, error)

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

type ScanResult struct {
	// Hosts contains all scanned hosts and their findings
	Hosts []Host
	// Stats contains summary statistics about the scan
	Stats HostStats
	// StartTime is when the scan started
	StartTime time.Time
	// EndTime is when the scan completed
	EndTime time.Time
	// Duration is how long the scan took
	Duration time.Duration
	// Error is any error that occurred during the scan
	Error error
}

type ScanXML struct {
	XMLName   xml.Name  `xml:"scanresult"`
	Hosts     []HostXML `xml:"host"`
	StartTime string    `xml:"start_time,attr"`
	EndTime   string    `xml:"end_time,attr"`
	Duration  string    `xml:"duration,attr"`
}

type WorkerSnapshot struct {
	// ID is the worker identifier (e.g. "worker-0").
	ID string
	// Status is "idle" or "active".
	Status string
	// JobID is the ID of the job currently being processed; empty when idle.
	JobID string
	// JobType is the type of the current job (e.g. "scan"); empty when idle.
	JobType string
	// JobTarget is the scan target of the current job; empty when idle.
	JobTarget string
	// JobStartedAt is when the current job started; nil when idle.
	JobStartedAt *time.Time
	// WorkerStartedAt is when this worker goroutine was started.
	WorkerStartedAt time.Time
	// LastJobAt is when this worker last completed a job; zero if never.
	LastJobAt time.Time
	// JobsDone is the number of jobs this worker has completed successfully.
	JobsDone int64
	// JobsFailed is the number of jobs this worker has failed.
	JobsFailed int64
}