You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
146 lines
4.6 KiB
Go
146 lines
4.6 KiB
Go
package hypervisor
|
|
|
|
import (
|
|
"errors"
|
|
"net"
|
|
"net/netip"
|
|
"os"
|
|
"path/filepath"
|
|
"regexp"
|
|
"sort"
|
|
"strings"
|
|
)
|
|
|
|
const (
|
|
vpcL3CapabilityVersion = uint64(3)
|
|
maxVPCTransportCandidates = 64
|
|
vpcNoTransportCandidates = "no_private_transport_addresses"
|
|
vpcIPv4ForwardingDisabled = "ipv4_forwarding_disabled"
|
|
vpcL3ImplementationDisabled = "vpc_l3_apply_unavailable"
|
|
vpcVMPortDisabled = "vpc_vm_port_unavailable"
|
|
)
|
|
|
|
var vpcTransportInterfacePattern = regexp.MustCompile(`^[A-Za-z0-9][A-Za-z0-9_.-]{0,14}$`)
|
|
|
|
type vpcInterfaceSnapshot struct {
|
|
Name string
|
|
Flags net.Flags
|
|
MTU int
|
|
Addresses []string
|
|
Bridge bool
|
|
}
|
|
|
|
type vpcApplyAvailability interface {
|
|
Available() error
|
|
}
|
|
|
|
func probeVPCL3Capability(router vpcApplyAvailability) (*VPCL3Capability, map[string]CapabilityCheck) {
|
|
candidates, candidatesCheck := discoverVPCTransportCandidates()
|
|
forwardingCheck := probeIPv4Forwarding("/proc/sys/net/ipv4/ip_forward")
|
|
applyCheck := unavailableCheck(vpcL3ImplementationDisabled)
|
|
portCheck := unavailableCheck(vpcVMPortDisabled)
|
|
if router != nil {
|
|
if err := router.Available(); err == nil {
|
|
applyCheck = availableCheck()
|
|
portCheck = availableCheck()
|
|
} else {
|
|
var coded interface{ PublicCode() string }
|
|
if errors.As(err, &coded) && coded.PublicCode() != "" {
|
|
applyCheck = unavailableCheck(coded.PublicCode())
|
|
}
|
|
}
|
|
}
|
|
ready := applyCheck.Available && portCheck.Available &&
|
|
candidatesCheck.Available && forwardingCheck.Available
|
|
return &VPCL3Capability{
|
|
Version: vpcL3CapabilityVersion,
|
|
ApplySupported: ready, PortSupported: ready,
|
|
IPv4Forwarding: forwardingCheck.Available, Candidates: candidates,
|
|
}, map[string]CapabilityCheck{
|
|
"vpc_transport_candidates": candidatesCheck,
|
|
"vpc_ipv4_forwarding": forwardingCheck,
|
|
"vpc_l3_apply": applyCheck,
|
|
"vpc_vm_port": portCheck,
|
|
}
|
|
}
|
|
|
|
func discoverVPCTransportCandidates() ([]VPCTransportCandidate, CapabilityCheck) {
|
|
interfaces, err := net.Interfaces()
|
|
if err != nil {
|
|
return []VPCTransportCandidate{}, unavailableCheck(capabilityUnavailable)
|
|
}
|
|
snapshots := make([]vpcInterfaceSnapshot, 0, len(interfaces))
|
|
for _, device := range interfaces {
|
|
addresses, addressErr := device.Addrs()
|
|
if addressErr != nil {
|
|
continue
|
|
}
|
|
values := make([]string, 0, len(addresses))
|
|
for _, address := range addresses {
|
|
values = append(values, address.String())
|
|
}
|
|
info, statErr := os.Stat(filepath.Join("/sys/class/net", device.Name, "bridge"))
|
|
snapshots = append(snapshots, vpcInterfaceSnapshot{
|
|
Name: device.Name, Flags: device.Flags, MTU: device.MTU,
|
|
Addresses: values, Bridge: statErr == nil && info.IsDir(),
|
|
})
|
|
}
|
|
return normalizeVPCTransportCandidates(snapshots)
|
|
}
|
|
|
|
func normalizeVPCTransportCandidates(
|
|
snapshots []vpcInterfaceSnapshot,
|
|
) ([]VPCTransportCandidate, CapabilityCheck) {
|
|
candidates := make([]VPCTransportCandidate, 0)
|
|
seen := make(map[string]struct{})
|
|
for _, device := range snapshots {
|
|
if device.Flags&net.FlagUp == 0 || device.Flags&net.FlagLoopback != 0 ||
|
|
!vpcTransportInterfacePattern.MatchString(device.Name) ||
|
|
device.MTU < 576 || device.MTU > 65535 {
|
|
continue
|
|
}
|
|
for _, raw := range device.Addresses {
|
|
prefix, err := netip.ParsePrefix(strings.TrimSpace(raw))
|
|
if err != nil || !prefix.Addr().Is4() || !prefix.Addr().IsPrivate() ||
|
|
prefix.Addr().IsLoopback() || prefix.Addr().IsLinkLocalUnicast() ||
|
|
prefix.Addr().IsUnspecified() || prefix.Addr().IsMulticast() {
|
|
continue
|
|
}
|
|
key := device.Name + "\x00" + prefix.String()
|
|
if _, exists := seen[key]; exists {
|
|
continue
|
|
}
|
|
seen[key] = struct{}{}
|
|
candidates = append(candidates, VPCTransportCandidate{
|
|
AddressCIDR: prefix.String(), Address: prefix.Addr().String(),
|
|
Prefix: uint8(prefix.Bits()), Interface: device.Name,
|
|
MTU: device.MTU, Bridge: device.Bridge,
|
|
})
|
|
}
|
|
}
|
|
if len(candidates) > maxVPCTransportCandidates {
|
|
return []VPCTransportCandidate{}, unavailableCheck(capabilityInvalid)
|
|
}
|
|
sort.Slice(candidates, func(left, right int) bool {
|
|
if candidates[left].Interface != candidates[right].Interface {
|
|
return candidates[left].Interface < candidates[right].Interface
|
|
}
|
|
return candidates[left].AddressCIDR < candidates[right].AddressCIDR
|
|
})
|
|
if len(candidates) == 0 {
|
|
return candidates, unavailableCheck(vpcNoTransportCandidates)
|
|
}
|
|
return candidates, availableCheck()
|
|
}
|
|
|
|
func probeIPv4Forwarding(path string) CapabilityCheck {
|
|
raw, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return unavailableCheck(capabilityUnreadable)
|
|
}
|
|
if strings.TrimSpace(string(raw)) != "1" {
|
|
return unavailableCheck(vpcIPv4ForwardingDisabled)
|
|
}
|
|
return availableCheck()
|
|
}
|