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() }