network add: enable adding DHCP hosts

This makes it possible to add DHCP hosts entries directly to a new
network.  At least in an Ubuntu Focal server environment, this performs
much better than adding a network and then adding hosts entries.

Author: JoelColledge

cmd/network_add.go

@@ -1,22 +1,29 @@
 package cmd
 
 import (
+	"fmt"
+	"net"
+
 	libvirtxml "github.com/libvirt/libvirt-go-xml"
 	log "github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
-	"net"
+
+	"github.com/LINBIT/virter/internal/virter"
 )
 
 func networkAddCommand() *cobra.Command {
 	var forward string
 	var dhcp bool
+	var dhcpMAC string
+	var dhcpID uint
+	var dhcpCount uint
 	var network string
 	var domain string
 
 	addCmd := &cobra.Command{
 		Use:   "add <name>",
 		Short: "Add a new network",
-		Long:  `Add a new network. VMs can be attached to such a network in addition to the default network used by virter.`,
+		Long:  `Add a new network. VMs can be attached to such a network in addition to the default network used by virter. DHCP entries can be added directly to the new network.`,
 		Args:  cobra.ExactArgs(1),
 		Run: func(cmd *cobra.Command, args []string) {
 			v, err := InitVirter()
@@ -41,13 +48,7 @@ func networkAddCommand() *cobra.Command {
 
 				var dhcpDesc *libvirtxml.NetworkDHCP
 				if dhcp {
-					start := nextIP(ip)
-					end := previousIP(broadcastAddress(n))
-
-					n.Network()
-					dhcpDesc = &libvirtxml.NetworkDHCP{
-						Ranges: []libvirtxml.NetworkDHCPRange{{Start: start.String(), End: end.String()}},
-					}
+					dhcpDesc = buildNetworkDHCP(ip, n, dhcpMAC, dhcpID, dhcpCount)
 				}
 
 				addressesDesc = append(addressesDesc, libvirtxml.NetworkIP{
@@ -82,10 +83,43 @@ func networkAddCommand() *cobra.Command {
 	addCmd.Flags().StringVarP(&forward, "forward-mode", "m", "", "Set the forward mode, for example 'nat'")
 	addCmd.Flags().StringVarP(&network, "network-cidr", "n", "", "Configure the network range (IPv4) in CIDR notation. The IP will be assigned to the host device.")
 	addCmd.Flags().BoolVarP(&dhcp, "dhcp", "p", false, "Configure DHCP. Use together with '--network-cidr'. DHCP range is configured starting from --network-cidr+1 until the broadcast address")
+	addCmd.Flags().StringVarP(&dhcpMAC, "dhcp-mac", "", virter.QemuBaseMAC().String(), "Base MAC address to which ID is added. The default can be used to populate a virter access network")
+	addCmd.Flags().UintVarP(&dhcpID, "dhcp-id", "", 0, "ID which determines the MAC and IP addresses to associate")
+	addCmd.Flags().UintVar(&dhcpCount, "dhcp-count", 0, "Number of host entries to add")
 	addCmd.Flags().StringVarP(&domain, "domain", "d", "", "Configure DNS names for the network")
 	return addCmd
 }
 
+func buildNetworkDHCP(ip net.IP, n *net.IPNet, dhcpMAC string, dhcpID uint, dhcpCount uint) *libvirtxml.NetworkDHCP {
+	start := nextIP(ip)
+	end := previousIP(broadcastAddress(n))
+
+	baseMAC, err := net.ParseMAC(dhcpMAC)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	networkBaseIP := ip.Mask(n.Mask)
+	hosts := make([]libvirtxml.NetworkDHCPHost, dhcpCount)
+	for i := uint(0); i < dhcpCount; i++ {
+		id := dhcpID + i
+		mac, err := virter.AddToMAC(baseMAC, id)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		hosts[i] = libvirtxml.NetworkDHCPHost{
+			MAC: mac.String(),
+			IP:  fmt.Sprint(virter.AddToIP(networkBaseIP, id)),
+		}
+	}
+
+	return &libvirtxml.NetworkDHCP{
+		Ranges: []libvirtxml.NetworkDHCPRange{{Start: start.String(), End: end.String()}},
+		Hosts:  hosts,
+	}
+}
+
 func nextIP(ip net.IP) net.IP {
 	dup := make(net.IP, len(ip))
 	copy(dup, ip)

internal/virter/dhcp.go

@@ -2,6 +2,7 @@ package virter
 
 import (
 	"fmt"
+	"math/big"
 	"net"
 	"os/exec"
 
@@ -27,7 +28,7 @@ func (v *Virter) AddDHCPHost(mac string, id uint) error {
 	}
 
 	networkBaseIP := ipNet.IP.Mask(ipNet.Mask)
-	ip := addToIP(networkBaseIP, id)
+	ip := AddToIP(networkBaseIP, id)
 
 	if !ipNet.Contains(ip) {
 		return fmt.Errorf("computed IP %v is not in network", ip)
@@ -85,7 +86,7 @@ func (v *Virter) getDomainSuffix() (string, error) {
 	return net.Domain.Name, nil
 }
 
-func addToIP(ip net.IP, addend uint) net.IP {
+func AddToIP(ip net.IP, addend uint) net.IP {
 	i := ip.To4()
 	v := uint(i[0])<<24 + uint(i[1])<<16 + uint(i[2])<<8 + uint(i[3])
 	v += addend
@@ -113,10 +114,39 @@ func ipToID(ipnet net.IPNet, ip net.IP) (uint, error) {
 
 // QemuMAC calculates a MAC address for a given id
 func QemuMAC(id uint) string {
-	id0 := byte((id >> 16) & 0xFF)
-	id1 := byte((id >> 8) & 0xFF)
-	id2 := byte(id & 0xFF)
-	return fmt.Sprintf("52:54:00:%02x:%02x:%02x", id0, id1, id2)
+	mac, err := AddToMAC(QemuBaseMAC(), id)
+	if err != nil {
+		// Should never happen because "id" should never exceed 32 bits
+		// and any 32 bit value can be added to the QEMU base MAC.
+		panic(fmt.Sprintf("failed to construct QEMU MAC: %v", err))
+	}
+
+	return mac.String()
+}
+
+func QemuBaseMAC() net.HardwareAddr {
+	mac, err := net.ParseMAC("52:54:00:00:00:00")
+	if err != nil {
+		panic("failed to parse hardcoded MAC address")
+	}
+
+	return mac
+}
+
+func AddToMAC(mac net.HardwareAddr, addend uint) (net.HardwareAddr, error) {
+	var value big.Int
+	value.SetBytes(mac)
+	value.Add(&value, big.NewInt(int64(addend)))
+
+	valueBytes := value.Bytes()
+	if len(valueBytes) > len(mac) {
+		return net.HardwareAddr{}, fmt.Errorf("overflow adding %d to %v", addend, mac)
+	}
+
+	// zero-pad bytes
+	out := make([]byte, len(mac))
+	copy(out[len(out)-len(valueBytes):], valueBytes)
+	return out, nil
 }
 
 func (v *Virter) getIPNet(network libvirt.Network) (net.IPNet, error) {