We don't need to close the channels on stopping a task. We use a Context to exit from the task results loop.
154 lines
3.2 KiB
Go
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
|
|
}
|