Update App version to 0.0.4

Signed-off-by: luckfox-eng29 <eng29@luckfox.com>

internal/network/netif.go

@@ -1,13 +1,16 @@
 package network
 
 import (
-	"fmt"
-	"net"
-	"sync"
+    "fmt"
+    "net"
+    "os"
+    "strconv"
+    "strings"
+    "sync"
 
-	"kvm/internal/confparser"
-	"kvm/internal/logging"
-	"kvm/internal/udhcpc"
+    "kvm/internal/confparser"
+    "kvm/internal/logging"
+    "kvm/internal/udhcpc"
 
 	"github.com/rs/zerolog"
 
@@ -100,6 +103,31 @@ func NewNetworkInterfaceState(opts *NetworkInterfaceOptions) (*NetworkInterfaceS
 
 	s.dhcpClient = dhcpClient
 
+	mode := strings.TrimSpace(s.config.IPv4Mode.String)
+	switch mode {
+	case "static":
+		if s.dhcpClient != nil {
+			s.dhcpClient.SetEnabled(false)
+		}
+		if err := s.applyIPv4Static(); err != nil {
+			l.Error().Err(err).Msg("failed to apply static IPv4 on init")
+		}
+	case "dhcp":
+		if s.dhcpClient != nil {
+			s.dhcpClient.SetEnabled(true)
+		}
+	case "disabled":
+		if s.dhcpClient != nil {
+			s.dhcpClient.SetEnabled(false)
+		}
+		if err := s.clearIPv4Addresses(); err != nil {
+			l.Warn().Err(err).Msg("failed to clear IPv4 addresses on init")
+		}
+		if err := s.clearDefaultIPv4Route(); err != nil {
+			l.Debug().Err(err).Msg("failed to clear default route on init")
+		}
+	}
+
 	return s, nil
 }
 
@@ -343,6 +371,162 @@ func (s *NetworkInterfaceState) CheckAndUpdateDhcp() error {
 }
 
 func (s *NetworkInterfaceState) onConfigChange(config *NetworkConfig) {
-	_ = s.setHostnameIfNotSame()
-	s.cbConfigChange(config)
+    _ = s.setHostnameIfNotSame()
+    s.cbConfigChange(config)
+}
+
+// clearIPv4Addresses removes all IPv4 addresses from the interface.
+func (s *NetworkInterfaceState) clearIPv4Addresses() error {
+    iface, err := netlink.LinkByName(s.interfaceName)
+    if err != nil {
+        return err
+    }
+    addrs, err := netlinkAddrs(iface)
+    if err != nil {
+        return err
+    }
+    for _, addr := range addrs {
+        if addr.IP.To4() != nil {
+            if err := netlink.AddrDel(iface, &addr); err != nil {
+                s.l.Warn().Err(err).Str("addr", addr.IPNet.String()).Msg("failed to delete IPv4 address")
+            }
+        }
+    }
+    return nil
+}
+
+// clearDefaultIPv4Route removes existing default IPv4 route on this interface.
+func (s *NetworkInterfaceState) clearDefaultIPv4Route() error {
+    iface, err := netlink.LinkByName(s.interfaceName)
+    if err != nil {
+        return err
+    }
+    routes, err := netlink.RouteList(iface, netlink.FAMILY_V4)
+    if err != nil {
+        return err
+    }
+    for _, r := range routes {
+        if r.Dst == nil { // default route
+            if err := netlink.RouteDel(&r); err != nil {
+                s.l.Warn().Err(err).Msg("failed to delete default route")
+            }
+        }
+    }
+    return nil
+}
+
+// parseIPv4Mask converts dotted decimal netmask to net.IPMask.
+func parseIPv4Mask(mask string) (net.IPMask, error) {
+    parts := strings.Split(strings.TrimSpace(mask), ".")
+    if len(parts) != 4 {
+        return nil, fmt.Errorf("invalid netmask: %s", mask)
+    }
+    bytes := make([]byte, 4)
+    for i := 0; i < 4; i++ {
+        v, err := strconv.Atoi(parts[i])
+        if err != nil || v < 0 || v > 255 {
+            return nil, fmt.Errorf("invalid netmask octet: %s", parts[i])
+        }
+        bytes[i] = byte(v)
+    }
+    return net.IPv4Mask(bytes[0], bytes[1], bytes[2], bytes[3]), nil
+}
+
+// writeResolvConf writes DNS servers and optional domain into /etc/resolv.conf.
+func (s *NetworkInterfaceState) writeResolvConf(dns []string, domain string) error {
+    var b strings.Builder
+    if domain != "" {
+        b.WriteString("search ")
+        b.WriteString(domain)
+        b.WriteString("\n")
+    }
+    for _, d := range dns {
+        d = strings.TrimSpace(d)
+        if d == "" {
+            continue
+        }
+        b.WriteString("nameserver ")
+        b.WriteString(d)
+        b.WriteString("\n")
+    }
+    content := b.String()
+    if content == "" {
+        return nil
+    }
+    if err := os.WriteFile("/etc/resolv.conf", []byte(content), 0644); err != nil {
+        return err
+    }
+    s.l.Info().Msg("updated /etc/resolv.conf for static IPv4")
+    return nil
+}
+
+// applyIPv4Static sets a static IPv4 address, default route, and DNS.
+func (s *NetworkInterfaceState) applyIPv4Static() error {
+    if s.config == nil || s.config.IPv4Static == nil {
+        return fmt.Errorf("IPv4Static config not provided")
+    }
+    ipStr := strings.TrimSpace(s.config.IPv4Static.Address.String)
+    maskStr := strings.TrimSpace(s.config.IPv4Static.Netmask.String)
+    gwStr := strings.TrimSpace(s.config.IPv4Static.Gateway.String)
+    dns := s.config.IPv4Static.DNS
+
+    ip := net.ParseIP(ipStr)
+    if ip == nil || ip.To4() == nil {
+        return fmt.Errorf("invalid IPv4 address: %s", ipStr)
+    }
+    mask, err := parseIPv4Mask(maskStr)
+    if err != nil {
+        return err
+    }
+
+    iface, err := netlink.LinkByName(s.interfaceName)
+    if err != nil {
+        return err
+    }
+
+    // Clear existing IPv4 addresses and default route
+    if err := s.clearIPv4Addresses(); err != nil {
+        s.l.Warn().Err(err).Msg("failed clearing IPv4 addresses prior to static apply")
+    }
+    if err := s.clearDefaultIPv4Route(); err != nil {
+        s.l.Warn().Err(err).Msg("failed clearing default route prior to static apply")
+    }
+
+    ipNet := &net.IPNet{IP: ip, Mask: mask}
+    addr := &netlink.Addr{IPNet: ipNet}
+    if err := netlink.AddrAdd(iface, addr); err != nil {
+        return logging.ErrorfL(s.l, "failed to add static IPv4 address", err)
+    }
+    s.l.Info().Str("ipv4", ipNet.String()).Msg("static IPv4 address applied")
+
+    // Default route
+    if gwStr != "" {
+        gw := net.ParseIP(gwStr)
+        if gw == nil || gw.To4() == nil {
+            s.l.Warn().Str("gateway", gwStr).Msg("invalid IPv4 gateway; skipping route")
+        } else {
+            route := netlink.Route{LinkIndex: iface.Attrs().Index, Gw: gw}
+            // remove any existing default routes already attempted above, then add
+            if err := netlink.RouteAdd(&route); err != nil {
+                // try replace if add failed
+                if replaceErr := netlink.RouteReplace(&route); replaceErr != nil {
+                    s.l.Warn().Err(err).Msg("failed to add default route")
+                }
+            }
+            s.l.Info().Str("gateway", gwStr).Msg("default route applied")
+        }
+    }
+
+    // DNS
+    if len(dns) > 0 {
+        if err := s.writeResolvConf(dns, s.GetDomain()); err != nil {
+            s.l.Warn().Err(err).Msg("failed to write resolv.conf")
+        }
+    }
+
+    // Refresh internal state
+    if _, err := s.update(); err != nil {
+        s.l.Warn().Err(err).Msg("failed to refresh state after static apply")
+    }
+    return nil
 }