opensnitch/daemon/tasks/socketsmonitor/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

154 lines
3.2 KiB
Go

package socketsmonitor
import (
"context"
"encoding/json"
"fmt"
"sync"
"time"
"unsafe"
"github.com/evilsocket/opensnitch/daemon/log"
"github.com/evilsocket/opensnitch/daemon/tasks/base"
)
// Name of this task
var Name = "sockets-monitor"
// Config of this task
// {"interval": "5s", "states": "0,1,2,3", "family": 2, "proto": 17}
type monConfig struct {
Interval string
State uint8
Proto uint8
Family uint8
}
// SocketsMonitor monitors a process ID.
type SocketsMonitor struct {
base.TaskBase
mu *sync.RWMutex
Ticker *time.Ticker
Config *monConfig
states uint8
// stop the task if the daemon is disconnected from the GUI (server)
StopOnDisconnect bool
}
// initConfig parses the received configuration, and initializes it if
// it's not complete.
func initConfig(config interface{}) (*monConfig, error) {
// https://pkg.go.dev/encoding/json#Unmarshal
// JSON objects (are converted) to map[string]interface{}
cfg, ok := config.(map[string]interface{})
if !ok {
return nil, fmt.Errorf("[sockmon] invalid config received: %v", config)
}
var newCfg monConfig
newCfg.Interval = cfg["interval"].(string)
newCfg.State = uint8(cfg["state"].(float64))
newCfg.Proto = uint8(cfg["proto"].(float64))
newCfg.Family = uint8(cfg["family"].(float64))
if newCfg.Interval == "" {
newCfg.Interval = "5s"
}
return &newCfg, nil
}
// New returns a new SocketsMonitor
func New(name string, config interface{}, stopOnDisconnect bool) (*SocketsMonitor, error) {
cfg, err := initConfig(config)
if err != nil {
return nil, err
}
return &SocketsMonitor{
TaskBase: base.TaskBase{
Name: Name,
Results: make(chan interface{}),
Errors: make(chan error),
},
mu: &sync.RWMutex{},
StopOnDisconnect: stopOnDisconnect,
Config: cfg,
}, nil
}
// Start ...
func (pm *SocketsMonitor) Start(ctx context.Context, cancel context.CancelFunc) error {
pm.mu.Lock()
defer pm.mu.Unlock()
pm.Ctx = ctx
pm.Cancel = cancel
interval, err := time.ParseDuration(pm.Config.Interval)
if err != nil {
return err
}
pm.Ticker = time.NewTicker(interval)
go func(ctx context.Context) {
for {
select {
case <-ctx.Done():
goto Exit
default:
// FIXME: ensure that dumpSockets() are not overlapped
socketList := pm.dumpSockets()
sockJSON, err := json.Marshal(socketList)
if err != nil {
pm.TaskBase.Errors <- err
}
pm.TaskBase.Results <- unsafe.String(unsafe.SliceData(sockJSON), len(sockJSON))
<-pm.Ticker.C
}
}
Exit:
log.Debug("[tasks.SocketsMonitor] stopped")
}(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 *SocketsMonitor) Pause() error {
// TODO
return nil
}
// Resume stopped tasks.
func (pm *SocketsMonitor) Resume() error {
// TODO
return nil
}
// Stop ...
func (pm *SocketsMonitor) Stop() error {
pm.mu.RLock()
defer pm.mu.RUnlock()
log.Debug("[task.SocketsMonitor] Stop()")
if pm.Ticker != nil {
pm.Ticker.Stop()
}
if pm.Cancel != nil {
pm.Cancel()
}
return nil
}
// Results ...
func (pm *SocketsMonitor) Results() <-chan interface{} {
return pm.TaskBase.Results
}
// Errors ...
func (pm *SocketsMonitor) Errors() <-chan error {
return pm.TaskBase.Errors
}