opensnitch/daemon/tasks/pidmonitor/main.go
Gustavo Iñiguez Goia 543241f7cd
improved tasks stopping
We don't need to close the channels on stopping a task. We use a Context
to exit from the task results loop.
2025-11-20 01:25:31 +01:00

141 lines
2.8 KiB
Go

package pidmonitor
import (
"context"
"encoding/json"
"fmt"
"sync"
"time"
"unsafe"
"github.com/evilsocket/opensnitch/daemon/log"
"github.com/evilsocket/opensnitch/daemon/procmon"
"github.com/evilsocket/opensnitch/daemon/tasks/base"
)
// Name s the base name of this task.
// When adding a new task, it'll be created as "pid-monitor-" + <pid>
var Name = "pid-monitor"
// Config of this task
type Config struct {
Interval string
Pid int
}
// PIDMonitor monitors a process ID.
type PIDMonitor struct {
base.TaskBase
mu *sync.RWMutex
Ticker *time.Ticker
Interval string
Pid int
}
// New returns a new PIDMonitor
func New(pid int, interval string, stopOnDisconnect bool) (string, *PIDMonitor) {
return fmt.Sprint(Name, "-", pid), &PIDMonitor{
TaskBase: base.TaskBase{
Name: Name,
Results: make(chan interface{}),
Errors: make(chan error),
},
mu: &sync.RWMutex{},
Pid: pid,
Interval: interval,
}
}
// Start ...
func (pm *PIDMonitor) Start(ctx context.Context, cancel context.CancelFunc) error {
pm.mu.RLock()
defer pm.mu.RUnlock()
pm.Ctx = ctx
pm.Cancel = cancel
p := &procmon.Process{}
item, found := procmon.EventsCache.IsInStoreByPID(pm.Pid)
if found {
newProc := item.Proc
p = &newProc
if len(p.Tree) == 0 {
p.GetParent()
p.BuildTree()
}
} else {
p = procmon.NewProcess(pm.Pid, "")
}
if pm.Interval == "" {
pm.Interval = "5s"
}
interval, err := time.ParseDuration(pm.Interval)
if err != nil {
return err
}
pm.Ticker = time.NewTicker(interval)
go func(ctx context.Context) {
for {
select {
case <-ctx.Done():
goto Exit
default:
// TODO: errors counter, and exit on errors > X
if err := p.GetExtraInfo(); err != nil {
pm.TaskBase.Errors <- err
goto Exit
}
pJSON, err := json.Marshal(p)
if err != nil {
pm.TaskBase.Errors <- err
continue
}
// ~200µs (string()) vs ~60ns
pm.TaskBase.Results <- unsafe.String(unsafe.SliceData(pJSON), len(pJSON))
<-pm.Ticker.C
}
}
Exit:
log.Debug("[tasks.PIDMonitor] stopped (%d)", pm.Pid)
}(ctx)
return err
}
// Pause stops temporarily the task. For example it might be paused when the
// connection with the GUI (server) is closed.
func (pm *PIDMonitor) Pause() error {
// TODO
return nil
}
// Resume stopped tasks.
func (pm *PIDMonitor) Resume() error {
// TODO
return nil
}
// Stop ...
func (pm *PIDMonitor) Stop() error {
pm.mu.Lock()
defer pm.mu.Unlock()
log.Debug("[task.PIDMonitor] Stop()")
if pm.Ticker != nil {
pm.Ticker.Stop()
}
if pm.Cancel != nil {
pm.Cancel()
}
return nil
}
// Results ...
func (pm *PIDMonitor) Results() <-chan interface{} {
return pm.TaskBase.Results
}
// Errors ...
func (pm *PIDMonitor) Errors() <-chan error {
return pm.TaskBase.Errors
}