opensnitch/daemon/ui/notifications_tasks.go
2025-11-27 21:32:39 +01:00

127 lines
3.7 KiB
Go

package ui
import (
"fmt"
"github.com/evilsocket/opensnitch/daemon/core"
"github.com/evilsocket/opensnitch/daemon/log"
"github.com/evilsocket/opensnitch/daemon/tasks"
taskBase "github.com/evilsocket/opensnitch/daemon/tasks/base"
"github.com/evilsocket/opensnitch/daemon/tasks/nodemonitor"
"github.com/evilsocket/opensnitch/daemon/tasks/pidmonitor"
"github.com/evilsocket/opensnitch/daemon/tasks/socketsmonitor"
"github.com/evilsocket/opensnitch/daemon/ui/protocol"
"golang.org/x/net/context"
)
// monitor events of the tasks manager: new task added, removed, etc.
func (c *Client) monitorTaskManager(tm *tasks.TaskManager) {
for {
select {
case <-TaskMgr.Ctx.Done():
goto Exit
case taskEvent := <-TaskMgr.TaskAdded:
log.Debug("Task Added: %s", taskEvent.Name)
go c.monitorTaskEvents(
taskEvent.Ctx,
taskEvent.Name,
c.streamNotifications,
0,
taskEvent.Task.GetID(),
taskEvent.Task.Results(),
taskEvent.Task.Errors(),
)
case taskEvent := <-TaskMgr.TaskRemoved:
log.Debug("Task removed: %v", taskEvent.Name)
}
}
Exit:
}
// monitor events sent by the tasks.
func (c *Client) monitorTaskEvents(ctx context.Context, taskName string, stream protocol.UI_NotificationsClient, ntfType protocol.Action, ntfId uint64, results <-chan interface{}, errors <-chan error) {
postMsg := func(data string, err error) {
// when a task is loaded from disk, we don't have a notification ID to
// identify this task on the UI. For these cases, we use a unique ID for
// each task.
// The notification ID sent from the UI is a timestamp, so we don't expect
// low values here.
if stream != nil && ntfId > 10000 {
c.sendNotificationReply(stream, ntfType, ntfId, data, err)
} else {
alertType := protocol.Alert_INFO
if err != nil {
alertType = protocol.Alert_ERROR
}
c.PostAlert(
alertType,
protocol.Alert_GENERIC,
protocol.Alert_SHOW_ALERT,
protocol.Alert_MEDIUM,
data)
c.loggers.Log(
taskBase.TaskNotification{Data: data, Name: taskName},
nil,
nil)
}
}
for {
select {
case <-ctx.Done():
goto Exit
case err := <-errors:
postMsg("", err)
case temp := <-results:
data, ok := temp.(string)
if ok {
postMsg(data, nil)
}
}
}
Exit:
// task should have already been removed via TASK_STOP
log.Debug("[tasks] stop monitoring events %d (%d)", ntfId, ntfType)
}
func (c *Client) monitorSockets(config interface{}, stream protocol.UI_NotificationsClient, ntf *protocol.Notification) {
sockMonTask, err := socketsmonitor.New(socketsmonitor.Name, config, true)
sockMonTask.SetID(ntf.Id)
if err != nil {
c.sendNotificationReply(stream, ntf.Type, ntf.Id, "", err)
return
}
_, err = TaskMgr.AddTask(sockMonTask.Name, sockMonTask)
if err != nil {
c.sendNotificationReply(stream, ntf.Type, ntf.Id, "", err)
return
}
}
func (c *Client) monitorNode(node, interval string, stream protocol.UI_NotificationsClient, ntf *protocol.Notification) {
taskName, nodeMonTask := nodemonitor.New(node, interval, true)
nodeMonTask.SetID(ntf.Id)
_, err := TaskMgr.AddTask(taskName, nodeMonTask)
if err != nil {
c.sendNotificationReply(stream, ntf.Type, ntf.Id, "", err)
return
}
}
func (c *Client) monitorProcessDetails(pid int, interval string, stream protocol.UI_NotificationsClient, ntf *protocol.Notification) {
if !core.Exists(fmt.Sprint("/proc/", pid)) {
c.sendNotificationReply(stream, ntf.Type, ntf.Id, "", fmt.Errorf("The process is no longer running"))
return
}
taskName, pidMonTask := pidmonitor.New(pid, interval, true)
pidMonTask.SetID(ntf.Id)
_, err := TaskMgr.AddTask(taskName, pidMonTask)
if err != nil {
c.sendNotificationReply(stream, ntf.Type, ntf.Id, "", err)
return
}
}