2021-10-06 03:02:09 +08:00
|
|
|
package logic
|
|
|
|
|
|
|
|
import (
|
|
|
|
"encoding/json"
|
2023-03-14 03:06:07 +08:00
|
|
|
"fmt"
|
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"
|
|
|
|
"github.com/gravitl/netmaker/models"
|
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
|
|
|
|
}
|
|
|
|
deleteExtClientFromCache(key)
|
|
|
|
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-06-27 23:18:53 +08:00
|
|
|
allextclients := getAllExtClientsFromCache()
|
|
|
|
if len(allextclients) != 0 {
|
|
|
|
for _, extclient := range allextclients {
|
|
|
|
if extclient.Network == network {
|
|
|
|
extclients = append(extclients, extclient)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return extclients, nil
|
|
|
|
}
|
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-06-27 23:18:53 +08:00
|
|
|
key, err := GetRecordKey(extclient.ClientID, network)
|
|
|
|
if err == nil {
|
|
|
|
storeExtClientInCache(key, extclient)
|
|
|
|
}
|
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-06-27 23:18:53 +08:00
|
|
|
if extclient, ok := getExtClientFromCache(key); ok {
|
|
|
|
return extclient, nil
|
|
|
|
}
|
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-06-27 23:18:53 +08:00
|
|
|
storeExtClientInCache(key, extclient)
|
2021-12-08 01:46:55 +08:00
|
|
|
return extclient, err
|
|
|
|
}
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
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-06-27 23:18:53 +08:00
|
|
|
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-05-17 22:58:03 +08:00
|
|
|
if update.ExtraAllowedIPs != nil && StringDifference(old.ExtraAllowedIPs, update.ExtraAllowedIPs) != nil {
|
|
|
|
new.ExtraAllowedIPs = update.ExtraAllowedIPs
|
2023-03-14 03:06:07 +08:00
|
|
|
}
|
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
|
|
|
|
}
|