2021-12-08 01:46:55 +08:00
|
|
|
package logic
|
|
|
|
|
|
|
|
import (
|
|
|
|
"errors"
|
|
|
|
"time"
|
|
|
|
|
|
|
|
"github.com/gravitl/netmaker/database"
|
|
|
|
"github.com/gravitl/netmaker/logger"
|
|
|
|
"github.com/gravitl/netmaker/models"
|
2024-02-28 09:46:51 +08:00
|
|
|
"github.com/gravitl/netmaker/servercfg"
|
2021-12-08 01:46:55 +08:00
|
|
|
)
|
|
|
|
|
2024-02-28 09:46:51 +08:00
|
|
|
// IsInternetGw - checks if node is acting as internet gw
|
|
|
|
func IsInternetGw(node models.Node) bool {
|
|
|
|
return node.IsInternetGateway
|
|
|
|
}
|
2023-12-07 03:57:58 +08:00
|
|
|
|
2023-10-06 14:22:58 +08:00
|
|
|
// GetInternetGateways - gets all the nodes that are internet gateways
|
|
|
|
func GetInternetGateways() ([]models.Node, error) {
|
|
|
|
nodes, err := GetAllNodes()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
igs := make([]models.Node, 0)
|
|
|
|
for _, node := range nodes {
|
2024-02-28 09:46:51 +08:00
|
|
|
if node.IsInternetGateway {
|
|
|
|
igs = append(igs, node)
|
2023-10-06 14:22:58 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return igs, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetAllIngresses - gets all the nodes that are ingresses
|
2023-08-09 01:47:49 +08:00
|
|
|
func GetAllIngresses() ([]models.Node, error) {
|
|
|
|
nodes, err := GetAllNodes()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
ingresses := make([]models.Node, 0)
|
|
|
|
for _, node := range nodes {
|
|
|
|
if node.IsIngressGateway {
|
|
|
|
ingresses = append(ingresses, node)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ingresses, nil
|
|
|
|
}
|
|
|
|
|
2023-10-06 14:22:58 +08:00
|
|
|
// GetAllEgresses - gets all the nodes that are egresses
|
2023-08-09 01:47:49 +08:00
|
|
|
func GetAllEgresses() ([]models.Node, error) {
|
|
|
|
nodes, err := GetAllNodes()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
egresses := make([]models.Node, 0)
|
|
|
|
for _, node := range nodes {
|
|
|
|
if node.IsEgressGateway {
|
|
|
|
egresses = append(egresses, node)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return egresses, nil
|
|
|
|
}
|
|
|
|
|
2021-12-08 01:46:55 +08:00
|
|
|
// CreateEgressGateway - creates an egress gateway
|
2022-12-21 04:29:09 +08:00
|
|
|
func CreateEgressGateway(gateway models.EgressGatewayRequest) (models.Node, error) {
|
|
|
|
node, err := GetNodeByID(gateway.NodeID)
|
|
|
|
if err != nil {
|
|
|
|
return models.Node{}, err
|
|
|
|
}
|
|
|
|
host, err := GetHost(node.HostID.String())
|
|
|
|
if err != nil {
|
|
|
|
return models.Node{}, err
|
|
|
|
}
|
2023-02-07 00:14:30 +08:00
|
|
|
if host.OS != "linux" { // support for other OS to be added
|
2022-12-21 04:29:09 +08:00
|
|
|
return models.Node{}, errors.New(host.OS + " is unsupported for egress gateways")
|
2022-01-26 22:04:30 +08:00
|
|
|
}
|
2023-04-27 22:32:58 +08:00
|
|
|
if host.FirewallInUse == models.FIREWALL_NONE {
|
2023-04-27 22:35:41 +08:00
|
|
|
return models.Node{}, errors.New("firewall is not supported for egress gateways")
|
2023-04-27 22:32:58 +08:00
|
|
|
}
|
2023-02-07 00:04:47 +08:00
|
|
|
for i := len(gateway.Ranges) - 1; i >= 0; i-- {
|
2023-08-09 01:47:49 +08:00
|
|
|
// check if internet gateway IPv4
|
2023-12-07 03:57:58 +08:00
|
|
|
if gateway.Ranges[i] == "0.0.0.0/0" || gateway.Ranges[i] == "::/0" {
|
2024-01-18 00:53:48 +08:00
|
|
|
// remove inet range
|
|
|
|
gateway.Ranges = append(gateway.Ranges[:i], gateway.Ranges[i+1:]...)
|
|
|
|
continue
|
2023-02-07 00:04:47 +08:00
|
|
|
}
|
|
|
|
normalized, err := NormalizeCIDR(gateway.Ranges[i])
|
|
|
|
if err != nil {
|
|
|
|
return models.Node{}, err
|
|
|
|
}
|
|
|
|
gateway.Ranges[i] = normalized
|
|
|
|
|
|
|
|
}
|
2022-07-20 19:01:28 +08:00
|
|
|
if gateway.NatEnabled == "" {
|
|
|
|
gateway.NatEnabled = "yes"
|
|
|
|
}
|
2021-12-08 01:46:55 +08:00
|
|
|
err = ValidateEgressGateway(gateway)
|
|
|
|
if err != nil {
|
2022-12-21 04:29:09 +08:00
|
|
|
return models.Node{}, err
|
2021-12-08 01:46:55 +08:00
|
|
|
}
|
2024-02-13 21:24:22 +08:00
|
|
|
if gateway.Ranges == nil {
|
|
|
|
gateway.Ranges = make([]string, 0)
|
|
|
|
}
|
2022-12-21 04:29:09 +08:00
|
|
|
node.IsEgressGateway = true
|
2021-12-08 01:46:55 +08:00
|
|
|
node.EgressGatewayRanges = gateway.Ranges
|
2022-12-22 19:42:33 +08:00
|
|
|
node.EgressGatewayNatEnabled = models.ParseBool(gateway.NatEnabled)
|
2022-08-08 10:22:54 +08:00
|
|
|
node.EgressGatewayRequest = gateway // store entire request for use when preserving the egress gateway
|
2021-12-08 01:46:55 +08:00
|
|
|
node.SetLastModified()
|
2023-06-26 04:10:28 +08:00
|
|
|
if err = UpsertNode(&node); err != nil {
|
2022-12-21 04:29:09 +08:00
|
|
|
return models.Node{}, err
|
2021-12-08 01:46:55 +08:00
|
|
|
}
|
|
|
|
return node, nil
|
|
|
|
}
|
|
|
|
|
2022-01-11 23:58:20 +08:00
|
|
|
// ValidateEgressGateway - validates the egress gateway model
|
2021-12-08 01:46:55 +08:00
|
|
|
func ValidateEgressGateway(gateway models.EgressGatewayRequest) error {
|
2024-02-13 21:24:22 +08:00
|
|
|
return nil
|
2021-12-08 01:46:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// DeleteEgressGateway - deletes egress from node
|
2022-12-21 04:29:09 +08:00
|
|
|
func DeleteEgressGateway(network, nodeid string) (models.Node, error) {
|
2022-01-11 06:52:21 +08:00
|
|
|
node, err := GetNodeByID(nodeid)
|
2021-12-08 01:46:55 +08:00
|
|
|
if err != nil {
|
2022-12-21 04:29:09 +08:00
|
|
|
return models.Node{}, err
|
2021-12-08 01:46:55 +08:00
|
|
|
}
|
2022-12-21 04:29:09 +08:00
|
|
|
node.IsEgressGateway = false
|
2021-12-08 01:46:55 +08:00
|
|
|
node.EgressGatewayRanges = []string{}
|
2022-08-08 10:22:54 +08:00
|
|
|
node.EgressGatewayRequest = models.EgressGatewayRequest{} // remove preserved request as the egress gateway is gone
|
2021-12-08 01:46:55 +08:00
|
|
|
node.SetLastModified()
|
2023-06-26 04:10:28 +08:00
|
|
|
if err = UpsertNode(&node); err != nil {
|
2022-12-21 04:29:09 +08:00
|
|
|
return models.Node{}, err
|
2021-12-08 01:46:55 +08:00
|
|
|
}
|
|
|
|
return node, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// CreateIngressGateway - creates an ingress gateway
|
2023-05-17 22:58:03 +08:00
|
|
|
func CreateIngressGateway(netid string, nodeid string, ingress models.IngressRequest) (models.Node, error) {
|
2021-12-08 01:46:55 +08:00
|
|
|
|
2022-01-11 06:52:21 +08:00
|
|
|
node, err := GetNodeByID(nodeid)
|
2022-12-21 04:29:09 +08:00
|
|
|
if err != nil {
|
|
|
|
return models.Node{}, err
|
2022-12-13 20:06:36 +08:00
|
|
|
}
|
2023-06-20 00:26:14 +08:00
|
|
|
if node.IsRelayed {
|
|
|
|
return models.Node{}, errors.New("ingress cannot be created on a relayed node")
|
|
|
|
}
|
2022-12-21 04:29:09 +08:00
|
|
|
host, err := GetHost(node.HostID.String())
|
2021-12-08 01:46:55 +08:00
|
|
|
if err != nil {
|
2022-12-21 04:29:09 +08:00
|
|
|
return models.Node{}, err
|
|
|
|
}
|
2023-01-25 19:35:45 +08:00
|
|
|
if host.OS != "linux" {
|
|
|
|
return models.Node{}, errors.New("ingress can only be created on linux based node")
|
|
|
|
}
|
2022-12-21 04:29:09 +08:00
|
|
|
if host.FirewallInUse == models.FIREWALL_NONE {
|
|
|
|
return models.Node{}, errors.New("firewall is not supported for ingress gateways")
|
2021-12-08 01:46:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
network, err := GetParentNetwork(netid)
|
|
|
|
if err != nil {
|
2022-12-21 04:29:09 +08:00
|
|
|
return models.Node{}, err
|
2021-12-08 01:46:55 +08:00
|
|
|
}
|
2022-12-21 04:29:09 +08:00
|
|
|
node.IsIngressGateway = true
|
2024-02-28 09:46:51 +08:00
|
|
|
if !servercfg.IsPro {
|
|
|
|
node.IsInternetGateway = ingress.IsInternetGateway
|
|
|
|
}
|
2021-12-08 01:46:55 +08:00
|
|
|
node.IngressGatewayRange = network.AddressRange
|
2022-09-02 23:01:19 +08:00
|
|
|
node.IngressGatewayRange6 = network.AddressRange6
|
2023-05-17 22:58:03 +08:00
|
|
|
node.IngressDNS = ingress.ExtclientDNS
|
2024-04-12 20:52:03 +08:00
|
|
|
if servercfg.IsPro {
|
|
|
|
if _, exists := FailOverExists(node.Network); exists {
|
|
|
|
ResetFailedOverPeer(&node)
|
|
|
|
}
|
|
|
|
}
|
2021-12-08 01:46:55 +08:00
|
|
|
node.SetLastModified()
|
2024-01-20 00:17:18 +08:00
|
|
|
if node.Metadata == "" {
|
|
|
|
node.Metadata = "This host can be used for remote access"
|
|
|
|
}
|
2023-06-26 04:10:28 +08:00
|
|
|
err = UpsertNode(&node)
|
2021-12-08 01:46:55 +08:00
|
|
|
if err != nil {
|
2022-12-21 04:29:09 +08:00
|
|
|
return models.Node{}, err
|
2021-12-08 01:46:55 +08:00
|
|
|
}
|
|
|
|
err = SetNetworkNodesLastModified(netid)
|
|
|
|
return node, err
|
|
|
|
}
|
|
|
|
|
2023-09-01 16:57:08 +08:00
|
|
|
// GetIngressGwUsers - lists the users having to access to ingressGW
|
|
|
|
func GetIngressGwUsers(node models.Node) (models.IngressGwUsers, error) {
|
|
|
|
|
|
|
|
gwUsers := models.IngressGwUsers{
|
|
|
|
NodeID: node.ID.String(),
|
|
|
|
Network: node.Network,
|
|
|
|
}
|
|
|
|
users, err := GetUsers()
|
|
|
|
if err != nil {
|
|
|
|
return gwUsers, err
|
|
|
|
}
|
|
|
|
for _, user := range users {
|
|
|
|
if !user.IsAdmin && !user.IsSuperAdmin {
|
|
|
|
gwUsers.Users = append(gwUsers.Users, user)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return gwUsers, nil
|
|
|
|
}
|
|
|
|
|
2021-12-08 01:46:55 +08:00
|
|
|
// DeleteIngressGateway - deletes an ingress gateway
|
2023-11-30 00:10:07 +08:00
|
|
|
func DeleteIngressGateway(nodeid string) (models.Node, []models.ExtClient, error) {
|
2023-04-07 00:27:33 +08:00
|
|
|
removedClients := []models.ExtClient{}
|
2022-01-12 02:05:22 +08:00
|
|
|
node, err := GetNodeByID(nodeid)
|
2021-12-08 01:46:55 +08:00
|
|
|
if err != nil {
|
2023-11-30 00:10:07 +08:00
|
|
|
return models.Node{}, removedClients, err
|
2021-12-08 01:46:55 +08:00
|
|
|
}
|
2023-07-28 23:46:35 +08:00
|
|
|
clients, err := GetExtClientsByID(nodeid, node.Network)
|
2023-04-12 22:16:18 +08:00
|
|
|
if err != nil && !database.IsEmptyRecord(err) {
|
2023-11-30 00:10:07 +08:00
|
|
|
return models.Node{}, removedClients, err
|
2023-04-07 00:27:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
removedClients = clients
|
|
|
|
|
2021-12-08 01:46:55 +08:00
|
|
|
// delete ext clients belonging to ingress gateway
|
2023-07-28 23:46:35 +08:00
|
|
|
if err = DeleteGatewayExtClients(node.ID.String(), node.Network); err != nil {
|
2023-11-30 00:10:07 +08:00
|
|
|
return models.Node{}, removedClients, err
|
2021-12-08 01:46:55 +08:00
|
|
|
}
|
2022-08-04 02:36:16 +08:00
|
|
|
logger.Log(3, "deleting ingress gateway")
|
2022-12-21 04:29:09 +08:00
|
|
|
node.LastModified = time.Now()
|
|
|
|
node.IsIngressGateway = false
|
2024-02-28 09:46:51 +08:00
|
|
|
if !servercfg.IsPro {
|
|
|
|
node.IsInternetGateway = false
|
|
|
|
}
|
2021-12-08 01:46:55 +08:00
|
|
|
node.IngressGatewayRange = ""
|
2024-01-20 00:17:18 +08:00
|
|
|
node.Metadata = ""
|
2023-06-26 04:10:28 +08:00
|
|
|
err = UpsertNode(&node)
|
2021-12-08 01:46:55 +08:00
|
|
|
if err != nil {
|
2023-11-30 00:10:07 +08:00
|
|
|
return models.Node{}, removedClients, err
|
2021-12-08 01:46:55 +08:00
|
|
|
}
|
2023-07-28 23:46:35 +08:00
|
|
|
err = SetNetworkNodesLastModified(node.Network)
|
2023-11-30 00:10:07 +08:00
|
|
|
return node, removedClients, err
|
2021-12-08 01:46:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// DeleteGatewayExtClients - deletes ext clients based on gateway (mac) of ingress node and network
|
|
|
|
func DeleteGatewayExtClients(gatewayID string, networkName string) error {
|
|
|
|
currentExtClients, err := GetNetworkExtClients(networkName)
|
2023-04-11 23:04:36 +08:00
|
|
|
if database.IsEmptyRecord(err) {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
if err != nil {
|
2021-12-08 01:46:55 +08:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
for _, extClient := range currentExtClients {
|
|
|
|
if extClient.IngressGatewayID == gatewayID {
|
|
|
|
if err = DeleteExtClient(networkName, extClient.ClientID); err != nil {
|
|
|
|
logger.Log(1, "failed to remove ext client", extClient.ClientID)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
2023-09-01 16:57:08 +08:00
|
|
|
|
|
|
|
// IsUserAllowedAccessToExtClient - checks if user has permission to access extclient
|
|
|
|
func IsUserAllowedAccessToExtClient(username string, client models.ExtClient) bool {
|
|
|
|
if username == MasterUser {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
user, err := GetUser(username)
|
|
|
|
if err != nil {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
if !user.IsAdmin && !user.IsSuperAdmin {
|
|
|
|
if user.UserName != client.OwnerID {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true
|
|
|
|
}
|