mirror of
https://github.com/juanfont/headscale.git
synced 2024-11-23 18:15:26 +00:00
feb15365b5
This is a massive commit that restructures the code into modules:
db/
All functions related to modifying the Database
types/
All type definitions and methods that can be exclusivly used on
these types without dependencies
policy/
All Policy related code, now without dependencies on the Database.
policy/matcher/
Dedicated code to match machines in a list of FilterRules
Signed-off-by: Kristoffer Dalby <kristoffer@tailscale.com>
125 lines
2.8 KiB
Go
125 lines
2.8 KiB
Go
package util
|
|
|
|
import (
|
|
"fmt"
|
|
"net/netip"
|
|
"reflect"
|
|
"strings"
|
|
|
|
"go4.org/netipx"
|
|
)
|
|
|
|
// This is borrowed from, and updated to use IPSet
|
|
// https://github.com/tailscale/tailscale/blob/71029cea2ddf82007b80f465b256d027eab0f02d/wgengine/filter/tailcfg.go#L97-L162
|
|
// TODO(kradalby): contribute upstream and make public.
|
|
var (
|
|
zeroIP4 = netip.AddrFrom4([4]byte{})
|
|
zeroIP6 = netip.AddrFrom16([16]byte{})
|
|
)
|
|
|
|
// parseIPSet parses arg as one:
|
|
//
|
|
// - an IP address (IPv4 or IPv6)
|
|
// - the string "*" to match everything (both IPv4 & IPv6)
|
|
// - a CIDR (e.g. "192.168.0.0/16")
|
|
// - a range of two IPs, inclusive, separated by hyphen ("2eff::1-2eff::0800")
|
|
//
|
|
// bits, if non-nil, is the legacy SrcBits CIDR length to make a IP
|
|
// address (without a slash) treated as a CIDR of *bits length.
|
|
// nolint
|
|
func ParseIPSet(arg string, bits *int) (*netipx.IPSet, error) {
|
|
var ipSet netipx.IPSetBuilder
|
|
if arg == "*" {
|
|
ipSet.AddPrefix(netip.PrefixFrom(zeroIP4, 0))
|
|
ipSet.AddPrefix(netip.PrefixFrom(zeroIP6, 0))
|
|
|
|
return ipSet.IPSet()
|
|
}
|
|
if strings.Contains(arg, "/") {
|
|
pfx, err := netip.ParsePrefix(arg)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if pfx != pfx.Masked() {
|
|
return nil, fmt.Errorf("%v contains non-network bits set", pfx)
|
|
}
|
|
|
|
ipSet.AddPrefix(pfx)
|
|
|
|
return ipSet.IPSet()
|
|
}
|
|
if strings.Count(arg, "-") == 1 {
|
|
ip1s, ip2s, _ := strings.Cut(arg, "-")
|
|
|
|
ip1, err := netip.ParseAddr(ip1s)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
ip2, err := netip.ParseAddr(ip2s)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
r := netipx.IPRangeFrom(ip1, ip2)
|
|
if !r.IsValid() {
|
|
return nil, fmt.Errorf("invalid IP range %q", arg)
|
|
}
|
|
|
|
for _, prefix := range r.Prefixes() {
|
|
ipSet.AddPrefix(prefix)
|
|
}
|
|
|
|
return ipSet.IPSet()
|
|
}
|
|
ip, err := netip.ParseAddr(arg)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("invalid IP address %q", arg)
|
|
}
|
|
bits8 := uint8(ip.BitLen())
|
|
if bits != nil {
|
|
if *bits < 0 || *bits > int(bits8) {
|
|
return nil, fmt.Errorf("invalid CIDR size %d for IP %q", *bits, arg)
|
|
}
|
|
bits8 = uint8(*bits)
|
|
}
|
|
|
|
ipSet.AddPrefix(netip.PrefixFrom(ip, int(bits8)))
|
|
|
|
return ipSet.IPSet()
|
|
}
|
|
|
|
func GetIPPrefixEndpoints(na netip.Prefix) (netip.Addr, netip.Addr) {
|
|
var network, broadcast netip.Addr
|
|
ipRange := netipx.RangeOfPrefix(na)
|
|
network = ipRange.From()
|
|
broadcast = ipRange.To()
|
|
|
|
return network, broadcast
|
|
}
|
|
|
|
func StringToIPPrefix(prefixes []string) ([]netip.Prefix, error) {
|
|
result := make([]netip.Prefix, len(prefixes))
|
|
|
|
for index, prefixStr := range prefixes {
|
|
prefix, err := netip.ParsePrefix(prefixStr)
|
|
if err != nil {
|
|
return []netip.Prefix{}, err
|
|
}
|
|
|
|
result[index] = prefix
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
func StringOrPrefixListContains[T string | netip.Prefix](ts []T, t T) bool {
|
|
for _, v := range ts {
|
|
if reflect.DeepEqual(v, t) {
|
|
return true
|
|
}
|
|
}
|
|
|
|
return false
|
|
}
|