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.
virt/agent/hypervisor/vpc_capability.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()
}