Update App version to 0.0.4

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

internal/network/config.go

@@ -33,23 +33,24 @@ type IPv6StaticConfig struct {
 	DNS     []string    `json:"dns,omitempty" validate_type:"ipv6" required:"true"`
 }
 type NetworkConfig struct {
-	Hostname null.String `json:"hostname,omitempty" validate_type:"hostname"`
-	Domain   null.String `json:"domain,omitempty" validate_type:"hostname"`
+    Hostname null.String `json:"hostname,omitempty" validate_type:"hostname"`
+    Domain   null.String `json:"domain,omitempty" validate_type:"hostname"`
 
-	IPv4Mode           null.String       `json:"ipv4_mode,omitempty" one_of:"dhcp,static,disabled" default:"dhcp"`
-	IPv4RequestAddress null.String       `json:"ipv4_request_address,omitempty"`
-	IPv4Static         *IPv4StaticConfig `json:"ipv4_static,omitempty" required_if:"IPv4Mode=static"`
+    IPv4Mode           null.String       `json:"ipv4_mode,omitempty" one_of:"dhcp,static,disabled" default:"dhcp"`
+    IPv4RequestAddress null.String       `json:"ipv4_request_address,omitempty"`
+    IPv4Static         *IPv4StaticConfig `json:"ipv4_static,omitempty" required_if:"IPv4Mode=static"`
 
-	IPv6Mode   null.String       `json:"ipv6_mode,omitempty" one_of:"slaac,dhcpv6,slaac_and_dhcpv6,static,link_local,disabled" default:"slaac"`
-	IPv6Static *IPv6StaticConfig `json:"ipv6_static,omitempty" required_if:"IPv6Mode=static"`
+    IPv6Mode   null.String       `json:"ipv6_mode,omitempty" one_of:"slaac,dhcpv6,slaac_and_dhcpv6,static,link_local,disabled" default:"slaac"`
+    IPv6Static *IPv6StaticConfig `json:"ipv6_static,omitempty" required_if:"IPv6Mode=static"`
 
-	LLDPMode                null.String `json:"lldp_mode,omitempty" one_of:"disabled,basic,all" default:"basic"`
-	LLDPTxTLVs              []string    `json:"lldp_tx_tlvs,omitempty" one_of:"chassis,port,system,vlan" default:"chassis,port,system,vlan"`
-	MDNSMode                null.String `json:"mdns_mode,omitempty" one_of:"disabled,auto,ipv4_only,ipv6_only" default:"auto"`
-	TimeSyncMode            null.String `json:"time_sync_mode,omitempty" one_of:"ntp_only,ntp_and_http,http_only,custom" default:"ntp_and_http"`
-	TimeSyncOrdering        []string    `json:"time_sync_ordering,omitempty" one_of:"http,ntp,ntp_dhcp,ntp_user_provided,ntp_fallback" default:"ntp,http"`
-	TimeSyncDisableFallback null.Bool   `json:"time_sync_disable_fallback,omitempty" default:"false"`
-	TimeSyncParallel        null.Int    `json:"time_sync_parallel,omitempty" default:"4"`
+    LLDPMode                null.String `json:"lldp_mode,omitempty" one_of:"disabled,basic,all" default:"basic"`
+    LLDPTxTLVs              []string    `json:"lldp_tx_tlvs,omitempty" one_of:"chassis,port,system,vlan" default:"chassis,port,system,vlan"`
+    MDNSMode                null.String `json:"mdns_mode,omitempty" one_of:"disabled,auto,ipv4_only,ipv6_only" default:"auto"`
+    TimeSyncMode            null.String `json:"time_sync_mode,omitempty" one_of:"ntp_only,ntp_and_http,http_only,custom" default:"ntp_and_http"`
+    TimeSyncOrdering        []string    `json:"time_sync_ordering,omitempty" one_of:"http,ntp,ntp_dhcp,ntp_user_provided,ntp_fallback" default:"ntp,http"`
+    TimeSyncDisableFallback null.Bool   `json:"time_sync_disable_fallback,omitempty" default:"false"`
+    TimeSyncParallel        null.Int    `json:"time_sync_parallel,omitempty" default:"4"`
+    PendingReboot           null.Bool   `json:"pending_reboot,omitempty" default:"false"`
 }
 
 func (c *NetworkConfig) GetMDNSMode() *mdns.MDNSListenOptions {

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
 }

internal/network/rpc.go

@@ -1,11 +1,13 @@
 package network
 
 import (
-	"fmt"
-	"time"
+    "fmt"
+    "time"
 
-	"kvm/internal/confparser"
-	"kvm/internal/udhcpc"
+    "kvm/internal/confparser"
+    "kvm/internal/udhcpc"
+
+    "github.com/guregu/null/v6"
 )
 
 type RpcIPv6Address struct {
@@ -99,17 +101,22 @@ func (s *NetworkInterfaceState) RpcGetNetworkSettings() RpcNetworkSettings {
 }
 
 func (s *NetworkInterfaceState) RpcSetNetworkSettings(settings RpcNetworkSettings) error {
-	currentSettings := s.config
+    currentSettings := s.config
 
-	err := confparser.SetDefaultsAndValidate(&settings.NetworkConfig)
-	if err != nil {
-		return err
-	}
+    err := confparser.SetDefaultsAndValidate(&settings.NetworkConfig)
+    if err != nil {
+        return err
+    }
 
-	if IsSame(currentSettings, settings.NetworkConfig) {
-		// no changes, do nothing
-		return nil
-	}
+    neutralA := *currentSettings
+    neutralB := settings.NetworkConfig
+    neutralA.PendingReboot = null.Bool{}
+    neutralB.PendingReboot = null.Bool{}
+
+    if IsSame(neutralA, neutralB) {
+        // no changes, do nothing
+        return nil
+    }
 
 	s.config = &settings.NetworkConfig
 	s.onConfigChange(s.config)
@@ -124,3 +131,10 @@ func (s *NetworkInterfaceState) RpcRenewDHCPLease() error {
 
 	return s.dhcpClient.Renew()
 }
+
+func (s *NetworkInterfaceState) RpcRequestDHCPAddress(ip string) error {
+	if s.dhcpClient == nil {
+		return fmt.Errorf("dhcp client not initialized")
+	}
+	return s.dhcpClient.RequestAddress(ip)
+}