netmaker/models/node.go

389 lines
12 KiB
Go
Raw Normal View History

2021-03-26 00:17:52 +08:00
package models
import (
2021-10-09 03:07:12 +08:00
"bytes"
2021-07-25 04:13:24 +08:00
"errors"
2021-04-25 20:18:43 +08:00
"math/rand"
"net"
2021-07-25 04:13:24 +08:00
"strings"
2021-04-25 20:18:43 +08:00
"time"
"golang.org/x/crypto/bcrypt"
2021-03-26 00:17:52 +08:00
)
2021-07-27 22:48:58 +08:00
const TEN_YEARS_IN_SECONDS = 300000000
2021-11-16 00:42:52 +08:00
const MAX_NAME_LENGTH = 62
2021-08-03 06:06:26 +08:00
// == ACTIONS == (can only be set by GRPC)
const NODE_UPDATE_KEY = "updatekey"
2021-08-10 00:43:09 +08:00
const NODE_SERVER_NAME = "netmaker"
2021-08-03 06:06:26 +08:00
const NODE_DELETE = "delete"
const NODE_IS_PENDING = "pending"
2021-08-06 04:46:23 +08:00
const NODE_NOOP = "noop"
2021-08-03 06:06:26 +08:00
2021-03-26 00:17:52 +08:00
var seededRand *rand.Rand = rand.New(
2021-04-25 20:18:43 +08:00
rand.NewSource(time.Now().UnixNano()))
2021-03-26 00:17:52 +08:00
// node struct
2021-03-26 00:17:52 +08:00
type Node struct {
2021-07-25 04:13:24 +08:00
ID string `json:"id,omitempty" bson:"id,omitempty"`
2021-08-03 06:06:26 +08:00
Address string `json:"address" bson:"address" yaml:"address" validate:"omitempty,ipv4"`
Address6 string `json:"address6" bson:"address6" yaml:"address6" validate:"omitempty,ipv6"`
LocalAddress string `json:"localaddress" bson:"localaddress" yaml:"localaddress" validate:"omitempty,ip"`
2021-11-16 00:42:52 +08:00
Name string `json:"name" bson:"name" yaml:"name" validate:"omitempty,max=62,in_charset"`
2021-12-11 10:09:42 +08:00
NetworkSettings Network `json:"networksettings" bson:"networksettings" yaml:"networksettings" validate:"-"`
2021-08-03 06:06:26 +08:00
ListenPort int32 `json:"listenport" bson:"listenport" yaml:"listenport" validate:"omitempty,numeric,min=1024,max=65535"`
PublicKey string `json:"publickey" bson:"publickey" yaml:"publickey" validate:"required,base64"`
Endpoint string `json:"endpoint" bson:"endpoint" yaml:"endpoint" validate:"required,ip"`
PostUp string `json:"postup" bson:"postup" yaml:"postup"`
PostDown string `json:"postdown" bson:"postdown" yaml:"postdown"`
AllowedIPs []string `json:"allowedips" bson:"allowedips" yaml:"allowedips"`
PersistentKeepalive int32 `json:"persistentkeepalive" bson:"persistentkeepalive" yaml:"persistentkeepalive" validate:"omitempty,numeric,max=1000"`
SaveConfig string `json:"saveconfig" bson:"saveconfig" yaml:"saveconfig" validate:"checkyesorno"`
AccessKey string `json:"accesskey" bson:"accesskey" yaml:"accesskey"`
Interface string `json:"interface" bson:"interface" yaml:"interface"`
LastModified int64 `json:"lastmodified" bson:"lastmodified" yaml:"lastmodified"`
KeyUpdateTimeStamp int64 `json:"keyupdatetimestamp" bson:"keyupdatetimestamp" yaml:"keyupdatetimestamp"`
ExpirationDateTime int64 `json:"expdatetime" bson:"expdatetime" yaml:"expdatetime"`
LastPeerUpdate int64 `json:"lastpeerupdate" bson:"lastpeerupdate" yaml:"lastpeerupdate"`
LastCheckIn int64 `json:"lastcheckin" bson:"lastcheckin" yaml:"lastcheckin"`
MacAddress string `json:"macaddress" bson:"macaddress" yaml:"macaddress" validate:"required,min=5,macaddress_unique"`
// checkin interval is depreciated at the network level. Set on server with CHECKIN_INTERVAL
2021-08-03 06:06:26 +08:00
CheckInInterval int32 `json:"checkininterval" bson:"checkininterval" yaml:"checkininterval"`
Password string `json:"password" bson:"password" yaml:"password" validate:"required,min=6"`
Network string `json:"network" bson:"network" yaml:"network" validate:"network_exists"`
2021-09-18 22:33:14 +08:00
IsRelayed string `json:"isrelayed" bson:"isrelayed" yaml:"isrelayed"`
2021-08-03 06:06:26 +08:00
IsPending string `json:"ispending" bson:"ispending" yaml:"ispending"`
2021-09-18 22:33:14 +08:00
IsRelay string `json:"isrelay" bson:"isrelay" yaml:"isrelay" validate:"checkyesorno"`
2021-08-03 06:06:26 +08:00
IsEgressGateway string `json:"isegressgateway" bson:"isegressgateway" yaml:"isegressgateway"`
IsIngressGateway string `json:"isingressgateway" bson:"isingressgateway" yaml:"isingressgateway"`
EgressGatewayRanges []string `json:"egressgatewayranges" bson:"egressgatewayranges" yaml:"egressgatewayranges"`
2021-09-18 22:33:14 +08:00
RelayAddrs []string `json:"relayaddrs" bson:"relayaddrs" yaml:"relayaddrs"`
2021-08-03 06:06:26 +08:00
IngressGatewayRange string `json:"ingressgatewayrange" bson:"ingressgatewayrange" yaml:"ingressgatewayrange"`
2021-08-11 00:15:30 +08:00
IsStatic string `json:"isstatic" bson:"isstatic" yaml:"isstatic" validate:"checkyesorno"`
2021-08-03 06:06:26 +08:00
UDPHolePunch string `json:"udpholepunch" bson:"udpholepunch" yaml:"udpholepunch" validate:"checkyesorno"`
PullChanges string `json:"pullchanges" bson:"pullchanges" yaml:"pullchanges" validate:"checkyesorno"`
DNSOn string `json:"dnson" bson:"dnson" yaml:"dnson" validate:"checkyesorno"`
IsDualStack string `json:"isdualstack" bson:"isdualstack" yaml:"isdualstack" validate:"checkyesorno"`
2021-08-10 00:43:09 +08:00
IsServer string `json:"isserver" bson:"isserver" yaml:"isserver" validate:"checkyesorno"`
2021-08-03 06:06:26 +08:00
Action string `json:"action" bson:"action" yaml:"action"`
IsLocal string `json:"islocal" bson:"islocal" yaml:"islocal" validate:"checkyesorno"`
LocalRange string `json:"localrange" bson:"localrange" yaml:"localrange"`
Roaming string `json:"roaming" bson:"roaming" yaml:"roaming" validate:"checkyesorno"`
IPForwarding string `json:"ipforwarding" bson:"ipforwarding" yaml:"ipforwarding" validate:"checkyesorno"`
2021-08-31 03:58:23 +08:00
OS string `json:"os" bson:"os" yaml:"os"`
MTU int32 `json:"mtu" bson:"mtu" yaml:"mtu"`
}
type NodesArray []Node
func (a NodesArray) Len() int { return len(a) }
func (a NodesArray) Less(i, j int) bool { return isLess(a[i].Address, a[j].Address) }
func (a NodesArray) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func isLess(ipA string, ipB string) bool {
ipNetA := net.ParseIP(ipA)
ipNetB := net.ParseIP(ipB)
return bytes.Compare(ipNetA, ipNetB) < 0
}
2021-08-31 03:58:23 +08:00
func (node *Node) SetDefaultMTU() {
if node.MTU == 0 {
node.MTU = 1280
}
2021-08-03 06:06:26 +08:00
}
2021-08-11 00:15:30 +08:00
func (node *Node) SetDefaulIsPending() {
if node.IsPending == "" {
node.IsPending = "no"
}
}
2021-09-18 22:33:14 +08:00
func (node *Node) SetDefaultIsRelayed() {
if node.IsRelayed == "" {
node.IsRelayed = "no"
}
}
func (node *Node) SetDefaultIsRelay() {
if node.IsRelay == "" {
node.IsRelay = "no"
}
}
2021-08-11 00:15:30 +08:00
func (node *Node) SetDefaultEgressGateway() {
if node.IsEgressGateway == "" {
node.IsEgressGateway = "no"
}
}
func (node *Node) SetDefaultIngressGateway() {
if node.IsIngressGateway == "" {
node.IsIngressGateway = "no"
}
}
2021-08-06 04:46:23 +08:00
func (node *Node) SetDefaultAction() {
if node.Action == "" {
node.Action = NODE_NOOP
}
}
2021-08-06 00:52:50 +08:00
func (node *Node) SetRoamingDefault() {
if node.Roaming == "" {
node.Roaming = "yes"
2021-08-06 00:52:50 +08:00
}
}
func (node *Node) SetPullChangesDefault() {
if node.PullChanges == "" {
node.PullChanges = "no"
}
}
2021-08-03 06:06:26 +08:00
func (node *Node) SetIPForwardingDefault() {
if node.IPForwarding == "" {
node.IPForwarding = "yes"
2021-08-03 06:06:26 +08:00
}
}
func (node *Node) SetIsLocalDefault() {
if node.IsLocal == "" {
node.IsLocal = "no"
}
}
func (node *Node) SetDNSOnDefault() {
if node.DNSOn == "" {
2021-08-12 00:19:28 +08:00
node.DNSOn = "yes"
2021-08-03 06:06:26 +08:00
}
}
func (node *Node) SetIsDualStackDefault() {
if node.IsDualStack == "" {
node.IsDualStack = "no"
}
2021-03-26 00:17:52 +08:00
}
2021-08-10 00:43:09 +08:00
func (node *Node) SetIsServerDefault() {
if node.IsServer != "yes" {
node.IsServer = "no"
}
}
2021-08-10 02:28:43 +08:00
func (node *Node) SetIsStaticDefault() {
if node.IsServer == "yes" {
node.IsStatic = "yes"
} else if node.IsStatic != "yes" {
node.IsStatic = "no"
}
}
2021-04-25 20:18:43 +08:00
func (node *Node) SetLastModified() {
2021-03-26 00:17:52 +08:00
node.LastModified = time.Now().Unix()
}
2021-04-25 20:18:43 +08:00
func (node *Node) SetLastCheckIn() {
node.LastCheckIn = time.Now().Unix()
2021-03-26 00:17:52 +08:00
}
2021-04-25 20:18:43 +08:00
func (node *Node) SetLastPeerUpdate() {
node.LastPeerUpdate = time.Now().Unix()
2021-03-26 00:17:52 +08:00
}
2021-07-25 04:13:24 +08:00
func (node *Node) SetID() {
node.ID = node.MacAddress + "###" + node.Network
}
2021-04-25 20:18:43 +08:00
func (node *Node) SetExpirationDateTime() {
2021-07-27 22:48:58 +08:00
node.ExpirationDateTime = time.Now().Unix() + TEN_YEARS_IN_SECONDS
2021-04-06 08:47:19 +08:00
}
2021-04-25 20:18:43 +08:00
func (node *Node) SetDefaultName() {
if node.Name == "" {
2021-08-09 22:58:09 +08:00
node.Name = GenerateNodeName()
2021-04-25 20:18:43 +08:00
}
2021-03-26 00:17:52 +08:00
}
2021-11-15 08:17:30 +08:00
func (newNode *Node) Fill(currentNode *Node) {
2021-07-27 00:24:36 +08:00
if newNode.ID == "" {
newNode.ID = currentNode.ID
}
2021-08-11 00:15:30 +08:00
if newNode.Address == "" && newNode.IsStatic != "yes" {
2021-07-27 00:24:36 +08:00
newNode.Address = currentNode.Address
}
2021-08-11 00:15:30 +08:00
if newNode.Address6 == "" && newNode.IsStatic != "yes" {
2021-07-27 00:24:36 +08:00
newNode.Address6 = currentNode.Address6
}
if newNode.LocalAddress == "" {
newNode.LocalAddress = currentNode.LocalAddress
}
if newNode.Name == "" {
newNode.Name = currentNode.Name
}
2021-08-11 00:15:30 +08:00
if newNode.ListenPort == 0 && newNode.IsStatic != "yes" {
2021-07-27 00:24:36 +08:00
newNode.ListenPort = currentNode.ListenPort
}
2021-08-10 02:13:19 +08:00
if newNode.PublicKey == "" && newNode.IsStatic != "yes" {
2021-07-27 00:24:36 +08:00
newNode.PublicKey = currentNode.PublicKey
2021-07-27 01:57:50 +08:00
} else {
newNode.KeyUpdateTimeStamp = time.Now().Unix()
2021-07-27 00:24:36 +08:00
}
2021-08-11 00:15:30 +08:00
if newNode.Endpoint == "" && newNode.IsStatic != "yes" {
2021-07-27 00:24:36 +08:00
newNode.Endpoint = currentNode.Endpoint
}
if newNode.PostUp == "" {
newNode.PostUp = currentNode.PostUp
}
if newNode.PostDown == "" {
newNode.PostDown = currentNode.PostDown
}
if newNode.AllowedIPs == nil {
2021-12-11 10:09:42 +08:00
newNode.AllowedIPs = currentNode.AllowedIPs
2021-07-27 00:24:36 +08:00
}
if newNode.PersistentKeepalive == 0 {
newNode.PersistentKeepalive = currentNode.PersistentKeepalive
}
if newNode.SaveConfig == "" {
newNode.SaveConfig = currentNode.SaveConfig
}
if newNode.AccessKey == "" {
newNode.AccessKey = currentNode.AccessKey
}
if newNode.Interface == "" {
newNode.Interface = currentNode.Interface
}
if newNode.LastModified == 0 {
newNode.LastModified = currentNode.LastModified
}
if newNode.KeyUpdateTimeStamp == 0 {
newNode.LastModified = currentNode.LastModified
}
if newNode.ExpirationDateTime == 0 {
newNode.ExpirationDateTime = currentNode.ExpirationDateTime
}
if newNode.LastPeerUpdate == 0 {
newNode.LastPeerUpdate = currentNode.LastPeerUpdate
}
if newNode.LastCheckIn == 0 {
newNode.LastCheckIn = currentNode.LastCheckIn
}
if newNode.MacAddress == "" {
newNode.MacAddress = currentNode.MacAddress
}
if newNode.CheckInInterval == 0 {
newNode.CheckInInterval = currentNode.CheckInInterval
}
if newNode.Password != "" {
err := bcrypt.CompareHashAndPassword([]byte(newNode.Password), []byte(currentNode.Password))
if err != nil && currentNode.Password != newNode.Password {
hash, err := bcrypt.GenerateFromPassword([]byte(newNode.Password), 5)
if err == nil {
newNode.Password = string(hash)
}
}
} else {
newNode.Password = currentNode.Password
}
if newNode.Network == "" {
newNode.Network = currentNode.Network
}
if newNode.IsPending == "" {
newNode.IsPending = currentNode.IsPending
}
if newNode.IsEgressGateway == "" {
newNode.IsEgressGateway = currentNode.IsEgressGateway
}
if newNode.IsIngressGateway == "" {
newNode.IsIngressGateway = currentNode.IsIngressGateway
}
if newNode.EgressGatewayRanges == nil {
2021-12-11 10:09:42 +08:00
newNode.EgressGatewayRanges = currentNode.EgressGatewayRanges
2021-07-27 00:24:36 +08:00
}
if newNode.IngressGatewayRange == "" {
2021-12-11 10:09:42 +08:00
newNode.IngressGatewayRange = currentNode.IngressGatewayRange
2021-07-27 00:24:36 +08:00
}
2021-08-10 02:13:19 +08:00
if newNode.IsStatic == "" {
newNode.IsStatic = currentNode.IsStatic
2021-07-27 00:24:36 +08:00
}
if newNode.UDPHolePunch == "" {
newNode.UDPHolePunch = currentNode.SaveConfig
}
2021-08-03 06:06:26 +08:00
if newNode.DNSOn == "" {
newNode.DNSOn = currentNode.DNSOn
}
if newNode.IsDualStack == "" {
newNode.IsDualStack = currentNode.IsDualStack
}
if newNode.IsLocal == "" {
newNode.IsLocal = currentNode.IsLocal
}
if newNode.IPForwarding == "" {
newNode.IPForwarding = currentNode.IPForwarding
}
2021-08-06 00:55:20 +08:00
if newNode.PullChanges == "" {
newNode.PullChanges = currentNode.PullChanges
}
2021-08-03 06:06:26 +08:00
if newNode.Roaming == "" {
newNode.Roaming = currentNode.Roaming
}
if newNode.Action == "" {
newNode.Action = currentNode.Action
}
if newNode.IsServer == "" {
newNode.IsServer = currentNode.IsServer
}
2021-08-10 02:28:43 +08:00
if newNode.IsServer == "yes" {
newNode.IsStatic = "yes"
}
2021-08-31 03:58:23 +08:00
if newNode.MTU == 0 {
newNode.MTU = currentNode.MTU
}
2021-09-17 08:00:40 +08:00
if newNode.OS == "" {
newNode.OS = currentNode.OS
}
if newNode.RelayAddrs == nil {
2021-12-11 10:09:42 +08:00
newNode.RelayAddrs = currentNode.RelayAddrs
2021-09-17 08:00:40 +08:00
}
if newNode.IsRelay == "" {
newNode.IsRelay = currentNode.IsRelay
}
2021-09-18 22:33:14 +08:00
if newNode.IsRelayed == "" {
newNode.IsRelayed = currentNode.IsRelayed
2021-09-17 08:00:40 +08:00
}
2021-07-27 00:24:36 +08:00
}
2021-03-26 00:17:52 +08:00
func StringWithCharset(length int, charset string) string {
2021-04-25 20:18:43 +08:00
b := make([]byte, length)
for i := range b {
b[i] = charset[seededRand.Intn(len(charset))]
}
return string(b)
2021-03-26 00:17:52 +08:00
}
//Check for valid IPv4 address
//Note: We dont handle IPv6 AT ALL!!!!! This definitely is needed at some point
//But for iteration 1, lets just stick to IPv4. Keep it simple stupid.
func IsIpv4Net(host string) bool {
2021-04-25 20:18:43 +08:00
return net.ParseIP(host) != nil
2021-03-26 00:17:52 +08:00
}
2021-07-25 04:13:24 +08:00
func (node *Node) NameInNodeCharSet() bool {
charset := "abcdefghijklmnopqrstuvwxyz1234567890-"
for _, char := range node.Name {
if !strings.Contains(charset, strings.ToLower(string(char))) {
return false
}
}
return true
}
func (node *Node) GetID() (string, error) {
if node.MacAddress == "" || node.Network == "" {
2021-07-27 00:24:36 +08:00
return "", errors.New("unable to get record key")
}
return node.MacAddress + "###" + node.Network, nil
2021-07-27 00:24:36 +08:00
}