mirror of https://github.com/jetkvm/kvm.git
502 lines
14 KiB
Go
502 lines
14 KiB
Go
package kvm
|
|
|
|
import (
|
|
"fmt"
|
|
"net"
|
|
"os"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/Masterminds/semver/v3"
|
|
"github.com/jetkvm/kvm/internal/udhcpc"
|
|
"github.com/rs/zerolog"
|
|
|
|
"github.com/vishvananda/netlink"
|
|
"github.com/vishvananda/netlink/nl"
|
|
)
|
|
|
|
var (
|
|
networkState *NetworkInterfaceState
|
|
)
|
|
|
|
type DhcpTargetState int
|
|
|
|
const (
|
|
DhcpTargetStateDoNothing DhcpTargetState = iota
|
|
DhcpTargetStateStart
|
|
DhcpTargetStateStop
|
|
DhcpTargetStateRenew
|
|
DhcpTargetStateRelease
|
|
)
|
|
|
|
type IPv6Address struct {
|
|
Address net.IP `json:"address"`
|
|
Prefix net.IPNet `json:"prefix"`
|
|
ValidLifetime *time.Time `json:"valid_lifetime"`
|
|
PreferredLifetime *time.Time `json:"preferred_lifetime"`
|
|
Scope int `json:"scope"`
|
|
}
|
|
|
|
type NetworkInterfaceState struct {
|
|
interfaceName string
|
|
interfaceUp bool
|
|
ipv4Addr *net.IP
|
|
ipv4Addresses []string
|
|
ipv6Addr *net.IP
|
|
ipv6Addresses []IPv6Address
|
|
ipv6LinkLocal *net.IP
|
|
macAddr *net.HardwareAddr
|
|
|
|
l *zerolog.Logger
|
|
stateLock sync.Mutex
|
|
|
|
dhcpClient *udhcpc.DHCPClient
|
|
|
|
onStateChange func(state *NetworkInterfaceState)
|
|
onInitialCheck func(state *NetworkInterfaceState)
|
|
|
|
checked bool
|
|
}
|
|
|
|
type NetworkConfig struct {
|
|
Hostname string `json:"hostname,omitempty"`
|
|
Domain string `json:"domain,omitempty"`
|
|
|
|
IPv4Mode string `json:"ipv4_mode" one_of:"dhcp,static,disabled" default:"dhcp"`
|
|
IPv4Static struct {
|
|
Address string `json:"address" validate_type:"ipv4"`
|
|
Netmask string `json:"netmask" validate_type:"ipv4"`
|
|
Gateway string `json:"gateway" validate_type:"ipv4"`
|
|
DNS []string `json:"dns" validate_type:"ipv4"`
|
|
} `json:"ipv4_static,omitempty" required_if:"ipv4_mode,static"`
|
|
|
|
IPv6Mode string `json:"ipv6_mode" one_of:"slaac,dhcpv6,slaac_and_dhcpv6,static,link_local,disabled" default:"slaac"`
|
|
IPv6Static struct {
|
|
Address string `json:"address" validate_type:"ipv6"`
|
|
Netmask string `json:"netmask" validate_type:"ipv6"`
|
|
Gateway string `json:"gateway" validate_type:"ipv6"`
|
|
DNS []string `json:"dns" validate_type:"ipv6"`
|
|
} `json:"ipv6_static,omitempty" required_if:"ipv6_mode,static"`
|
|
|
|
LLDPMode 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 string `json:"mdns_mode,omitempty" one_of:"disabled,auto,ipv4_only,ipv6_only" default:"auto"`
|
|
TimeSyncMode string `json:"time_sync_mode,omitempty" one_of:"ntp_only,ntp_and_http,http_only,custom" default:"ntp_and_http"`
|
|
}
|
|
|
|
type RpcIPv6Address struct {
|
|
Address string `json:"address"`
|
|
ValidLifetime *time.Time `json:"valid_lifetime,omitempty"`
|
|
PreferredLifetime *time.Time `json:"preferred_lifetime,omitempty"`
|
|
Scope int `json:"scope"`
|
|
}
|
|
|
|
type RpcNetworkState struct {
|
|
InterfaceName string `json:"interface_name"`
|
|
MacAddress string `json:"mac_address"`
|
|
IPv4 string `json:"ipv4,omitempty"`
|
|
IPv6 string `json:"ipv6,omitempty"`
|
|
IPv6LinkLocal string `json:"ipv6_link_local,omitempty"`
|
|
IPv4Addresses []string `json:"ipv4_addresses,omitempty"`
|
|
IPv6Addresses []RpcIPv6Address `json:"ipv6_addresses,omitempty"`
|
|
DHCPLease *udhcpc.Lease `json:"dhcp_lease,omitempty"`
|
|
}
|
|
|
|
type RpcNetworkSettings struct {
|
|
IPv4Mode string `json:"ipv4_mode,omitempty"`
|
|
IPv6Mode string `json:"ipv6_mode,omitempty"`
|
|
LLDPMode string `json:"lldp_mode,omitempty"`
|
|
LLDPTxTLVs []string `json:"lldp_tx_tlvs,omitempty"`
|
|
MDNSMode string `json:"mdns_mode,omitempty"`
|
|
TimeSyncMode string `json:"time_sync_mode,omitempty"`
|
|
}
|
|
|
|
func lifetimeToTime(lifetime int) *time.Time {
|
|
if lifetime == 0 {
|
|
return nil
|
|
}
|
|
t := time.Now().Add(time.Duration(lifetime) * time.Second)
|
|
return &t
|
|
}
|
|
|
|
func (s *NetworkInterfaceState) IsUp() bool {
|
|
return s.interfaceUp
|
|
}
|
|
|
|
func (s *NetworkInterfaceState) HasIPAssigned() bool {
|
|
return s.ipv4Addr != nil || s.ipv6Addr != nil
|
|
}
|
|
|
|
func (s *NetworkInterfaceState) IsOnline() bool {
|
|
return s.IsUp() && s.HasIPAssigned()
|
|
}
|
|
|
|
func (s *NetworkInterfaceState) IPv4() *net.IP {
|
|
return s.ipv4Addr
|
|
}
|
|
|
|
func (s *NetworkInterfaceState) IPv4String() string {
|
|
if s.ipv4Addr == nil {
|
|
return "..."
|
|
}
|
|
return s.ipv4Addr.String()
|
|
}
|
|
|
|
func (s *NetworkInterfaceState) IPv6() *net.IP {
|
|
return s.ipv6Addr
|
|
}
|
|
|
|
func (s *NetworkInterfaceState) IPv6String() string {
|
|
if s.ipv6Addr == nil {
|
|
return "..."
|
|
}
|
|
return s.ipv6Addr.String()
|
|
}
|
|
|
|
func (s *NetworkInterfaceState) MAC() *net.HardwareAddr {
|
|
return s.macAddr
|
|
}
|
|
|
|
func (s *NetworkInterfaceState) MACString() string {
|
|
if s.macAddr == nil {
|
|
return ""
|
|
}
|
|
return s.macAddr.String()
|
|
}
|
|
|
|
const (
|
|
// TODO: add support for multiple interfaces
|
|
NetIfName = "eth0"
|
|
)
|
|
|
|
func NewNetworkInterfaceState(ifname string) *NetworkInterfaceState {
|
|
logger := networkLogger.With().Str("interface", ifname).Logger()
|
|
|
|
s := &NetworkInterfaceState{
|
|
interfaceName: ifname,
|
|
stateLock: sync.Mutex{},
|
|
l: &logger,
|
|
onStateChange: func(state *NetworkInterfaceState) {
|
|
go func() {
|
|
waitCtrlClientConnected()
|
|
requestDisplayUpdate(true)
|
|
}()
|
|
},
|
|
onInitialCheck: func(state *NetworkInterfaceState) {
|
|
go func() {
|
|
waitCtrlClientConnected()
|
|
requestDisplayUpdate(true)
|
|
}()
|
|
},
|
|
}
|
|
|
|
// use a pid file for udhcpc if the system version is 0.2.4 or higher
|
|
dhcpPidFile := ""
|
|
systemVersionLocal, _, _ := GetLocalVersion()
|
|
if systemVersionLocal != nil &&
|
|
systemVersionLocal.Compare(semver.MustParse("0.2.4")) >= 0 {
|
|
dhcpPidFile = fmt.Sprintf("/run/udhcpc.%s.pid", ifname)
|
|
}
|
|
|
|
// create the dhcp client
|
|
dhcpClient := udhcpc.NewDHCPClient(&udhcpc.DHCPClientOptions{
|
|
InterfaceName: ifname,
|
|
PidFile: dhcpPidFile,
|
|
Logger: &logger,
|
|
OnLeaseChange: func(lease *udhcpc.Lease) {
|
|
_, err := s.update()
|
|
if err != nil {
|
|
logger.Error().Err(err).Msg("failed to update network state")
|
|
return
|
|
}
|
|
|
|
if currentSession == nil {
|
|
logger.Info().Msg("No active RPC session, skipping network state update")
|
|
return
|
|
}
|
|
|
|
writeJSONRPCEvent("networkState", rpcGetNetworkState(), currentSession)
|
|
},
|
|
})
|
|
|
|
s.dhcpClient = dhcpClient
|
|
|
|
return s
|
|
}
|
|
|
|
func (s *NetworkInterfaceState) update() (DhcpTargetState, error) {
|
|
s.stateLock.Lock()
|
|
defer s.stateLock.Unlock()
|
|
|
|
dhcpTargetState := DhcpTargetStateDoNothing
|
|
|
|
iface, err := netlink.LinkByName(s.interfaceName)
|
|
if err != nil {
|
|
s.l.Error().Err(err).Msg("failed to get interface")
|
|
return dhcpTargetState, err
|
|
}
|
|
|
|
// detect if the interface status changed
|
|
var changed bool
|
|
attrs := iface.Attrs()
|
|
state := attrs.OperState
|
|
newInterfaceUp := state == netlink.OperUp
|
|
|
|
// check if the interface is coming up
|
|
interfaceGoingUp := !s.interfaceUp && newInterfaceUp
|
|
interfaceGoingDown := s.interfaceUp && !newInterfaceUp
|
|
|
|
if s.interfaceUp != newInterfaceUp {
|
|
s.interfaceUp = newInterfaceUp
|
|
changed = true
|
|
}
|
|
|
|
if changed {
|
|
if interfaceGoingUp {
|
|
s.l.Info().Msg("interface state transitioned to up")
|
|
dhcpTargetState = DhcpTargetStateRenew
|
|
} else if interfaceGoingDown {
|
|
s.l.Info().Msg("interface state transitioned to down")
|
|
}
|
|
}
|
|
|
|
// set the mac address
|
|
s.macAddr = &attrs.HardwareAddr
|
|
|
|
// get the ip addresses
|
|
addrs, err := netlink.AddrList(iface, nl.FAMILY_ALL)
|
|
if err != nil {
|
|
s.l.Error().Err(err).Msg("failed to get ip addresses")
|
|
return dhcpTargetState, err
|
|
}
|
|
|
|
var (
|
|
ipv4Addresses = make([]net.IP, 0)
|
|
ipv4AddressesString = make([]string, 0)
|
|
ipv6Addresses = make([]IPv6Address, 0)
|
|
ipv6AddressesString = make([]string, 0)
|
|
ipv6LinkLocal *net.IP
|
|
)
|
|
|
|
for _, addr := range addrs {
|
|
if addr.IP.To4() != nil {
|
|
scopedLogger := s.l.With().Str("ipv4", addr.IP.String()).Logger()
|
|
if interfaceGoingDown {
|
|
// remove all IPv4 addresses from the interface.
|
|
scopedLogger.Info().Msg("state transitioned to down, removing IPv4 address")
|
|
err := netlink.AddrDel(iface, &addr)
|
|
if err != nil {
|
|
scopedLogger.Warn().Err(err).Msg("failed to delete address")
|
|
}
|
|
// notify the DHCP client to release the lease
|
|
dhcpTargetState = DhcpTargetStateRelease
|
|
continue
|
|
}
|
|
ipv4Addresses = append(ipv4Addresses, addr.IP)
|
|
ipv4AddressesString = append(ipv4AddressesString, addr.IPNet.String())
|
|
} else if addr.IP.To16() != nil {
|
|
scopedLogger := s.l.With().Str("ipv6", addr.IP.String()).Logger()
|
|
// check if it's a link local address
|
|
if addr.IP.IsLinkLocalUnicast() {
|
|
ipv6LinkLocal = &addr.IP
|
|
continue
|
|
}
|
|
|
|
if !addr.IP.IsGlobalUnicast() {
|
|
scopedLogger.Trace().Msg("not a global unicast address, skipping")
|
|
continue
|
|
}
|
|
|
|
if interfaceGoingDown {
|
|
scopedLogger.Info().Msg("state transitioned to down, removing IPv6 address")
|
|
err := netlink.AddrDel(iface, &addr)
|
|
if err != nil {
|
|
scopedLogger.Warn().Err(err).Msg("failed to delete address")
|
|
}
|
|
continue
|
|
}
|
|
ipv6Addresses = append(ipv6Addresses, IPv6Address{
|
|
Address: addr.IP,
|
|
Prefix: *addr.IPNet,
|
|
ValidLifetime: lifetimeToTime(addr.ValidLft),
|
|
PreferredLifetime: lifetimeToTime(addr.PreferedLft),
|
|
Scope: addr.Scope,
|
|
})
|
|
ipv6AddressesString = append(ipv6AddressesString, addr.IPNet.String())
|
|
}
|
|
}
|
|
|
|
if len(ipv4Addresses) > 0 {
|
|
// compare the addresses to see if there's a change
|
|
if s.ipv4Addr == nil || s.ipv4Addr.String() != ipv4Addresses[0].String() {
|
|
scopedLogger := s.l.With().Str("ipv4", ipv4Addresses[0].String()).Logger()
|
|
if s.ipv4Addr != nil {
|
|
scopedLogger.Info().
|
|
Str("old_ipv4", s.ipv4Addr.String()).
|
|
Msg("IPv4 address changed")
|
|
} else {
|
|
scopedLogger.Info().Msg("IPv4 address found")
|
|
}
|
|
s.ipv4Addr = &ipv4Addresses[0]
|
|
changed = true
|
|
}
|
|
}
|
|
s.ipv4Addresses = ipv4AddressesString
|
|
|
|
if ipv6LinkLocal != nil {
|
|
if s.ipv6LinkLocal == nil || s.ipv6LinkLocal.String() != ipv6LinkLocal.String() {
|
|
scopedLogger := s.l.With().Str("ipv6", ipv6LinkLocal.String()).Logger()
|
|
if s.ipv6LinkLocal != nil {
|
|
scopedLogger.Info().
|
|
Str("old_ipv6", s.ipv6LinkLocal.String()).
|
|
Msg("IPv6 link local address changed")
|
|
} else {
|
|
scopedLogger.Info().Msg("IPv6 link local address found")
|
|
}
|
|
s.ipv6LinkLocal = ipv6LinkLocal
|
|
changed = true
|
|
}
|
|
}
|
|
s.ipv6Addresses = ipv6Addresses
|
|
|
|
if len(ipv6Addresses) > 0 {
|
|
// compare the addresses to see if there's a change
|
|
if s.ipv6Addr == nil || s.ipv6Addr.String() != ipv6Addresses[0].Address.String() {
|
|
scopedLogger := s.l.With().Str("ipv6", ipv6Addresses[0].Address.String()).Logger()
|
|
if s.ipv6Addr != nil {
|
|
scopedLogger.Info().
|
|
Str("old_ipv6", s.ipv6Addr.String()).
|
|
Msg("IPv6 address changed")
|
|
} else {
|
|
scopedLogger.Info().Msg("IPv6 address found")
|
|
}
|
|
s.ipv6Addr = &ipv6Addresses[0].Address
|
|
changed = true
|
|
}
|
|
}
|
|
|
|
// if it's the initial check, we'll set changed to false
|
|
initialCheck := !s.checked
|
|
if initialCheck {
|
|
s.checked = true
|
|
changed = false
|
|
}
|
|
|
|
if initialCheck {
|
|
s.onInitialCheck(s)
|
|
} else if changed {
|
|
s.onStateChange(s)
|
|
}
|
|
|
|
return dhcpTargetState, nil
|
|
}
|
|
|
|
func (s *NetworkInterfaceState) CheckAndUpdateDhcp() error {
|
|
dhcpTargetState, err := s.update()
|
|
if err != nil {
|
|
return ErrorfL(s.l, "failed to update network state", err)
|
|
}
|
|
|
|
switch dhcpTargetState {
|
|
case DhcpTargetStateRenew:
|
|
s.l.Info().Msg("renewing DHCP lease")
|
|
_ = s.dhcpClient.Renew()
|
|
case DhcpTargetStateRelease:
|
|
s.l.Info().Msg("releasing DHCP lease")
|
|
_ = s.dhcpClient.Release()
|
|
case DhcpTargetStateStart:
|
|
s.l.Warn().Msg("dhcpTargetStateStart not implemented")
|
|
case DhcpTargetStateStop:
|
|
s.l.Warn().Msg("dhcpTargetStateStop not implemented")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *NetworkInterfaceState) HandleLinkUpdate(update netlink.LinkUpdate) {
|
|
if update.Link.Attrs().Name == s.interfaceName {
|
|
s.l.Info().Interface("update", update).Msg("interface link update received")
|
|
_ = s.CheckAndUpdateDhcp()
|
|
}
|
|
}
|
|
|
|
func rpcGetNetworkState() RpcNetworkState {
|
|
ipv6Addresses := make([]RpcIPv6Address, 0)
|
|
for _, addr := range networkState.ipv6Addresses {
|
|
ipv6Addresses = append(ipv6Addresses, RpcIPv6Address{
|
|
Address: addr.Prefix.String(),
|
|
ValidLifetime: addr.ValidLifetime,
|
|
PreferredLifetime: addr.PreferredLifetime,
|
|
Scope: addr.Scope,
|
|
})
|
|
}
|
|
return RpcNetworkState{
|
|
InterfaceName: networkState.interfaceName,
|
|
MacAddress: networkState.macAddr.String(),
|
|
IPv4: networkState.ipv4Addr.String(),
|
|
IPv6: networkState.ipv6Addr.String(),
|
|
IPv6LinkLocal: networkState.ipv6LinkLocal.String(),
|
|
IPv4Addresses: networkState.ipv4Addresses,
|
|
IPv6Addresses: ipv6Addresses,
|
|
DHCPLease: networkState.dhcpClient.GetLease(),
|
|
}
|
|
}
|
|
|
|
func rpcGetNetworkSettings() RpcNetworkSettings {
|
|
return RpcNetworkSettings{
|
|
IPv4Mode: "dhcp",
|
|
IPv6Mode: "slaac",
|
|
LLDPMode: "basic",
|
|
LLDPTxTLVs: []string{"chassis", "port", "system", "vlan"},
|
|
MDNSMode: "auto",
|
|
TimeSyncMode: "ntp_and_http",
|
|
}
|
|
}
|
|
|
|
func rpcRenewDHCPLease() error {
|
|
if networkState == nil {
|
|
return fmt.Errorf("network state not initialized")
|
|
}
|
|
if networkState.dhcpClient == nil {
|
|
return fmt.Errorf("dhcp client not initialized")
|
|
}
|
|
|
|
return networkState.dhcpClient.Renew()
|
|
}
|
|
|
|
func initNetwork() {
|
|
ensureConfigLoaded()
|
|
|
|
updates := make(chan netlink.LinkUpdate)
|
|
done := make(chan struct{})
|
|
|
|
if err := netlink.LinkSubscribe(updates, done); err != nil {
|
|
networkLogger.Warn().Err(err).Msg("failed to subscribe to link updates")
|
|
return
|
|
}
|
|
|
|
// TODO: support multiple interfaces
|
|
networkState = NewNetworkInterfaceState(NetIfName)
|
|
go networkState.dhcpClient.Run() // nolint:errcheck
|
|
|
|
if err := networkState.CheckAndUpdateDhcp(); err != nil {
|
|
os.Exit(1)
|
|
}
|
|
|
|
go func() {
|
|
ticker := time.NewTicker(1 * time.Second)
|
|
defer ticker.Stop()
|
|
|
|
for {
|
|
select {
|
|
case update := <-updates:
|
|
networkState.HandleLinkUpdate(update)
|
|
case <-ticker.C:
|
|
_ = networkState.CheckAndUpdateDhcp()
|
|
case <-done:
|
|
return
|
|
}
|
|
}
|
|
}()
|
|
}
|