2021-10-06 03:02:09 +08:00
|
|
|
package logic
|
|
|
|
|
|
|
|
import (
|
|
|
|
"encoding/json"
|
2023-03-14 03:06:07 +08:00
|
|
|
"fmt"
|
2023-11-24 23:29:43 +08:00
|
|
|
"net"
|
2023-07-26 13:02:54 +08:00
|
|
|
"reflect"
|
2023-06-27 23:18:53 +08:00
|
|
|
"sync"
|
2021-12-08 01:46:55 +08:00
|
|
|
"time"
|
2021-10-06 03:02:09 +08:00
|
|
|
|
|
|
|
"github.com/gravitl/netmaker/database"
|
2023-11-24 23:29:43 +08:00
|
|
|
"github.com/gravitl/netmaker/logger"
|
2021-10-06 03:02:09 +08:00
|
|
|
"github.com/gravitl/netmaker/models"
|
2023-12-05 16:01:35 +08:00
|
|
|
"github.com/gravitl/netmaker/servercfg"
|
2023-10-02 12:57:58 +08:00
|
|
|
"golang.org/x/exp/slog"
|
2021-12-08 01:46:55 +08:00
|
|
|
"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
|
2021-10-06 03:02:09 +08:00
|
|
|
)
|
|
|
|
|
2023-06-27 23:18:53 +08:00
|
|
|
var (
|
|
|
|
extClientCacheMutex = &sync.RWMutex{}
|
|
|
|
extClientCacheMap = make(map[string]models.ExtClient)
|
|
|
|
)
|
2021-10-06 03:02:09 +08:00
|
|
|
|
2023-06-27 23:18:53 +08:00
|
|
|
func getAllExtClientsFromCache() (extClients []models.ExtClient) {
|
|
|
|
extClientCacheMutex.RLock()
|
|
|
|
for _, extclient := range extClientCacheMap {
|
|
|
|
extClients = append(extClients, extclient)
|
2021-10-06 03:02:09 +08:00
|
|
|
}
|
2023-06-28 00:01:04 +08:00
|
|
|
extClientCacheMutex.RUnlock()
|
2023-06-27 23:18:53 +08:00
|
|
|
return
|
|
|
|
}
|
2021-10-06 03:02:09 +08:00
|
|
|
|
2023-06-27 23:18:53 +08:00
|
|
|
func deleteExtClientFromCache(key string) {
|
|
|
|
extClientCacheMutex.Lock()
|
|
|
|
delete(extClientCacheMap, key)
|
|
|
|
extClientCacheMutex.Unlock()
|
|
|
|
}
|
2022-04-23 01:04:34 +08:00
|
|
|
|
2023-06-27 23:18:53 +08:00
|
|
|
func getExtClientFromCache(key string) (extclient models.ExtClient, ok bool) {
|
|
|
|
extClientCacheMutex.RLock()
|
|
|
|
extclient, ok = extClientCacheMap[key]
|
|
|
|
extClientCacheMutex.RUnlock()
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
func storeExtClientInCache(key string, extclient models.ExtClient) {
|
|
|
|
extClientCacheMutex.Lock()
|
|
|
|
extClientCacheMap[key] = extclient
|
|
|
|
extClientCacheMutex.Unlock()
|
2021-10-06 03:02:09 +08:00
|
|
|
}
|
2021-10-27 00:27:29 +08:00
|
|
|
|
|
|
|
// ExtClient.GetEgressRangesOnNetwork - returns the egress ranges on network of ext client
|
|
|
|
func GetEgressRangesOnNetwork(client *models.ExtClient) ([]string, error) {
|
|
|
|
|
|
|
|
var result []string
|
2023-06-26 04:10:28 +08:00
|
|
|
networkNodes, err := GetNetworkNodes(client.Network)
|
2021-10-27 00:27:29 +08:00
|
|
|
if err != nil {
|
|
|
|
return []string{}, err
|
|
|
|
}
|
2023-06-26 04:10:28 +08:00
|
|
|
for _, currentNode := range networkNodes {
|
2021-10-27 00:27:29 +08:00
|
|
|
if currentNode.Network != client.Network {
|
|
|
|
continue
|
|
|
|
}
|
2022-12-21 04:29:09 +08:00
|
|
|
if currentNode.IsEgressGateway { // add the egress gateway range(s) to the result
|
2021-10-27 00:27:29 +08:00
|
|
|
if len(currentNode.EgressGatewayRanges) > 0 {
|
|
|
|
result = append(result, currentNode.EgressGatewayRanges...)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return result, nil
|
|
|
|
}
|
2021-12-08 01:46:55 +08:00
|
|
|
|
|
|
|
// DeleteExtClient - deletes an existing ext client
|
|
|
|
func DeleteExtClient(network string, clientid string) error {
|
|
|
|
key, err := GetRecordKey(clientid, network)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
err = database.DeleteRecord(database.EXT_CLIENT_TABLE_NAME, key)
|
2023-06-27 23:18:53 +08:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2023-12-05 16:01:35 +08:00
|
|
|
if servercfg.CacheEnabled() {
|
|
|
|
deleteExtClientFromCache(key)
|
|
|
|
}
|
2023-06-27 23:18:53 +08:00
|
|
|
return nil
|
2021-12-08 01:46:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// GetNetworkExtClients - gets the ext clients of given network
|
|
|
|
func GetNetworkExtClients(network string) ([]models.ExtClient, error) {
|
|
|
|
var extclients []models.ExtClient
|
2023-12-05 16:01:35 +08:00
|
|
|
if servercfg.CacheEnabled() {
|
|
|
|
allextclients := getAllExtClientsFromCache()
|
|
|
|
if len(allextclients) != 0 {
|
|
|
|
for _, extclient := range allextclients {
|
|
|
|
if extclient.Network == network {
|
|
|
|
extclients = append(extclients, extclient)
|
|
|
|
}
|
2023-06-27 23:18:53 +08:00
|
|
|
}
|
2023-12-05 16:01:35 +08:00
|
|
|
return extclients, nil
|
2023-06-27 23:18:53 +08:00
|
|
|
}
|
|
|
|
}
|
2021-12-08 01:46:55 +08:00
|
|
|
records, err := database.FetchRecords(database.EXT_CLIENT_TABLE_NAME)
|
|
|
|
if err != nil {
|
2023-07-26 13:02:54 +08:00
|
|
|
if database.IsEmptyRecord(err) {
|
|
|
|
return extclients, nil
|
|
|
|
}
|
2021-12-08 01:46:55 +08:00
|
|
|
return extclients, err
|
|
|
|
}
|
|
|
|
for _, value := range records {
|
|
|
|
var extclient models.ExtClient
|
|
|
|
err = json.Unmarshal([]byte(value), &extclient)
|
|
|
|
if err != nil {
|
|
|
|
continue
|
|
|
|
}
|
2023-11-02 03:36:46 +08:00
|
|
|
key, err := GetRecordKey(extclient.ClientID, extclient.Network)
|
2023-06-27 23:18:53 +08:00
|
|
|
if err == nil {
|
2023-12-05 16:01:35 +08:00
|
|
|
if servercfg.CacheEnabled() {
|
|
|
|
storeExtClientInCache(key, extclient)
|
|
|
|
}
|
2023-06-27 23:18:53 +08:00
|
|
|
}
|
2021-12-08 01:46:55 +08:00
|
|
|
if extclient.Network == network {
|
|
|
|
extclients = append(extclients, extclient)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return extclients, err
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetExtClient - gets a single ext client on a network
|
|
|
|
func GetExtClient(clientid string, network string) (models.ExtClient, error) {
|
|
|
|
var extclient models.ExtClient
|
|
|
|
key, err := GetRecordKey(clientid, network)
|
|
|
|
if err != nil {
|
|
|
|
return extclient, err
|
|
|
|
}
|
2023-12-05 16:01:35 +08:00
|
|
|
if servercfg.CacheEnabled() {
|
|
|
|
if extclient, ok := getExtClientFromCache(key); ok {
|
|
|
|
return extclient, nil
|
|
|
|
}
|
2023-06-27 23:18:53 +08:00
|
|
|
}
|
2021-12-08 01:46:55 +08:00
|
|
|
data, err := database.FetchRecord(database.EXT_CLIENT_TABLE_NAME, key)
|
|
|
|
if err != nil {
|
|
|
|
return extclient, err
|
|
|
|
}
|
|
|
|
err = json.Unmarshal([]byte(data), &extclient)
|
2023-12-05 16:01:35 +08:00
|
|
|
if servercfg.CacheEnabled() {
|
|
|
|
storeExtClientInCache(key, extclient)
|
|
|
|
}
|
2021-12-08 01:46:55 +08:00
|
|
|
return extclient, err
|
|
|
|
}
|
|
|
|
|
2023-11-08 21:43:41 +08:00
|
|
|
// GetGwExtclients - return all ext clients attached to the passed gw id
|
|
|
|
func GetGwExtclients(nodeID, network string) []models.ExtClient {
|
|
|
|
gwClients := []models.ExtClient{}
|
|
|
|
clients, err := GetNetworkExtClients(network)
|
|
|
|
if err != nil {
|
|
|
|
return gwClients
|
|
|
|
}
|
|
|
|
for _, client := range clients {
|
|
|
|
if client.IngressGatewayID == nodeID {
|
|
|
|
gwClients = append(gwClients, client)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return gwClients
|
|
|
|
}
|
|
|
|
|
2023-03-14 03:06:07 +08:00
|
|
|
// GetExtClient - gets a single ext client on a network
|
|
|
|
func GetExtClientByPubKey(publicKey string, network string) (*models.ExtClient, error) {
|
|
|
|
netClients, err := GetNetworkExtClients(network)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
for i := range netClients {
|
|
|
|
ec := netClients[i]
|
|
|
|
if ec.PublicKey == publicKey {
|
|
|
|
return &ec, nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil, fmt.Errorf("no client found")
|
|
|
|
}
|
|
|
|
|
2023-08-01 22:50:43 +08:00
|
|
|
// CreateExtClient - creates and saves an extclient
|
2021-12-11 10:09:42 +08:00
|
|
|
func CreateExtClient(extclient *models.ExtClient) error {
|
2023-08-01 22:50:43 +08:00
|
|
|
// lock because we may need unique IPs and having it concurrent makes parallel calls result in same "unique" IPs
|
2023-07-27 14:04:15 +08:00
|
|
|
addressLock.Lock()
|
|
|
|
defer addressLock.Unlock()
|
2023-01-13 12:43:45 +08:00
|
|
|
|
2023-03-07 04:54:50 +08:00
|
|
|
if len(extclient.PublicKey) == 0 {
|
2021-12-08 01:46:55 +08:00
|
|
|
privateKey, err := wgtypes.GeneratePrivateKey()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
extclient.PrivateKey = privateKey.String()
|
|
|
|
extclient.PublicKey = privateKey.PublicKey().String()
|
2023-04-06 00:06:15 +08:00
|
|
|
} else if len(extclient.PrivateKey) == 0 && len(extclient.PublicKey) > 0 {
|
2023-03-07 04:54:50 +08:00
|
|
|
extclient.PrivateKey = "[ENTER PRIVATE KEY]"
|
2021-12-08 01:46:55 +08:00
|
|
|
}
|
2023-11-27 16:24:31 +08:00
|
|
|
if extclient.ExtraAllowedIPs == nil {
|
|
|
|
extclient.ExtraAllowedIPs = []string{}
|
|
|
|
}
|
2021-12-08 01:46:55 +08:00
|
|
|
|
2022-04-20 02:17:21 +08:00
|
|
|
parentNetwork, err := GetNetwork(extclient.Network)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2022-04-21 22:29:43 +08:00
|
|
|
if extclient.Address == "" {
|
|
|
|
if parentNetwork.IsIPv4 == "yes" {
|
2023-01-13 21:41:40 +08:00
|
|
|
newAddress, err := UniqueAddress(extclient.Network, true)
|
2022-04-21 22:29:43 +08:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2022-12-21 04:29:09 +08:00
|
|
|
extclient.Address = newAddress.String()
|
2021-12-08 01:46:55 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-04-21 22:29:43 +08:00
|
|
|
if extclient.Address6 == "" {
|
|
|
|
if parentNetwork.IsIPv6 == "yes" {
|
2023-01-13 21:41:40 +08:00
|
|
|
addr6, err := UniqueAddress6(extclient.Network, true)
|
2022-04-21 22:29:43 +08:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2022-12-21 04:29:09 +08:00
|
|
|
extclient.Address6 = addr6.String()
|
2022-03-09 06:11:53 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-08 01:46:55 +08:00
|
|
|
if extclient.ClientID == "" {
|
|
|
|
extclient.ClientID = models.GenerateNodeName()
|
|
|
|
}
|
|
|
|
|
|
|
|
extclient.LastModified = time.Now().Unix()
|
2023-05-17 22:58:03 +08:00
|
|
|
return SaveExtClient(extclient)
|
|
|
|
}
|
|
|
|
|
|
|
|
// SaveExtClient - saves an ext client to database
|
|
|
|
func SaveExtClient(extclient *models.ExtClient) error {
|
2021-12-08 01:46:55 +08:00
|
|
|
key, err := GetRecordKey(extclient.ClientID, extclient.Network)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
data, err := json.Marshal(&extclient)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if err = database.Insert(key, string(data), database.EXT_CLIENT_TABLE_NAME); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2023-12-05 16:01:35 +08:00
|
|
|
if servercfg.CacheEnabled() {
|
|
|
|
storeExtClientInCache(key, *extclient)
|
|
|
|
}
|
2022-03-09 06:11:53 +08:00
|
|
|
return SetNetworkNodesLastModified(extclient.Network)
|
2021-12-08 01:46:55 +08:00
|
|
|
}
|
|
|
|
|
2023-05-17 22:58:03 +08:00
|
|
|
// UpdateExtClient - updates an ext client with new values
|
2023-08-01 22:50:43 +08:00
|
|
|
func UpdateExtClient(old *models.ExtClient, update *models.CustomExtClient) models.ExtClient {
|
|
|
|
new := *old
|
2023-05-17 22:58:03 +08:00
|
|
|
new.ClientID = update.ClientID
|
|
|
|
if update.PublicKey != "" && old.PublicKey != update.PublicKey {
|
|
|
|
new.PublicKey = update.PublicKey
|
|
|
|
}
|
2023-09-18 15:58:04 +08:00
|
|
|
if update.DNS != old.DNS {
|
2023-05-17 22:58:03 +08:00
|
|
|
new.DNS = update.DNS
|
|
|
|
}
|
|
|
|
if update.Enabled != old.Enabled {
|
|
|
|
new.Enabled = update.Enabled
|
2023-03-29 03:12:09 +08:00
|
|
|
}
|
2023-11-24 19:17:27 +08:00
|
|
|
new.ExtraAllowedIPs = update.ExtraAllowedIPs
|
2023-07-26 13:02:54 +08:00
|
|
|
if update.DeniedACLs != nil && !reflect.DeepEqual(old.DeniedACLs, update.DeniedACLs) {
|
|
|
|
new.DeniedACLs = update.DeniedACLs
|
|
|
|
}
|
2023-08-01 22:50:43 +08:00
|
|
|
return new
|
2021-12-08 01:46:55 +08:00
|
|
|
}
|
2022-09-14 03:25:56 +08:00
|
|
|
|
|
|
|
// GetExtClientsByID - gets the clients of attached gateway
|
|
|
|
func GetExtClientsByID(nodeid, network string) ([]models.ExtClient, error) {
|
|
|
|
var result []models.ExtClient
|
|
|
|
currentClients, err := GetNetworkExtClients(network)
|
|
|
|
if err != nil {
|
|
|
|
return result, err
|
|
|
|
}
|
|
|
|
for i := range currentClients {
|
|
|
|
if currentClients[i].IngressGatewayID == nodeid {
|
|
|
|
result = append(result, currentClients[i])
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetAllExtClients - gets all ext clients from DB
|
|
|
|
func GetAllExtClients() ([]models.ExtClient, error) {
|
|
|
|
var clients = []models.ExtClient{}
|
|
|
|
currentNetworks, err := GetNetworks()
|
|
|
|
if err != nil && database.IsEmptyRecord(err) {
|
|
|
|
return clients, nil
|
|
|
|
} else if err != nil {
|
|
|
|
return clients, err
|
|
|
|
}
|
|
|
|
|
|
|
|
for i := range currentNetworks {
|
|
|
|
netName := currentNetworks[i].NetID
|
|
|
|
netClients, err := GetNetworkExtClients(netName)
|
|
|
|
if err != nil {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
clients = append(clients, netClients...)
|
|
|
|
}
|
|
|
|
|
|
|
|
return clients, nil
|
|
|
|
}
|
2023-10-02 12:57:58 +08:00
|
|
|
|
|
|
|
// ToggleExtClientConnectivity - enables or disables an ext client
|
|
|
|
func ToggleExtClientConnectivity(client *models.ExtClient, enable bool) (models.ExtClient, error) {
|
|
|
|
update := models.CustomExtClient{
|
|
|
|
Enabled: enable,
|
|
|
|
ClientID: client.ClientID,
|
|
|
|
PublicKey: client.PublicKey,
|
|
|
|
DNS: client.DNS,
|
|
|
|
ExtraAllowedIPs: client.ExtraAllowedIPs,
|
|
|
|
DeniedACLs: client.DeniedACLs,
|
|
|
|
RemoteAccessClientID: client.RemoteAccessClientID,
|
|
|
|
}
|
|
|
|
|
|
|
|
// update in DB
|
|
|
|
newClient := UpdateExtClient(client, &update)
|
|
|
|
if err := DeleteExtClient(client.Network, client.ClientID); err != nil {
|
|
|
|
slog.Error("failed to delete ext client during update", "id", client.ClientID, "network", client.Network, "error", err)
|
|
|
|
return newClient, err
|
|
|
|
}
|
|
|
|
if err := SaveExtClient(&newClient); err != nil {
|
|
|
|
slog.Error("failed to save updated ext client during update", "id", newClient.ClientID, "network", newClient.Network, "error", err)
|
|
|
|
return newClient, err
|
|
|
|
}
|
|
|
|
|
|
|
|
return newClient, nil
|
|
|
|
}
|
2023-11-24 23:29:43 +08:00
|
|
|
|
|
|
|
func getExtPeers(node, peer *models.Node) ([]wgtypes.PeerConfig, []models.IDandAddr, []models.EgressNetworkRoutes, error) {
|
|
|
|
var peers []wgtypes.PeerConfig
|
|
|
|
var idsAndAddr []models.IDandAddr
|
|
|
|
var egressRoutes []models.EgressNetworkRoutes
|
|
|
|
extPeers, err := GetNetworkExtClients(node.Network)
|
|
|
|
if err != nil {
|
|
|
|
return peers, idsAndAddr, egressRoutes, err
|
|
|
|
}
|
|
|
|
host, err := GetHost(node.HostID.String())
|
|
|
|
if err != nil {
|
|
|
|
return peers, idsAndAddr, egressRoutes, err
|
|
|
|
}
|
|
|
|
for _, extPeer := range extPeers {
|
|
|
|
extPeer := extPeer
|
|
|
|
if !IsClientNodeAllowed(&extPeer, peer.ID.String()) {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
pubkey, err := wgtypes.ParseKey(extPeer.PublicKey)
|
|
|
|
if err != nil {
|
|
|
|
logger.Log(1, "error parsing ext pub key:", err.Error())
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
if host.PublicKey.String() == extPeer.PublicKey ||
|
|
|
|
extPeer.IngressGatewayID != node.ID.String() || !extPeer.Enabled {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
var allowedips []net.IPNet
|
|
|
|
var peer wgtypes.PeerConfig
|
|
|
|
if extPeer.Address != "" {
|
|
|
|
var peeraddr = net.IPNet{
|
|
|
|
IP: net.ParseIP(extPeer.Address),
|
|
|
|
Mask: net.CIDRMask(32, 32),
|
|
|
|
}
|
|
|
|
if peeraddr.IP != nil && peeraddr.Mask != nil {
|
|
|
|
allowedips = append(allowedips, peeraddr)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if extPeer.Address6 != "" {
|
|
|
|
var addr6 = net.IPNet{
|
|
|
|
IP: net.ParseIP(extPeer.Address6),
|
|
|
|
Mask: net.CIDRMask(128, 128),
|
|
|
|
}
|
|
|
|
if addr6.IP != nil && addr6.Mask != nil {
|
|
|
|
allowedips = append(allowedips, addr6)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for _, extraAllowedIP := range extPeer.ExtraAllowedIPs {
|
|
|
|
_, cidr, err := net.ParseCIDR(extraAllowedIP)
|
|
|
|
if err == nil {
|
|
|
|
allowedips = append(allowedips, *cidr)
|
|
|
|
}
|
|
|
|
}
|
2023-11-27 14:16:18 +08:00
|
|
|
egressRoutes = append(egressRoutes, getExtPeerEgressRoute(extPeer)...)
|
2023-11-24 23:29:43 +08:00
|
|
|
primaryAddr := extPeer.Address
|
|
|
|
if primaryAddr == "" {
|
|
|
|
primaryAddr = extPeer.Address6
|
|
|
|
}
|
|
|
|
peer = wgtypes.PeerConfig{
|
|
|
|
PublicKey: pubkey,
|
|
|
|
ReplaceAllowedIPs: true,
|
|
|
|
AllowedIPs: allowedips,
|
|
|
|
}
|
|
|
|
peers = append(peers, peer)
|
|
|
|
idsAndAddr = append(idsAndAddr, models.IDandAddr{
|
|
|
|
ID: peer.PublicKey.String(),
|
|
|
|
Name: extPeer.ClientID,
|
|
|
|
Address: primaryAddr,
|
|
|
|
IsExtClient: true,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
return peers, idsAndAddr, egressRoutes, nil
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
func getExtPeerEgressRoute(extPeer models.ExtClient) (egressRoutes []models.EgressNetworkRoutes) {
|
|
|
|
if extPeer.Address != "" {
|
|
|
|
egressRoutes = append(egressRoutes, models.EgressNetworkRoutes{
|
|
|
|
NodeAddr: extPeer.AddressIPNet4(),
|
|
|
|
EgressRanges: extPeer.ExtraAllowedIPs,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
if extPeer.Address6 != "" {
|
|
|
|
egressRoutes = append(egressRoutes, models.EgressNetworkRoutes{
|
|
|
|
NodeAddr: extPeer.AddressIPNet6(),
|
|
|
|
EgressRanges: extPeer.ExtraAllowedIPs,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
func getExtpeersExtraRoutes(network string) (egressRoutes []models.EgressNetworkRoutes) {
|
|
|
|
extPeers, err := GetNetworkExtClients(network)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
for _, extPeer := range extPeers {
|
|
|
|
egressRoutes = append(egressRoutes, getExtPeerEgressRoute(extPeer)...)
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
2023-12-13 21:30:43 +08:00
|
|
|
|
|
|
|
func GetExtclientAllowedIPs(client models.ExtClient) (allowedIPs []string) {
|
|
|
|
gwnode, err := GetNodeByID(client.IngressGatewayID)
|
|
|
|
if err != nil {
|
|
|
|
logger.Log(0,
|
|
|
|
fmt.Sprintf("failed to get ingress gateway node [%s] info: %v", client.IngressGatewayID, err))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
network, err := GetParentNetwork(client.Network)
|
|
|
|
if err != nil {
|
|
|
|
logger.Log(1, "Could not retrieve Ingress Gateway Network", client.Network)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if IsInternetGw(gwnode) {
|
|
|
|
egressrange := "0.0.0.0/0"
|
|
|
|
if gwnode.Address6.IP != nil && client.Address6 != "" {
|
|
|
|
egressrange += "," + "::/0"
|
|
|
|
}
|
|
|
|
allowedIPs = []string{egressrange}
|
|
|
|
} else {
|
|
|
|
allowedIPs = []string{network.AddressRange}
|
|
|
|
|
|
|
|
if network.AddressRange6 != "" {
|
|
|
|
allowedIPs = append(allowedIPs, network.AddressRange6)
|
|
|
|
}
|
|
|
|
if egressGatewayRanges, err := GetEgressRangesOnNetwork(&client); err == nil {
|
|
|
|
allowedIPs = append(allowedIPs, egressGatewayRanges...)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|