Support serving pxelinux artifacts

examples/boot.go

@@ -47,6 +47,13 @@ func main() {
 		DHCPNoBind: true,
 	}
 
+	/*
+		ret.PxeLinuxAssets = map[string]string{
+			"default": "pxelinux.0",
+		}
+
+	*/
+
 	ret.SetDefaultFirmwares()
 	b, _ := booters.StaticBooter(booterSpec)
 	ret.Booter = b

server/server.go

@@ -41,6 +41,24 @@ type Server struct {
 	// Ipxe lists the supported bootable Firmwares, and their
 	// associated ipxe binary.
 	Ipxe map[constants.Firmware][]byte
+	// PxeLinuxAssets lists the supported map of PxeLinux assets.
+	// It links the mac/default to the pxe config file.
+	// Usually the PxeLinux references are referred by several names, like:
+	// The client UUID, if provided by the PXE stack.
+	//
+	// Note that some BIOSes do not have a valid UUID, and it might end up reporting something like all 1's.
+	// This value is represented in the standard UUID format using lowercase hexadecimal digits, e.g. "b8945908-d6a6-41a9-611d-74a6ab80b83d".
+	//
+	// The hardware type (using its ARP "htype" code) and address, all in lowercase hexadecimal with dash separators
+	// For example, for an Ethernet (i.e. ARP hardware type "1") with address "88:99:AA:BB:CC:DD",
+	//  it would search for the filename "01-88-99-aa-bb-cc-dd".
+	//
+	// The client's own IPv4 address in uppercase hexadecimal, followed by removing hex characters, one at a time, from the end.
+	// For example, "192.168.2.91" → "C0A8025B". Then "C0A8025", "C0A802", "C0A80", "C0A8", "C0A", "C0", "C"
+	//
+	// Lowercase "default" string
+	// This is useful to provide configs for just one client or a group of clients. And have a generic fallback for all other clients.
+	PxeLinuxAssets map[string]string
 
 	// Log receives logs on Pixiecore's operation. If nil, logging
 	// is suppressed.

server/tftp.go

@@ -20,8 +20,8 @@
 	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"net"
+	"os"
 	"strconv"
 	"strings"
 
@@ -63,29 +63,71 @@
 }
 
 func (s *Server) logTFTPTransfer(clientAddr net.Addr, path string, err error) {
-	mac, _, pathErr := extractInfo(path)
-	if pathErr != nil {
-		s.log("TFTP", "unable to extract mac from request:%v", pathErr)
-		return
-	}
-	if err != nil {
-		s.log("TFTP", "Send of %q to %s failed: %s", path, clientAddr, err)
+	if strings.HasPrefix(path, "pxelinux.cfg/") {
+		if err != nil {
+			// debug logging because pxelinux is very noisy as it does a lot of requests
+			s.debug("TFTP", "Send of %q to %s failed: %s", path, clientAddr, err)
+		} else {
+			_, i, _ := extractInfoPxeLinux(path)
+			s.log("TFTP", "Sent %q to %s", i, clientAddr)
+			//s.machineEvent(mac, machineStateTFTP, "Sent Pxelinux asset to %s", clientAddr)
+		}
 	} else {
-		s.log("TFTP", "Sent %q to %s", mac.String(), clientAddr)
-		s.machineEvent(mac, machineStateTFTP, "Sent iPXE to %s", clientAddr)
+		mac, _, pathErr := extractInfo(path)
+		if pathErr != nil {
+			s.log("TFTP", "unable to extract mac from request:%v", pathErr)
+			return
+		}
+		if err != nil {
+			s.log("TFTP", "Send of %q to %s failed: %s", path, clientAddr, err)
+		} else {
+			s.log("TFTP", "Sent %q to %s", mac.String(), clientAddr)
+			s.machineEvent(mac, machineStateTFTP, "Sent iPXE to %s", clientAddr)
+		}
 	}
 }
 
 func (s *Server) handleTFTP(path string, clientAddr net.Addr) (io.ReadCloser, int64, error) {
-	_, i, err := extractInfo(path)
-	if err != nil {
-		return nil, 0, fmt.Errorf("unknown path %q", path)
-	}
+	if strings.HasPrefix(path, "pxelinux.cfg/") {
+		_, i, err := extractInfoPxeLinux(path)
+		if err != nil {
+			return nil, 0, fmt.Errorf("unknown path %q", path)
+		}
+		f, ok := s.PxeLinuxAssets[i]
+		if !ok {
+			return nil, 0, fmt.Errorf("PxeLinux asset not found with key %s", i)
+		}
+		bs, err := os.ReadFile(f)
+		if err != nil {
+			s.log("TFTP", "Failed to read file %q: %s", f, err)
+			return nil, 0, err
+		}
+		return io.NopCloser(bytes.NewBuffer(bs)), int64(len(bs)), nil
+	} else {
+		_, i, err := extractInfo(path)
+		if err != nil {
+			return nil, 0, fmt.Errorf("unknown path %q", path)
+		}
 
-	bs, ok := s.Ipxe[constants.Firmware(i)]
-	if !ok {
-		return nil, 0, fmt.Errorf("unknown firmware type %d", i)
+		bs, ok := s.Ipxe[constants.Firmware(i)]
+		if !ok {
+			return nil, 0, fmt.Errorf("unknown firmware type %d", i)
+		}
+
+		return io.NopCloser(bytes.NewBuffer(bs)), int64(len(bs)), nil
 	}
+}
 
-	return ioutil.NopCloser(bytes.NewBuffer(bs)), int64(len(bs)), nil
+func extractInfoPxeLinux(path string) (net.HardwareAddr, string, error) {
+	var mac net.HardwareAddr
+	pathElements := strings.Split(path, "/")
+	if len(pathElements) != 2 {
+		return nil, "", errors.New("not found")
+	}
+	cleanedMac := strings.Replace(pathElements[1], "01-", "", 1)
+	mac, _ = net.ParseMAC(cleanedMac)
+	// We return:
+	// parsed Mac address if possible
+	// the filename of the pxelinux config requested
+	return mac, pathElements[1], nil
 }