opensnitch/server/api/api.go
Gustavo Iñiguez Goia fbf94cc174 improved nodes api
2020-08-22 01:32:42 +02:00

82 lines
2.6 KiB
Go

package api
/*
Package api holds the functionality to interact with opensnitch
nodes/clients.
If a new client wants to connect to the server (UI, proxy2db, ...),
it must follow these steps:
1. Subscribe() - tell the server who we are.
2. Notifications() - open and keep opened a communication channel
3. Ping() - ping the server every n seconds, and send the statistics.
4. AskRule() - called when a new outgoing connection is about to be established.
*/
import (
"net"
"time"
"github.com/gustavo-iniguez-goya/opensnitch/daemon/log"
"github.com/gustavo-iniguez-goya/opensnitch/daemon/ui/protocol"
"golang.org/x/net/context"
"google.golang.org/grpc"
)
type server struct {
srv *protocol.UIServer
apiClient *Client
}
// Ping receives every second the stats of a node.
func (s *server) Ping(ctx context.Context, ping *protocol.PingRequest) (*protocol.PingReply, error) {
s.apiClient.UpdateStats(ctx, ping.Stats)
return &protocol.PingReply{Id: ping.Id}, nil
}
// AskRule waits for action on a new outgoing connection.
// If it not answered, after n seconds it'll apply the default action
func (s *server) AskRule(ctx context.Context, con *protocol.Connection) (*protocol.Rule, error) {
resultChan := s.apiClient.AskRule(con)
select {
case rule := <-resultChan:
return rule, nil
// XXX: the daemon as of v1.0.1 has this timeout hardcoded
case <-time.After(120 * time.Second):
// TODO: apply default action
return nil, nil
}
}
// Subscribe receives connections from new nodes with their configuration.
// The nodes are saved to keep a list of connected nodes.
func (s *server) Subscribe(ctx context.Context, clientConf *protocol.ClientConfig) (*protocol.ClientConfig, error) {
s.apiClient.AddNewNode(ctx, clientConf)
return &protocol.ClientConfig{}, nil
}
// Notifications opens a permanent channel to send commands back to the nodes.
// This function can't return until the connection with the node is closed,
// in order to maintain the communication channel opened.
func (s *server) Notifications(streamChannel protocol.UI_NotificationsServer) error {
s.apiClient.OpenChannelWithNode(streamChannel)
return nil
}
// StartServer start listening for incoming nodes/clients.
func startServer(client *Client, proto, port string) {
sockFd, err := net.Listen(proto, port)
if err != nil {
log.Error("failed to listen on %s: %v", port, err)
}
// create a server instance
s := server{}
s.apiClient = client
grpcServer := grpc.NewServer()
protocol.RegisterUIServer(grpcServer, &s)
// start the server
if err := grpcServer.Serve(sockFd); err != nil {
log.Error("failed to listen for new nodes: %s", err)
}
}