2020-06-21 04:32:08 -06:00
|
|
|
package headscale
|
|
|
|
|
|
|
|
import (
|
2022-01-16 06:16:59 -07:00
|
|
|
"database/sql/driver"
|
2020-06-21 04:32:08 -06:00
|
|
|
"fmt"
|
2021-02-21 16:53:37 -07:00
|
|
|
"sort"
|
2021-02-22 15:27:33 -07:00
|
|
|
"strconv"
|
2021-10-02 15:03:34 -06:00
|
|
|
"strings"
|
2020-06-21 04:32:08 -06:00
|
|
|
"time"
|
|
|
|
|
2021-10-06 16:06:07 -06:00
|
|
|
"github.com/fatih/set"
|
2021-11-13 01:39:04 -07:00
|
|
|
v1 "github.com/juanfont/headscale/gen/go/headscale/v1"
|
2021-08-05 11:11:26 -06:00
|
|
|
"github.com/rs/zerolog/log"
|
2021-11-04 16:11:38 -06:00
|
|
|
"google.golang.org/protobuf/types/known/timestamppb"
|
2021-02-20 14:43:07 -07:00
|
|
|
"inet.af/netaddr"
|
2020-06-21 04:32:08 -06:00
|
|
|
"tailscale.com/tailcfg"
|
2021-11-26 16:30:42 -07:00
|
|
|
"tailscale.com/types/key"
|
2020-06-21 04:32:08 -06:00
|
|
|
)
|
|
|
|
|
2021-11-15 12:18:14 -07:00
|
|
|
const (
|
2022-02-28 01:06:39 -07:00
|
|
|
errMachineNotFound = Error("machine not found")
|
|
|
|
errMachineRouteIsNotAvailable = Error("route is not available on machine")
|
|
|
|
errMachineAddressesInvalid = Error("failed to parse machine addresses")
|
|
|
|
errMachineNotFoundRegistrationCache = Error(
|
|
|
|
"machine not found in registration cache",
|
|
|
|
)
|
|
|
|
errCouldNotConvertMachineInterface = Error("failed to convert machine interface")
|
|
|
|
errHostnameTooLong = Error("Hostname too long")
|
2022-02-23 06:21:46 -07:00
|
|
|
)
|
|
|
|
|
|
|
|
const (
|
|
|
|
maxHostnameLength = 255
|
2021-11-15 12:18:14 -07:00
|
|
|
)
|
|
|
|
|
2021-11-13 01:39:04 -07:00
|
|
|
// Machine is a Headscale client.
|
2020-06-21 04:32:08 -06:00
|
|
|
type Machine struct {
|
2021-02-27 16:58:09 -07:00
|
|
|
ID uint64 `gorm:"primary_key"`
|
|
|
|
MachineKey string `gorm:"type:varchar(64);unique_index"`
|
|
|
|
NodeKey string
|
|
|
|
DiscoKey string
|
2022-01-16 06:16:59 -07:00
|
|
|
IPAddresses MachineAddresses
|
2021-02-27 16:58:09 -07:00
|
|
|
Name string
|
|
|
|
NamespaceID uint
|
2021-06-25 10:57:08 -06:00
|
|
|
Namespace Namespace `gorm:"foreignKey:NamespaceID"`
|
2020-06-21 04:32:08 -06:00
|
|
|
|
2021-05-05 16:08:36 -06:00
|
|
|
RegisterMethod string
|
2022-02-27 10:40:10 -07:00
|
|
|
|
2022-04-15 05:11:41 -06:00
|
|
|
ForcedTags StringList
|
|
|
|
|
2022-02-27 10:40:10 -07:00
|
|
|
// TODO(kradalby): This seems like irrelevant information?
|
|
|
|
AuthKeyID uint
|
|
|
|
AuthKey *PreAuthKey
|
2021-05-05 16:08:36 -06:00
|
|
|
|
2021-08-18 16:17:38 -06:00
|
|
|
LastSeen *time.Time
|
|
|
|
LastSuccessfulUpdate *time.Time
|
|
|
|
Expiry *time.Time
|
2020-06-21 04:32:08 -06:00
|
|
|
|
2022-03-01 09:31:25 -07:00
|
|
|
HostInfo HostInfo
|
|
|
|
Endpoints StringList
|
|
|
|
EnabledRoutes IPPrefixes
|
2020-06-21 04:32:08 -06:00
|
|
|
|
|
|
|
CreatedAt time.Time
|
|
|
|
UpdatedAt time.Time
|
|
|
|
DeletedAt *time.Time
|
|
|
|
}
|
|
|
|
|
2021-10-02 15:03:34 -06:00
|
|
|
type (
|
|
|
|
Machines []Machine
|
|
|
|
MachinesP []*Machine
|
|
|
|
)
|
|
|
|
|
2022-01-16 06:16:59 -07:00
|
|
|
type MachineAddresses []netaddr.IP
|
|
|
|
|
|
|
|
func (ma MachineAddresses) ToStringSlice() []string {
|
|
|
|
strSlice := make([]string, 0, len(ma))
|
|
|
|
for _, addr := range ma {
|
|
|
|
strSlice = append(strSlice, addr.String())
|
|
|
|
}
|
|
|
|
|
|
|
|
return strSlice
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ma *MachineAddresses) Scan(destination interface{}) error {
|
|
|
|
switch value := destination.(type) {
|
|
|
|
case string:
|
|
|
|
addresses := strings.Split(value, ",")
|
|
|
|
*ma = (*ma)[:0]
|
|
|
|
for _, addr := range addresses {
|
|
|
|
if len(addr) < 1 {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
parsed, err := netaddr.ParseIP(addr)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
*ma = append(*ma, parsed)
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
|
|
|
|
default:
|
|
|
|
return fmt.Errorf("%w: unexpected data type %T", errMachineAddressesInvalid, destination)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Value return json value, implement driver.Valuer interface.
|
|
|
|
func (ma MachineAddresses) Value() (driver.Value, error) {
|
|
|
|
addresses := strings.Join(ma.ToStringSlice(), ",")
|
|
|
|
|
|
|
|
return addresses, nil
|
|
|
|
}
|
|
|
|
|
2021-11-13 01:39:04 -07:00
|
|
|
// isExpired returns whether the machine registration has expired.
|
2021-11-14 12:32:03 -07:00
|
|
|
func (machine Machine) isExpired() bool {
|
2021-11-19 02:02:29 -07:00
|
|
|
// If Expiry is not set, the client has not indicated that
|
|
|
|
// it wants an expiry time, it is therefor considered
|
|
|
|
// to mean "not expired"
|
2022-03-02 00:15:20 -07:00
|
|
|
if machine.Expiry == nil || machine.Expiry.IsZero() {
|
2021-11-19 02:02:29 -07:00
|
|
|
return false
|
2021-10-10 03:22:42 -06:00
|
|
|
}
|
2021-11-19 02:02:29 -07:00
|
|
|
|
|
|
|
return time.Now().UTC().After(*machine.Expiry)
|
2021-10-10 03:22:42 -06:00
|
|
|
}
|
|
|
|
|
2022-02-21 01:02:27 -07:00
|
|
|
func containsAddresses(inputs []string, addrs []string) bool {
|
|
|
|
for _, addr := range addrs {
|
2022-02-03 11:53:11 -07:00
|
|
|
if containsString(inputs, addr) {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
2022-02-14 07:26:54 -07:00
|
|
|
|
2022-02-03 11:53:11 -07:00
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2022-02-21 02:02:59 -07:00
|
|
|
// matchSourceAndDestinationWithRule.
|
2022-02-21 08:06:20 -07:00
|
|
|
func matchSourceAndDestinationWithRule(
|
|
|
|
ruleSources []string,
|
|
|
|
ruleDestinations []string,
|
|
|
|
source []string,
|
|
|
|
destination []string,
|
|
|
|
) bool {
|
|
|
|
return containsAddresses(ruleSources, source) &&
|
|
|
|
containsAddresses(ruleDestinations, destination)
|
2022-02-21 01:02:27 -07:00
|
|
|
}
|
|
|
|
|
2022-02-03 11:53:11 -07:00
|
|
|
// getFilteredByACLPeerss should return the list of peers authorized to be accessed from machine.
|
2022-02-21 08:06:20 -07:00
|
|
|
func getFilteredByACLPeers(
|
|
|
|
machines []Machine,
|
|
|
|
rules []tailcfg.FilterRule,
|
|
|
|
machine *Machine,
|
|
|
|
) Machines {
|
2021-12-29 02:58:10 -07:00
|
|
|
log.Trace().
|
|
|
|
Caller().
|
|
|
|
Str("machine", machine.Name).
|
2022-02-03 11:53:11 -07:00
|
|
|
Msg("Finding peers filtered by ACLs")
|
2021-12-29 02:58:10 -07:00
|
|
|
|
2022-02-20 13:24:02 -07:00
|
|
|
peers := make(map[uint64]Machine)
|
2022-02-03 11:53:11 -07:00
|
|
|
// Aclfilter peers here. We are itering through machines in all namespaces and search through the computed aclRules
|
|
|
|
// for match between rule SrcIPs and DstPorts. If the rule is a match we allow the machine to be viewable.
|
2022-02-20 13:24:02 -07:00
|
|
|
for _, peer := range machines {
|
2022-02-21 01:05:04 -07:00
|
|
|
if peer.ID == machine.ID {
|
|
|
|
continue
|
|
|
|
}
|
2022-02-21 01:15:34 -07:00
|
|
|
for _, rule := range rules {
|
2022-02-20 15:47:04 -07:00
|
|
|
var dst []string
|
|
|
|
for _, d := range rule.DstPorts {
|
|
|
|
dst = append(dst, d.IP)
|
|
|
|
}
|
2022-02-21 08:06:20 -07:00
|
|
|
if matchSourceAndDestinationWithRule(
|
|
|
|
rule.SrcIPs,
|
|
|
|
dst,
|
|
|
|
machine.IPAddresses.ToStringSlice(),
|
|
|
|
peer.IPAddresses.ToStringSlice(),
|
|
|
|
) || // match source and destination
|
2022-03-01 14:43:25 -07:00
|
|
|
matchSourceAndDestinationWithRule(
|
|
|
|
rule.SrcIPs,
|
|
|
|
dst,
|
|
|
|
peer.IPAddresses.ToStringSlice(),
|
|
|
|
machine.IPAddresses.ToStringSlice(),
|
|
|
|
) || // match return path
|
2022-02-21 13:45:15 -07:00
|
|
|
matchSourceAndDestinationWithRule(
|
|
|
|
rule.SrcIPs,
|
|
|
|
dst,
|
|
|
|
machine.IPAddresses.ToStringSlice(),
|
|
|
|
[]string{"*"},
|
|
|
|
) || // match source and all destination
|
|
|
|
matchSourceAndDestinationWithRule(
|
|
|
|
rule.SrcIPs,
|
|
|
|
dst,
|
2022-03-01 14:43:25 -07:00
|
|
|
[]string{"*"},
|
|
|
|
[]string{"*"},
|
|
|
|
) || // match source and all destination
|
|
|
|
matchSourceAndDestinationWithRule(
|
|
|
|
rule.SrcIPs,
|
|
|
|
dst,
|
|
|
|
[]string{"*"},
|
2022-02-21 13:45:15 -07:00
|
|
|
peer.IPAddresses.ToStringSlice(),
|
2022-03-01 14:43:25 -07:00
|
|
|
) || // match source and all destination
|
|
|
|
matchSourceAndDestinationWithRule(
|
|
|
|
rule.SrcIPs,
|
|
|
|
dst,
|
|
|
|
[]string{"*"},
|
2022-02-21 13:45:15 -07:00
|
|
|
machine.IPAddresses.ToStringSlice(),
|
2022-03-01 14:43:25 -07:00
|
|
|
) { // match all sources and source
|
2022-02-20 13:24:02 -07:00
|
|
|
peers[peer.ID] = peer
|
2022-02-03 11:53:11 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2021-12-29 02:58:10 -07:00
|
|
|
|
2022-02-20 15:50:08 -07:00
|
|
|
authorizedPeers := make([]Machine, 0, len(peers))
|
2022-02-20 13:24:02 -07:00
|
|
|
for _, m := range peers {
|
2022-02-20 15:50:08 -07:00
|
|
|
authorizedPeers = append(authorizedPeers, m)
|
2022-02-03 11:53:11 -07:00
|
|
|
}
|
2022-02-14 07:54:51 -07:00
|
|
|
sort.Slice(
|
2022-02-20 15:50:08 -07:00
|
|
|
authorizedPeers,
|
|
|
|
func(i, j int) bool { return authorizedPeers[i].ID < authorizedPeers[j].ID },
|
2022-02-14 07:54:51 -07:00
|
|
|
)
|
2021-12-29 02:58:10 -07:00
|
|
|
|
|
|
|
log.Trace().
|
|
|
|
Caller().
|
|
|
|
Str("machine", machine.Name).
|
2022-02-20 13:24:02 -07:00
|
|
|
Msgf("Found some machines: %v", machines)
|
2021-12-29 02:58:10 -07:00
|
|
|
|
2022-02-21 02:02:59 -07:00
|
|
|
return authorizedPeers
|
2021-12-29 02:58:10 -07:00
|
|
|
}
|
|
|
|
|
2022-02-25 02:26:34 -07:00
|
|
|
func (h *Headscale) ListPeers(machine *Machine) (Machines, error) {
|
2021-10-02 15:03:34 -06:00
|
|
|
log.Trace().
|
2021-11-04 16:11:38 -06:00
|
|
|
Caller().
|
2021-11-14 12:32:03 -07:00
|
|
|
Str("machine", machine.Name).
|
2021-10-04 11:39:01 -06:00
|
|
|
Msg("Finding direct peers")
|
2021-02-23 12:10:58 -07:00
|
|
|
|
2021-10-04 11:39:01 -06:00
|
|
|
machines := Machines{}
|
2022-02-28 09:55:57 -07:00
|
|
|
if err := h.db.Preload("AuthKey").Preload("AuthKey.Namespace").Preload("Namespace").Where("machine_key <> ?",
|
2022-02-25 02:26:34 -07:00
|
|
|
machine.MachineKey).Find(&machines).Error; err != nil {
|
2021-10-02 15:03:34 -06:00
|
|
|
log.Error().Err(err).Msg("Error accessing db")
|
2021-11-14 08:46:09 -07:00
|
|
|
|
2021-10-06 13:32:15 -06:00
|
|
|
return Machines{}, err
|
2020-06-21 04:32:08 -06:00
|
|
|
}
|
|
|
|
|
2021-10-04 11:39:01 -06:00
|
|
|
sort.Slice(machines, func(i, j int) bool { return machines[i].ID < machines[j].ID })
|
2020-06-21 04:32:08 -06:00
|
|
|
|
2021-10-02 15:03:34 -06:00
|
|
|
log.Trace().
|
2021-11-04 16:11:38 -06:00
|
|
|
Caller().
|
2021-11-14 12:32:03 -07:00
|
|
|
Str("machine", machine.Name).
|
2022-02-25 02:26:34 -07:00
|
|
|
Msgf("Found peers: %s", machines.String())
|
2021-11-14 08:46:09 -07:00
|
|
|
|
2021-10-04 11:39:01 -06:00
|
|
|
return machines, nil
|
2020-06-21 04:32:08 -06:00
|
|
|
}
|
|
|
|
|
2021-11-14 12:32:03 -07:00
|
|
|
func (h *Headscale) getPeers(machine *Machine) (Machines, error) {
|
2022-02-03 11:53:11 -07:00
|
|
|
var peers Machines
|
|
|
|
var err error
|
2022-02-21 01:15:34 -07:00
|
|
|
|
2022-02-03 11:53:11 -07:00
|
|
|
// If ACLs rules are defined, filter visible host list with the ACLs
|
|
|
|
// else use the classic namespace scope
|
|
|
|
if h.aclPolicy != nil {
|
2022-02-21 01:15:34 -07:00
|
|
|
var machines []Machine
|
2022-02-25 02:26:34 -07:00
|
|
|
machines, err = h.ListMachines()
|
2022-02-21 01:15:34 -07:00
|
|
|
if err != nil {
|
|
|
|
log.Error().Err(err).Msg("Error retrieving list of machines")
|
2021-11-14 08:46:09 -07:00
|
|
|
|
2022-02-03 11:53:11 -07:00
|
|
|
return Machines{}, err
|
|
|
|
}
|
2022-02-21 02:02:59 -07:00
|
|
|
peers = getFilteredByACLPeers(machines, h.aclRules, machine)
|
2022-02-03 11:53:11 -07:00
|
|
|
} else {
|
2022-02-25 02:26:34 -07:00
|
|
|
peers, err = h.ListPeers(machine)
|
2022-02-03 11:53:11 -07:00
|
|
|
if err != nil {
|
|
|
|
log.Error().
|
|
|
|
Caller().
|
|
|
|
Err(err).
|
|
|
|
Msg("Cannot fetch peers")
|
|
|
|
|
|
|
|
return Machines{}, err
|
|
|
|
}
|
2021-10-02 15:03:34 -06:00
|
|
|
}
|
|
|
|
|
2021-10-04 11:39:01 -06:00
|
|
|
sort.Slice(peers, func(i, j int) bool { return peers[i].ID < peers[j].ID })
|
|
|
|
|
|
|
|
log.Trace().
|
2021-11-04 16:11:38 -06:00
|
|
|
Caller().
|
2021-11-14 12:32:03 -07:00
|
|
|
Str("machine", machine.Name).
|
2021-10-04 11:39:01 -06:00
|
|
|
Msgf("Found total peers: %s", peers.String())
|
|
|
|
|
|
|
|
return peers, nil
|
2020-06-21 04:32:08 -06:00
|
|
|
}
|
2021-03-14 04:38:42 -06:00
|
|
|
|
2021-11-22 12:51:16 -07:00
|
|
|
func (h *Headscale) getValidPeers(machine *Machine) (Machines, error) {
|
|
|
|
validPeers := make(Machines, 0)
|
|
|
|
|
|
|
|
peers, err := h.getPeers(machine)
|
|
|
|
if err != nil {
|
|
|
|
return Machines{}, err
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, peer := range peers {
|
2022-02-28 09:55:57 -07:00
|
|
|
if !peer.isExpired() {
|
2021-11-22 12:51:16 -07:00
|
|
|
validPeers = append(validPeers, peer)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return validPeers, nil
|
|
|
|
}
|
|
|
|
|
2021-11-04 16:11:38 -06:00
|
|
|
func (h *Headscale) ListMachines() ([]Machine, error) {
|
|
|
|
machines := []Machine{}
|
|
|
|
if err := h.db.Preload("AuthKey").Preload("AuthKey.Namespace").Preload("Namespace").Find(&machines).Error; err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2021-11-14 08:46:09 -07:00
|
|
|
|
2021-11-04 16:11:38 -06:00
|
|
|
return machines, nil
|
|
|
|
}
|
|
|
|
|
2021-11-13 01:39:04 -07:00
|
|
|
// GetMachine finds a Machine by name and namespace and returns the Machine struct.
|
2021-03-14 04:38:42 -06:00
|
|
|
func (h *Headscale) GetMachine(namespace string, name string) (*Machine, error) {
|
|
|
|
machines, err := h.ListMachinesInNamespace(namespace)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2021-11-04 16:11:38 -06:00
|
|
|
for _, m := range machines {
|
2021-03-14 04:38:42 -06:00
|
|
|
if m.Name == name {
|
|
|
|
return &m, nil
|
|
|
|
}
|
|
|
|
}
|
2021-11-14 08:46:09 -07:00
|
|
|
|
2021-11-15 12:18:14 -07:00
|
|
|
return nil, errMachineNotFound
|
2021-03-14 04:38:42 -06:00
|
|
|
}
|
|
|
|
|
2021-11-13 01:39:04 -07:00
|
|
|
// GetMachineByID finds a Machine by ID and returns the Machine struct.
|
2021-07-16 16:14:22 -06:00
|
|
|
func (h *Headscale) GetMachineByID(id uint64) (*Machine, error) {
|
|
|
|
m := Machine{}
|
2021-09-03 02:23:26 -06:00
|
|
|
if result := h.db.Preload("Namespace").Find(&Machine{ID: id}).First(&m); result.Error != nil {
|
2021-07-16 16:14:22 -06:00
|
|
|
return nil, result.Error
|
|
|
|
}
|
2021-11-14 08:46:09 -07:00
|
|
|
|
2021-07-16 16:14:22 -06:00
|
|
|
return &m, nil
|
|
|
|
}
|
|
|
|
|
2021-11-13 01:39:04 -07:00
|
|
|
// GetMachineByMachineKey finds a Machine by ID and returns the Machine struct.
|
2021-11-26 16:30:42 -07:00
|
|
|
func (h *Headscale) GetMachineByMachineKey(
|
|
|
|
machineKey key.MachinePublic,
|
|
|
|
) (*Machine, error) {
|
2021-10-02 14:58:28 -06:00
|
|
|
m := Machine{}
|
2021-11-26 16:30:42 -07:00
|
|
|
if result := h.db.Preload("Namespace").First(&m, "machine_key = ?", MachinePublicKeyStripPrefix(machineKey)); result.Error != nil {
|
2021-10-02 14:58:28 -06:00
|
|
|
return nil, result.Error
|
|
|
|
}
|
2021-11-14 08:46:09 -07:00
|
|
|
|
2021-10-02 14:58:28 -06:00
|
|
|
return &m, nil
|
|
|
|
}
|
|
|
|
|
2021-08-23 00:35:44 -06:00
|
|
|
// UpdateMachine takes a Machine struct pointer (typically already loaded from database
|
|
|
|
// and updates it with the latest data from the database.
|
2021-11-14 12:32:03 -07:00
|
|
|
func (h *Headscale) UpdateMachine(machine *Machine) error {
|
|
|
|
if result := h.db.Find(machine).First(&machine); result.Error != nil {
|
2021-08-18 16:17:38 -06:00
|
|
|
return result.Error
|
|
|
|
}
|
2021-11-14 08:46:09 -07:00
|
|
|
|
2021-08-18 16:17:38 -06:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2022-04-15 05:11:41 -06:00
|
|
|
// UpdateDBMachine takes a Machine struct pointer (typically already loaded from database
|
|
|
|
// search for the same machine in the database and update the latter
|
|
|
|
func (h *Headscale) UpdateDBMachine(machine Machine) error {
|
|
|
|
destMachine := Machine{}
|
|
|
|
if result := h.db.Where("id = ?", machine.ID).Find(&destMachine); result.Error != nil {
|
|
|
|
return result.Error
|
|
|
|
}
|
|
|
|
destMachine.Name = machine.Name
|
|
|
|
destMachine.NamespaceID = machine.NamespaceID
|
|
|
|
destMachine.ForcedTags = machine.ForcedTags
|
|
|
|
|
|
|
|
h.db.Save(destMachine)
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2021-11-21 06:40:19 -07:00
|
|
|
// ExpireMachine takes a Machine struct and sets the expire field to now.
|
|
|
|
func (h *Headscale) ExpireMachine(machine *Machine) {
|
|
|
|
now := time.Now()
|
|
|
|
machine.Expiry = &now
|
|
|
|
|
2021-11-22 12:51:16 -07:00
|
|
|
h.setLastStateChangeToNow(machine.Namespace.Name)
|
|
|
|
|
2021-11-21 06:40:19 -07:00
|
|
|
h.db.Save(machine)
|
|
|
|
}
|
|
|
|
|
2021-11-22 12:32:11 -07:00
|
|
|
// RefreshMachine takes a Machine struct and sets the expire field to now.
|
|
|
|
func (h *Headscale) RefreshMachine(machine *Machine, expiry time.Time) {
|
|
|
|
now := time.Now()
|
|
|
|
|
|
|
|
machine.LastSuccessfulUpdate = &now
|
|
|
|
machine.Expiry = &expiry
|
2021-11-22 12:51:16 -07:00
|
|
|
|
|
|
|
h.setLastStateChangeToNow(machine.Namespace.Name)
|
|
|
|
|
2021-11-22 12:32:11 -07:00
|
|
|
h.db.Save(machine)
|
|
|
|
}
|
|
|
|
|
2021-11-13 01:39:04 -07:00
|
|
|
// DeleteMachine softs deletes a Machine from the database.
|
2021-11-14 12:32:03 -07:00
|
|
|
func (h *Headscale) DeleteMachine(machine *Machine) error {
|
|
|
|
if err := h.db.Delete(&machine).Error; err != nil {
|
2021-07-16 16:14:22 -06:00
|
|
|
return err
|
|
|
|
}
|
2021-07-25 09:59:48 -06:00
|
|
|
|
2022-02-12 14:04:00 -07:00
|
|
|
return nil
|
2021-07-16 16:14:22 -06:00
|
|
|
}
|
|
|
|
|
2022-01-16 03:59:03 -07:00
|
|
|
func (h *Headscale) TouchMachine(machine *Machine) error {
|
|
|
|
return h.db.Updates(Machine{
|
|
|
|
ID: machine.ID,
|
|
|
|
LastSeen: machine.LastSeen,
|
|
|
|
LastSuccessfulUpdate: machine.LastSuccessfulUpdate,
|
|
|
|
}).Error
|
|
|
|
}
|
|
|
|
|
2021-11-13 01:39:04 -07:00
|
|
|
// HardDeleteMachine hard deletes a Machine from the database.
|
2021-11-14 12:32:03 -07:00
|
|
|
func (h *Headscale) HardDeleteMachine(machine *Machine) error {
|
|
|
|
if err := h.db.Unscoped().Delete(&machine).Error; err != nil {
|
2021-07-16 16:14:22 -06:00
|
|
|
return err
|
|
|
|
}
|
2021-10-10 15:55:03 -06:00
|
|
|
|
2022-02-12 14:04:00 -07:00
|
|
|
return nil
|
2021-07-16 16:14:22 -06:00
|
|
|
}
|
|
|
|
|
2021-11-13 01:39:04 -07:00
|
|
|
// GetHostInfo returns a Hostinfo struct for the machine.
|
2022-03-01 09:31:25 -07:00
|
|
|
func (machine *Machine) GetHostInfo() tailcfg.Hostinfo {
|
|
|
|
return tailcfg.Hostinfo(machine.HostInfo)
|
2021-03-14 04:38:42 -06:00
|
|
|
}
|
2021-08-12 13:53:37 -06:00
|
|
|
|
2021-11-14 12:32:03 -07:00
|
|
|
func (h *Headscale) isOutdated(machine *Machine) bool {
|
|
|
|
if err := h.UpdateMachine(machine); err != nil {
|
2021-10-07 08:45:45 -06:00
|
|
|
// It does not seem meaningful to propagate this error as the end result
|
|
|
|
// will have to be that the machine has to be considered outdated.
|
2021-08-19 11:05:33 -06:00
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2021-10-06 16:06:07 -06:00
|
|
|
namespaceSet := set.New(set.ThreadSafe)
|
2021-11-14 12:32:03 -07:00
|
|
|
namespaceSet.Add(machine.Namespace.Name)
|
2021-10-06 16:06:07 -06:00
|
|
|
|
|
|
|
namespaces := make([]string, namespaceSet.Size())
|
|
|
|
for index, namespace := range namespaceSet.List() {
|
2021-11-15 11:42:44 -07:00
|
|
|
if name, ok := namespace.(string); ok {
|
|
|
|
namespaces[index] = name
|
|
|
|
}
|
2021-10-06 13:32:15 -06:00
|
|
|
}
|
|
|
|
|
2021-10-06 16:06:07 -06:00
|
|
|
lastChange := h.getLastStateChange(namespaces...)
|
2022-01-15 08:20:14 -07:00
|
|
|
lastUpdate := machine.CreatedAt
|
|
|
|
if machine.LastSuccessfulUpdate != nil {
|
|
|
|
lastUpdate = *machine.LastSuccessfulUpdate
|
|
|
|
}
|
2021-08-18 16:17:38 -06:00
|
|
|
log.Trace().
|
2021-11-04 16:11:38 -06:00
|
|
|
Caller().
|
2021-11-14 12:32:03 -07:00
|
|
|
Str("machine", machine.Name).
|
2022-01-15 08:20:14 -07:00
|
|
|
Time("last_successful_update", lastChange).
|
|
|
|
Time("last_state_change", lastUpdate).
|
2021-11-14 12:32:03 -07:00
|
|
|
Msgf("Checking if %s is missing updates", machine.Name)
|
2021-11-14 08:46:09 -07:00
|
|
|
|
2022-01-15 08:20:14 -07:00
|
|
|
return lastUpdate.Before(lastChange)
|
2021-08-18 16:17:38 -06:00
|
|
|
}
|
2021-10-02 15:03:34 -06:00
|
|
|
|
2021-11-14 12:32:03 -07:00
|
|
|
func (machine Machine) String() string {
|
|
|
|
return machine.Name
|
2021-10-02 15:03:34 -06:00
|
|
|
}
|
|
|
|
|
2021-11-14 12:32:03 -07:00
|
|
|
func (machines Machines) String() string {
|
|
|
|
temp := make([]string, len(machines))
|
2021-10-02 15:03:34 -06:00
|
|
|
|
2021-11-14 12:32:03 -07:00
|
|
|
for index, machine := range machines {
|
2021-10-02 15:03:34 -06:00
|
|
|
temp[index] = machine.Name
|
|
|
|
}
|
|
|
|
|
|
|
|
return fmt.Sprintf("[ %s ](%d)", strings.Join(temp, ", "), len(temp))
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO(kradalby): Remove when we have generics...
|
2021-11-14 12:32:03 -07:00
|
|
|
func (machines MachinesP) String() string {
|
|
|
|
temp := make([]string, len(machines))
|
2021-10-02 15:03:34 -06:00
|
|
|
|
2021-11-14 12:32:03 -07:00
|
|
|
for index, machine := range machines {
|
2021-10-02 15:03:34 -06:00
|
|
|
temp[index] = machine.Name
|
|
|
|
}
|
|
|
|
|
|
|
|
return fmt.Sprintf("[ %s ](%d)", strings.Join(temp, ", "), len(temp))
|
|
|
|
}
|
|
|
|
|
2021-11-14 12:32:03 -07:00
|
|
|
func (machines Machines) toNodes(
|
2021-10-30 09:33:01 -06:00
|
|
|
baseDomain string,
|
|
|
|
dnsConfig *tailcfg.DNSConfig,
|
|
|
|
includeRoutes bool,
|
|
|
|
) ([]*tailcfg.Node, error) {
|
2021-11-14 12:32:03 -07:00
|
|
|
nodes := make([]*tailcfg.Node, len(machines))
|
2021-10-02 15:03:34 -06:00
|
|
|
|
2021-11-14 12:32:03 -07:00
|
|
|
for index, machine := range machines {
|
2021-10-04 15:49:16 -06:00
|
|
|
node, err := machine.toNode(baseDomain, dnsConfig, includeRoutes)
|
2021-10-02 15:03:34 -06:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
nodes[index] = node
|
|
|
|
}
|
|
|
|
|
|
|
|
return nodes, nil
|
2021-10-06 03:19:15 -06:00
|
|
|
}
|
|
|
|
|
2021-09-09 16:30:02 -06:00
|
|
|
// toNode converts a Machine into a Tailscale Node. includeRoutes is false for shared nodes
|
2021-11-13 01:39:04 -07:00
|
|
|
// as per the expected behaviour in the official SaaS.
|
2021-11-14 12:32:03 -07:00
|
|
|
func (machine Machine) toNode(
|
2021-11-13 01:36:45 -07:00
|
|
|
baseDomain string,
|
|
|
|
dnsConfig *tailcfg.DNSConfig,
|
|
|
|
includeRoutes bool,
|
|
|
|
) (*tailcfg.Node, error) {
|
2021-11-26 16:50:42 -07:00
|
|
|
var nodeKey key.NodePublic
|
2021-11-27 13:25:12 -07:00
|
|
|
err := nodeKey.UnmarshalText([]byte(NodePublicKeyEnsurePrefix(machine.NodeKey)))
|
2020-06-21 04:32:08 -06:00
|
|
|
if err != nil {
|
2021-11-26 16:30:42 -07:00
|
|
|
log.Trace().
|
|
|
|
Caller().
|
|
|
|
Str("node_key", machine.NodeKey).
|
|
|
|
Msgf("Failed to parse node public key from hex")
|
|
|
|
|
|
|
|
return nil, fmt.Errorf("failed to parse node public key: %w", err)
|
2020-06-21 04:32:08 -06:00
|
|
|
}
|
2021-11-14 12:32:03 -07:00
|
|
|
|
2021-11-26 16:50:42 -07:00
|
|
|
var machineKey key.MachinePublic
|
2021-11-27 13:25:12 -07:00
|
|
|
err = machineKey.UnmarshalText(
|
|
|
|
[]byte(MachinePublicKeyEnsurePrefix(machine.MachineKey)),
|
|
|
|
)
|
2020-06-21 04:32:08 -06:00
|
|
|
if err != nil {
|
2021-11-26 16:30:42 -07:00
|
|
|
return nil, fmt.Errorf("failed to parse machine public key: %w", err)
|
2020-06-21 04:32:08 -06:00
|
|
|
}
|
2021-02-23 12:10:58 -07:00
|
|
|
|
2021-11-26 16:30:42 -07:00
|
|
|
var discoKey key.DiscoPublic
|
2021-11-14 12:32:03 -07:00
|
|
|
if machine.DiscoKey != "" {
|
2021-11-27 13:25:12 -07:00
|
|
|
err := discoKey.UnmarshalText(
|
|
|
|
[]byte(DiscoPublicKeyEnsurePrefix(machine.DiscoKey)),
|
|
|
|
)
|
2021-02-23 12:10:58 -07:00
|
|
|
if err != nil {
|
2021-11-26 16:30:42 -07:00
|
|
|
return nil, fmt.Errorf("failed to parse disco public key: %w", err)
|
2021-02-23 12:10:58 -07:00
|
|
|
}
|
|
|
|
} else {
|
2021-11-26 16:30:42 -07:00
|
|
|
discoKey = key.DiscoPublic{}
|
2021-02-21 13:34:28 -07:00
|
|
|
}
|
2021-02-23 12:10:58 -07:00
|
|
|
|
2021-02-20 14:43:07 -07:00
|
|
|
addrs := []netaddr.IPPrefix{}
|
2022-01-16 06:16:59 -07:00
|
|
|
for _, machineAddress := range machine.IPAddresses {
|
|
|
|
ip := netaddr.IPPrefixFrom(machineAddress, machineAddress.BitLen())
|
|
|
|
addrs = append(addrs, ip)
|
2020-06-21 04:32:08 -06:00
|
|
|
}
|
2021-03-14 04:38:42 -06:00
|
|
|
|
2022-02-12 14:04:00 -07:00
|
|
|
allowedIPs := append(
|
|
|
|
[]netaddr.IPPrefix{},
|
|
|
|
addrs...) // we append the node own IP, as it is required by the clients
|
2021-03-14 04:38:42 -06:00
|
|
|
|
2022-02-21 16:01:35 -07:00
|
|
|
// TODO(kradalby): Needs investigation, We probably dont need this condition
|
|
|
|
// now that we dont have shared nodes
|
2021-09-02 08:59:03 -06:00
|
|
|
if includeRoutes {
|
2022-03-01 09:31:25 -07:00
|
|
|
allowedIPs = append(allowedIPs, machine.EnabledRoutes...)
|
2020-06-21 04:32:08 -06:00
|
|
|
}
|
|
|
|
|
2021-02-24 15:45:27 -07:00
|
|
|
var derp string
|
2022-03-01 09:31:25 -07:00
|
|
|
if machine.HostInfo.NetInfo != nil {
|
|
|
|
derp = fmt.Sprintf("127.3.3.40:%d", machine.HostInfo.NetInfo.PreferredDERP)
|
2021-02-24 15:45:27 -07:00
|
|
|
} else {
|
|
|
|
derp = "127.3.3.40:0" // Zero means disconnected or unknown.
|
|
|
|
}
|
|
|
|
|
2021-09-02 08:59:03 -06:00
|
|
|
var keyExpiry time.Time
|
2021-11-14 12:32:03 -07:00
|
|
|
if machine.Expiry != nil {
|
|
|
|
keyExpiry = *machine.Expiry
|
2021-09-02 08:59:03 -06:00
|
|
|
} else {
|
|
|
|
keyExpiry = time.Time{}
|
|
|
|
}
|
|
|
|
|
2021-10-04 15:49:16 -06:00
|
|
|
var hostname string
|
|
|
|
if dnsConfig != nil && dnsConfig.Proxied { // MagicDNS
|
2021-11-14 12:32:03 -07:00
|
|
|
hostname = fmt.Sprintf(
|
|
|
|
"%s.%s.%s",
|
|
|
|
machine.Name,
|
2022-02-22 04:45:50 -07:00
|
|
|
machine.Namespace.Name,
|
2021-11-14 12:32:03 -07:00
|
|
|
baseDomain,
|
|
|
|
)
|
2022-02-23 06:21:46 -07:00
|
|
|
if len(hostname) > maxHostnameLength {
|
|
|
|
return nil, fmt.Errorf(
|
|
|
|
"hostname %q is too long it cannot except 255 ASCII chars: %w",
|
|
|
|
hostname,
|
|
|
|
errHostnameTooLong,
|
|
|
|
)
|
|
|
|
}
|
2021-10-04 15:49:16 -06:00
|
|
|
} else {
|
2021-11-14 12:32:03 -07:00
|
|
|
hostname = machine.Name
|
2021-10-04 15:49:16 -06:00
|
|
|
}
|
|
|
|
|
2022-03-01 09:31:25 -07:00
|
|
|
hostInfo := machine.GetHostInfo()
|
|
|
|
|
2021-11-15 09:15:50 -07:00
|
|
|
node := tailcfg.Node{
|
2021-11-14 12:32:03 -07:00
|
|
|
ID: tailcfg.NodeID(machine.ID), // this is the actual ID
|
2021-10-30 09:33:01 -06:00
|
|
|
StableID: tailcfg.StableNodeID(
|
2021-11-15 10:24:24 -07:00
|
|
|
strconv.FormatUint(machine.ID, Base10),
|
2021-10-30 09:33:01 -06:00
|
|
|
), // in headscale, unlike tailcontrol server, IDs are permanent
|
2021-10-04 15:49:16 -06:00
|
|
|
Name: hostname,
|
2021-11-14 12:32:03 -07:00
|
|
|
User: tailcfg.UserID(machine.NamespaceID),
|
2021-11-26 16:30:42 -07:00
|
|
|
Key: nodeKey,
|
2021-09-02 08:59:03 -06:00
|
|
|
KeyExpiry: keyExpiry,
|
2021-11-26 16:30:42 -07:00
|
|
|
Machine: machineKey,
|
2021-02-23 12:10:58 -07:00
|
|
|
DiscoKey: discoKey,
|
2020-06-21 04:32:08 -06:00
|
|
|
Addresses: addrs,
|
|
|
|
AllowedIPs: allowedIPs,
|
2022-03-01 09:31:25 -07:00
|
|
|
Endpoints: machine.Endpoints,
|
2021-02-24 15:45:27 -07:00
|
|
|
DERP: derp,
|
2020-06-21 04:32:08 -06:00
|
|
|
|
2022-03-01 09:31:25 -07:00
|
|
|
Hostinfo: hostInfo.View(),
|
2021-11-14 12:32:03 -07:00
|
|
|
Created: machine.CreatedAt,
|
|
|
|
LastSeen: machine.LastSeen,
|
2020-06-21 04:32:08 -06:00
|
|
|
|
2021-02-23 12:10:58 -07:00
|
|
|
KeepAlive: true,
|
2022-02-28 09:55:57 -07:00
|
|
|
MachineAuthorized: !machine.isExpired(),
|
2021-09-24 01:49:29 -06:00
|
|
|
Capabilities: []string{tailcfg.CapabilityFileSharing},
|
2020-06-21 04:32:08 -06:00
|
|
|
}
|
2021-11-14 08:46:09 -07:00
|
|
|
|
2021-11-15 09:15:50 -07:00
|
|
|
return &node, nil
|
2020-06-21 04:32:08 -06:00
|
|
|
}
|
2021-11-04 16:11:38 -06:00
|
|
|
|
2021-11-14 12:32:03 -07:00
|
|
|
func (machine *Machine) toProto() *v1.Machine {
|
|
|
|
machineProto := &v1.Machine{
|
|
|
|
Id: machine.ID,
|
|
|
|
MachineKey: machine.MachineKey,
|
2021-11-04 16:11:38 -06:00
|
|
|
|
2022-01-16 06:16:59 -07:00
|
|
|
NodeKey: machine.NodeKey,
|
|
|
|
DiscoKey: machine.DiscoKey,
|
|
|
|
IpAddresses: machine.IPAddresses.ToStringSlice(),
|
|
|
|
Name: machine.Name,
|
|
|
|
Namespace: machine.Namespace.toProto(),
|
2022-04-15 05:11:41 -06:00
|
|
|
ForcedTags: machine.ForcedTags,
|
2021-11-04 16:11:38 -06:00
|
|
|
|
|
|
|
// TODO(kradalby): Implement register method enum converter
|
|
|
|
// RegisterMethod: ,
|
|
|
|
|
2021-11-14 12:32:03 -07:00
|
|
|
CreatedAt: timestamppb.New(machine.CreatedAt),
|
2021-11-04 16:11:38 -06:00
|
|
|
}
|
|
|
|
|
2021-11-14 12:32:03 -07:00
|
|
|
if machine.AuthKey != nil {
|
|
|
|
machineProto.PreAuthKey = machine.AuthKey.toProto()
|
2021-11-04 16:11:38 -06:00
|
|
|
}
|
|
|
|
|
2021-11-14 12:32:03 -07:00
|
|
|
if machine.LastSeen != nil {
|
|
|
|
machineProto.LastSeen = timestamppb.New(*machine.LastSeen)
|
2021-11-04 16:11:38 -06:00
|
|
|
}
|
|
|
|
|
2021-11-14 12:32:03 -07:00
|
|
|
if machine.LastSuccessfulUpdate != nil {
|
|
|
|
machineProto.LastSuccessfulUpdate = timestamppb.New(
|
|
|
|
*machine.LastSuccessfulUpdate,
|
|
|
|
)
|
2021-11-04 16:11:38 -06:00
|
|
|
}
|
|
|
|
|
2021-11-14 12:32:03 -07:00
|
|
|
if machine.Expiry != nil {
|
|
|
|
machineProto.Expiry = timestamppb.New(*machine.Expiry)
|
2021-11-04 16:11:38 -06:00
|
|
|
}
|
|
|
|
|
2021-11-14 12:32:03 -07:00
|
|
|
return machineProto
|
2021-11-04 16:11:38 -06:00
|
|
|
}
|
|
|
|
|
2022-02-28 01:06:39 -07:00
|
|
|
func (h *Headscale) RegisterMachineFromAuthCallback(
|
2021-11-26 16:30:42 -07:00
|
|
|
machineKeyStr string,
|
2021-11-14 12:32:03 -07:00
|
|
|
namespaceName string,
|
2022-02-28 01:06:39 -07:00
|
|
|
registrationMethod string,
|
2021-11-14 12:32:03 -07:00
|
|
|
) (*Machine, error) {
|
2022-02-28 01:06:39 -07:00
|
|
|
if machineInterface, ok := h.registrationCache.Get(machineKeyStr); ok {
|
|
|
|
if registrationMachine, ok := machineInterface.(Machine); ok {
|
2022-02-28 09:34:28 -07:00
|
|
|
namespace, err := h.GetNamespace(namespaceName)
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf(
|
|
|
|
"failed to find namespace in register machine from auth callback, %w",
|
|
|
|
err,
|
|
|
|
)
|
|
|
|
}
|
2021-11-04 16:11:38 -06:00
|
|
|
|
2022-02-28 09:34:28 -07:00
|
|
|
registrationMachine.NamespaceID = namespace.ID
|
|
|
|
registrationMachine.RegisterMethod = registrationMethod
|
2021-11-26 16:30:42 -07:00
|
|
|
|
2022-02-28 01:06:39 -07:00
|
|
|
machine, err := h.RegisterMachine(
|
2022-02-28 09:34:28 -07:00
|
|
|
registrationMachine,
|
2022-02-28 01:06:39 -07:00
|
|
|
)
|
2021-11-04 16:11:38 -06:00
|
|
|
|
2022-02-28 01:06:39 -07:00
|
|
|
return machine, err
|
|
|
|
} else {
|
|
|
|
return nil, errCouldNotConvertMachineInterface
|
2021-11-22 12:32:52 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-02-28 01:06:39 -07:00
|
|
|
return nil, errMachineNotFoundRegistrationCache
|
|
|
|
}
|
2021-11-22 12:32:52 -07:00
|
|
|
|
2021-11-13 01:39:04 -07:00
|
|
|
// RegisterMachine is executed from the CLI to register a new Machine using its MachineKey.
|
2022-02-28 09:34:28 -07:00
|
|
|
func (h *Headscale) RegisterMachine(machine Machine,
|
2021-11-14 12:32:03 -07:00
|
|
|
) (*Machine, error) {
|
2021-11-26 16:30:42 -07:00
|
|
|
log.Trace().
|
|
|
|
Caller().
|
2022-02-28 09:34:28 -07:00
|
|
|
Str("machine_key", machine.MachineKey).
|
2021-11-26 16:30:42 -07:00
|
|
|
Msg("Registering machine")
|
2021-11-22 12:32:52 -07:00
|
|
|
|
2021-11-04 16:11:38 -06:00
|
|
|
log.Trace().
|
|
|
|
Caller().
|
2021-11-14 12:32:03 -07:00
|
|
|
Str("machine", machine.Name).
|
2021-11-04 16:11:38 -06:00
|
|
|
Msg("Attempting to register machine")
|
|
|
|
|
2022-02-24 06:18:18 -07:00
|
|
|
h.ipAllocationMutex.Lock()
|
|
|
|
defer h.ipAllocationMutex.Unlock()
|
|
|
|
|
2022-01-16 06:16:59 -07:00
|
|
|
ips, err := h.getAvailableIPs()
|
2021-11-04 16:11:38 -06:00
|
|
|
if err != nil {
|
|
|
|
log.Error().
|
|
|
|
Caller().
|
|
|
|
Err(err).
|
2021-11-14 12:32:03 -07:00
|
|
|
Str("machine", machine.Name).
|
2021-11-04 16:11:38 -06:00
|
|
|
Msg("Could not find IP for the new machine")
|
2021-11-14 08:46:09 -07:00
|
|
|
|
2021-11-04 16:11:38 -06:00
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2022-01-16 06:16:59 -07:00
|
|
|
machine.IPAddresses = ips
|
2022-02-27 10:40:10 -07:00
|
|
|
|
2021-11-14 12:32:03 -07:00
|
|
|
h.db.Save(&machine)
|
2021-11-04 16:11:38 -06:00
|
|
|
|
|
|
|
log.Trace().
|
|
|
|
Caller().
|
2021-11-14 12:32:03 -07:00
|
|
|
Str("machine", machine.Name).
|
2022-01-16 06:16:59 -07:00
|
|
|
Str("ip", strings.Join(ips.ToStringSlice(), ",")).
|
2021-11-04 16:11:38 -06:00
|
|
|
Msg("Machine registered with the database")
|
|
|
|
|
2022-02-28 09:34:28 -07:00
|
|
|
return &machine, nil
|
2021-11-04 16:11:38 -06:00
|
|
|
}
|
|
|
|
|
2022-03-01 09:31:25 -07:00
|
|
|
func (machine *Machine) GetAdvertisedRoutes() []netaddr.IPPrefix {
|
|
|
|
return machine.HostInfo.RoutableIPs
|
2021-11-04 16:11:38 -06:00
|
|
|
}
|
|
|
|
|
2022-03-01 09:31:25 -07:00
|
|
|
func (machine *Machine) GetEnabledRoutes() []netaddr.IPPrefix {
|
|
|
|
return machine.EnabledRoutes
|
2021-11-04 16:11:38 -06:00
|
|
|
}
|
|
|
|
|
2021-11-14 12:32:03 -07:00
|
|
|
func (machine *Machine) IsRoutesEnabled(routeStr string) bool {
|
2021-11-04 16:11:38 -06:00
|
|
|
route, err := netaddr.ParseIPPrefix(routeStr)
|
|
|
|
if err != nil {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2022-03-01 09:31:25 -07:00
|
|
|
enabledRoutes := machine.GetEnabledRoutes()
|
2021-11-04 16:11:38 -06:00
|
|
|
|
|
|
|
for _, enabledRoute := range enabledRoutes {
|
|
|
|
if route == enabledRoute {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
2021-11-14 08:46:09 -07:00
|
|
|
|
2021-11-04 16:11:38 -06:00
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
// EnableNodeRoute enables new routes based on a list of new routes. It will _replace_ the
|
|
|
|
// previous list of routes.
|
2021-11-14 12:32:03 -07:00
|
|
|
func (h *Headscale) EnableRoutes(machine *Machine, routeStrs ...string) error {
|
2021-11-04 16:11:38 -06:00
|
|
|
newRoutes := make([]netaddr.IPPrefix, len(routeStrs))
|
|
|
|
for index, routeStr := range routeStrs {
|
|
|
|
route, err := netaddr.ParseIPPrefix(routeStr)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
newRoutes[index] = route
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, newRoute := range newRoutes {
|
2022-03-01 09:31:25 -07:00
|
|
|
if !containsIPPrefix(machine.GetAdvertisedRoutes(), newRoute) {
|
2021-11-13 01:36:45 -07:00
|
|
|
return fmt.Errorf(
|
2021-11-15 12:18:14 -07:00
|
|
|
"route (%s) is not available on node %s: %w",
|
2021-11-14 12:32:03 -07:00
|
|
|
machine.Name,
|
2021-11-15 12:18:14 -07:00
|
|
|
newRoute, errMachineRouteIsNotAvailable,
|
2021-11-13 01:36:45 -07:00
|
|
|
)
|
2021-11-04 16:11:38 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-03-01 09:31:25 -07:00
|
|
|
machine.EnabledRoutes = newRoutes
|
2021-11-14 12:32:03 -07:00
|
|
|
h.db.Save(&machine)
|
2021-11-04 16:11:38 -06:00
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2022-03-01 09:31:25 -07:00
|
|
|
func (machine *Machine) RoutesToProto() *v1.Routes {
|
|
|
|
availableRoutes := machine.GetAdvertisedRoutes()
|
2021-11-04 16:11:38 -06:00
|
|
|
|
2022-03-01 09:31:25 -07:00
|
|
|
enabledRoutes := machine.GetEnabledRoutes()
|
2021-11-04 16:11:38 -06:00
|
|
|
|
|
|
|
return &v1.Routes{
|
|
|
|
AdvertisedRoutes: ipPrefixToString(availableRoutes),
|
|
|
|
EnabledRoutes: ipPrefixToString(enabledRoutes),
|
2022-03-01 09:31:25 -07:00
|
|
|
}
|
2021-11-04 16:11:38 -06:00
|
|
|
}
|