NetworkTool/server/internal/network/interfaces/interfaces.go

package interfaces

import (
	"net"
	"os"
	"path/filepath"
	"sort"
	"strings"

	"networktool/internal/config"
	"networktool/internal/model"
)

type Service struct {
	cfg config.Config
}

func New(cfg config.Config) *Service {
	return &Service{cfg: cfg}
}

func (s *Service) List() (model.InterfacesResponse, error) {
	items, err := s.listPhysicalInterfaces()
	if err != nil {
		return model.InterfacesResponse{}, err
	}

	management := s.detectManagement(items)
	for i := range items {
		items[i].IsManagement = items[i].SystemName == management
		items[i].Name = items[i].SystemName
		if items[i].IsManagement {
			items[i].Role = "control"
		} else {
			items[i].Role = "business"
		}
	}

	suggested, requiresSelection := suggestTarget(items, management)
	for i := range items {
		items[i].IsSuggestedTarget = items[i].SystemName == suggested
	}

	return model.InterfacesResponse{
		ManagementInterface:      management,
		SuggestedTargetInterface: suggested,
		RequiresTargetSelection:  requiresSelection,
		Interfaces:               items,
	}, nil
}

func (s *Service) listPhysicalInterfaces() ([]model.NetworkInterface, error) {
	ifaces, err := net.Interfaces()
	if err != nil {
		return nil, err
	}

	items := make([]model.NetworkInterface, 0)
	for _, iface := range ifaces {
		if !isPhysicalEthernet(iface.Name) {
			continue
		}

		item := model.NetworkInterface{
			SystemName: iface.Name,
			MAC:        iface.HardwareAddr.String(),
			LinkUp:     readLinkUp(iface.Name),
			Gateway:    "",
			DNS:        []string{},
		}
		item.IPv4 = readIPv4(iface)
		items = append(items, item)
	}

	sort.Slice(items, func(i, j int) bool { return items[i].SystemName < items[j].SystemName })
	return items, nil
}

func (s *Service) detectManagement(items []model.NetworkInterface) string {
	for _, item := range items {
		for _, addr := range item.IPv4 {
			if s.cfg.MaintenanceIP != "" && addr.Address == s.cfg.MaintenanceIP {
				return item.SystemName
			}
			if s.cfg.MaintenanceIP == "" && strings.HasPrefix(addr.Address, "169.254.") {
				return item.SystemName
			}
		}
	}
	if len(items) == 2 {
		return items[1].SystemName
	}
	if len(items) > 0 {
		return items[len(items)-1].SystemName
	}
	return ""
}

func suggestTarget(items []model.NetworkInterface, management string) (string, bool) {
	candidates := make([]string, 0)
	for _, item := range items {
		if item.SystemName != management {
			candidates = append(candidates, item.SystemName)
		}
	}
	if len(candidates) == 1 {
		return candidates[0], false
	}
	return "", len(candidates) > 1
}

func readIPv4(iface net.Interface) []model.IPv4Address {
	addrs, err := iface.Addrs()
	if err != nil {
		return nil
	}
	result := make([]model.IPv4Address, 0)
	for _, addr := range addrs {
		ipNet, ok := addr.(*net.IPNet)
		if !ok || ipNet.IP.To4() == nil {
			continue
		}
		prefix, _ := ipNet.Mask.Size()
		source := "unknown"
		if strings.HasPrefix(ipNet.IP.String(), "169.254.") {
			source = "static"
		}
		result = append(result, model.IPv4Address{Address: ipNet.IP.String(), Prefix: prefix, Source: source})
	}
	return result
}

func isPhysicalEthernet(name string) bool {
	if name == "lo" {
		return false
	}
	for _, prefix := range []string{"docker", "br-", "veth", "virbr", "tun", "tap", "wg", "zt", "vmnet"} {
		if strings.HasPrefix(name, prefix) {
			return false
		}
	}
	devicePath := filepath.Join("/sys/class/net", name, "device")
	if _, err := os.Stat(devicePath); err != nil {
		return false
	}
	return true
}

func readLinkUp(name string) bool {
	carrierPath := filepath.Join("/sys/class/net", name, "carrier")
	data, err := os.ReadFile(carrierPath)
	if err == nil {
		return strings.TrimSpace(string(data)) == "1"
	}
	statePath := filepath.Join("/sys/class/net", name, "operstate")
	data, err = os.ReadFile(statePath)
	if err != nil {
		return false
	}
	return strings.TrimSpace(string(data)) == "up"
}