package main // rollcall net discover: what this host sees on each interface, for the day // when the provisioning network is not decided yet. Addresses (and the subnet // they imply), the switch port and VLAN from LLDP (lldpd), DHCP servers that // answer, neighbours; then a suggestion of what to do with each interface. import ( "encoding/json" "flag" "fmt" "net" "os" "os/exec" "path/filepath" "sort" "strconv" "strings" "time" ) type discoIface struct { Name string `json:"name"` Kind string `json:"kind"` // physical | vlan | bond | bridge | virtual MAC string `json:"mac"` Up bool `json:"up"` SpeedMbps int `json:"speed_mbps,omitempty"` Addrs []string `json:"addrs"` Subnets []string `json:"subnets"` Default bool `json:"default_route"` Switch string `json:"switch,omitempty"` Port string `json:"port,omitempty"` VLAN string `json:"vlan,omitempty"` DHCP []string `json:"dhcp_servers"` DHCPProbe string `json:"dhcp_probe,omitempty"` // why it was not probed Neighbours int `json:"neighbours"` Suggestion string `json:"suggestion"` } func discoverCmd(args []string) error { fs := flag.NewFlagSet("net discover", flag.ExitOnError) asJSON := fs.Bool("json", false, "JSON output") noProbe := fs.Bool("no-dhcp-probe", false, "do not send DHCPDISCOVERs") _ = fs.Parse(args) ifs := discoverInterfaces(!*noProbe) if *asJSON { enc := json.NewEncoder(os.Stdout) enc.SetIndent("", " ") return enc.Encode(ifs) } fmt.Printf("%-12s %-8s %-5s %6s %-22s %-28s %-14s %s\n", "INTERFACE", "KIND", "LINK", "SPEED", "ADDRESSES", "SWITCH / PORT / VLAN", "DHCP SERVERS", "NEIGH") for _, i := range ifs { link := "down" if i.Up { link = "up" } speed := "-" if i.SpeedMbps > 0 { speed = fmt.Sprintf("%dG", i.SpeedMbps/1000) if i.SpeedMbps < 1000 { speed = fmt.Sprintf("%dM", i.SpeedMbps) } } sw := "-" if i.Switch != "" || i.Port != "" { sw = strings.Trim(i.Switch+" / "+i.Port+" / "+orDash(i.VLAN), " /") } dh := strings.Join(i.DHCP, ",") if dh == "" { dh = orDash(i.DHCPProbe) } name := i.Name if i.Default { name += "*" } fmt.Printf("%-12s %-8s %-5s %6s %-22s %-28s %-14s %d\n", name, i.Kind, link, speed, trunc(strings.Join(i.Addrs, " "), 22), trunc(sw, 28), trunc(dh, 14), i.Neighbours) } fmt.Println("(* carries the default route)") fmt.Println() for _, i := range ifs { if i.Suggestion != "" { fmt.Printf("%-12s %s\n", i.Name, i.Suggestion) } } return nil } func discoverInterfaces(probe bool) []discoIface { def := defaultRouteIface() lldp := lldpNeighbours() nets, _ := net.Interfaces() var out []discoIface type probeRes struct { servers []string err error } probes := map[string]chan probeRes{} if probe { // in parallel: a DHCP server may take seconds to offer (it pings the address first) for _, n := range nets { if n.Flags&net.FlagLoopback != 0 || n.Flags&net.FlagUp == 0 || skipIface(n.Name) || ifaceKind(n.Name) == "bridge" || ifaceKind(n.Name) == "virtual" { continue } ch := make(chan probeRes, 1) probes[n.Name] = ch go func(name string) { s, err := dhcpProbe(name, 6*time.Second); ch <- probeRes{s, err} }(n.Name) } } for _, n := range nets { if n.Flags&net.FlagLoopback != 0 || skipIface(n.Name) { continue } d := discoIface{Name: n.Name, MAC: n.HardwareAddr.String(), Kind: ifaceKind(n.Name), Default: n.Name == def, Addrs: []string{}, Subnets: []string{}, DHCP: []string{}} if b, err := os.ReadFile("/sys/class/net/" + n.Name + "/operstate"); err == nil { d.Up = strings.TrimSpace(string(b)) == "up" } if b, err := os.ReadFile("/sys/class/net/" + n.Name + "/speed"); err == nil { if v, err := strconv.Atoi(strings.TrimSpace(string(b))); err == nil && v > 0 { d.SpeedMbps = v } } addrs, _ := n.Addrs() for _, a := range addrs { ipn, ok := a.(*net.IPNet) if !ok || ipn.IP.IsLinkLocalUnicast() { continue } ones, _ := ipn.Mask.Size() d.Addrs = append(d.Addrs, fmt.Sprintf("%s/%d", ipn.IP, ones)) d.Subnets = append(d.Subnets, (&net.IPNet{IP: ipn.IP.Mask(ipn.Mask), Mask: ipn.Mask}).String()) } if l, ok := lldp[n.Name]; ok { d.Switch, d.Port, d.VLAN = l[0], l[1], l[2] } d.Neighbours = neighbourCount(n.Name) switch { case !probe: d.DHCPProbe = "not probed" case !d.Up: d.DHCPProbe = "link down" case d.Kind == "bridge" || d.Kind == "virtual": d.DHCPProbe = "skipped" case probes[n.Name] == nil: d.DHCPProbe = "skipped" default: r := <-probes[n.Name] if s, err := r.servers, r.err; err != nil { d.DHCPProbe = "needs root" } else { for _, x := range s { if ifaceWithAddr(x) == "" { d.DHCP = append(d.DHCP, x) } else { d.DHCP = append(d.DHCP, x+"(this host)") } } if len(s) == 0 { d.DHCPProbe = "none" } } } d.Suggestion = discoSuggest(d) out = append(out, d) } sort.Slice(out, func(i, j int) bool { return out[i].Name < out[j].Name }) return out } func discoSuggest(d discoIface) string { foreign := 0 for _, s := range d.DHCP { if !strings.HasSuffix(s, "(this host)") { foreign++ } } v4 := "" for _, s := range d.Subnets { if !strings.Contains(s, ":") { v4 = s break } } vlan := "" if d.VLAN != "" { vlan = " (switch says VLAN " + d.VLAN + ")" } switch { case d.Kind == "bridge" || d.Kind == "virtual": return "" case !d.Up: return "no link: cable it to the provisioning network" + vlan case d.Default && foreign > 0: return "uplink: management network with its own DHCP (" + strings.Join(d.DHCP, ",") + "); keep it for the region's access" + vlan case d.Default: return "uplink: the region is reached here" + vlan case v4 == "": return "link up, no IPv4 address" + vlan + ": give it its address on the provisioning network, then bootstrap.sh --iface " + d.Name case foreign > 0: return v4 + " already has DHCP (" + strings.Join(d.DHCP, ",") + "): keep it and answer only PXE from here - bootstrap.sh --iface " + d.Name + " --proxy-dhcp - or the network team turns it off for this VLAN" default: return "candidate provisioning network " + v4 + vlan + ": bootstrap.sh --iface " + d.Name + " (or Network -> New subnet in the web UI)" } } func skipIface(name string) bool { for _, p := range []string{"docker", "veth", "virbr", "br-", "cni", "flannel", "tap", "vnet", "wg", "tun"} { if strings.HasPrefix(name, p) { return true } } return false } func ifaceKind(name string) string { base := "/sys/class/net/" + name switch { case exists(base + "/bridge"): return "bridge" case exists(base + "/bonding"): return "bond" case exists("/proc/net/vlan/" + name): return "vlan" case exists(base + "/device"): return "physical" } return "virtual" } func exists(p string) bool { _, err := os.Stat(p); return err == nil } func defaultRouteIface() string { b, err := os.ReadFile("/proc/net/route") if err != nil { return "" } for _, l := range strings.Split(string(b), "\n")[1:] { f := strings.Fields(l) if len(f) > 2 && f[1] == "00000000" && f[7] == "00000000" { return f[0] } } return "" } func neighbourCount(iface string) int { out, err := exec.Command("ip", "-j", "neigh", "show", "dev", iface).Output() if err != nil { return 0 } var ns []map[string]any _ = json.Unmarshal(out, &ns) n := 0 for _, x := range ns { if st, _ := x["state"].([]any); len(st) > 0 && st[0] != "FAILED" && st[0] != "INCOMPLETE" { n++ } } return n } // lldpNeighbours: interface -> [switch name, port, vlan] from lldpd. func lldpNeighbours() map[string][3]string { out := map[string][3]string{} bin, err := exec.LookPath("lldpcli") if err != nil { return out } b, err := exec.Command(bin, "-f", "json0", "show", "neighbors", "details").Output() if err != nil { return out } var doc struct { LLDP []struct { Interface []struct { Name string `json:"name"` Chassis []struct { Name []struct { Value string `json:"value"` } `json:"name"` } `json:"chassis"` Port []struct { ID []struct { Value string `json:"value"` } `json:"id"` Descr []struct { Value string `json:"value"` } `json:"descr"` } `json:"port"` VLAN []struct { VlanID string `json:"vlan-id"` PVID bool `json:"pvid"` } `json:"vlan"` } `json:"interface"` } `json:"lldp"` } if json.Unmarshal(b, &doc) != nil { return out } for _, l := range doc.LLDP { for _, i := range l.Interface { var sw, port, vlan string if len(i.Chassis) > 0 && len(i.Chassis[0].Name) > 0 { sw = i.Chassis[0].Name[0].Value } if len(i.Port) > 0 { if len(i.Port[0].Descr) > 0 { port = i.Port[0].Descr[0].Value } else if len(i.Port[0].ID) > 0 { port = i.Port[0].ID[0].Value } } var vs []string for _, v := range i.VLAN { s := v.VlanID if v.PVID { s += "(untagged)" } vs = append(vs, s) } vlan = strings.Join(vs, ",") out[filepath.Base(i.Name)] = [3]string{sw, port, vlan} } } return out }