Marshaling out

.github/workflows/go.yml

@@ -47,19 +47,8 @@ jobs:
     strategy:
       matrix:
         go-version: ['1.21.x', '1.22.x']
-        vmarch: [ 'amd64', 'arm64', 'riscv64' ]
+        vmarch: [ 'amd64' ]
         goarm: ['']
-        include:
-          # QEMU arm -M virt seems to support only v5. GOARM default as of 1.21
-          # is v7.
-          - go-version: '1.21.x'
-            vmarch: 'arm'
-            goarm: '5'
-          # QEMU arm -M virt seems to support only v5. GOARM default as of 1.21
-          # is v7.
-          - go-version: '1.22.x'
-            vmarch: 'arm'
-            goarm: '5'
 
     env:
       VMTEST_ARCH: ${{ matrix.vmarch }}

dmidecode/struct_parser.go

@@ -5,25 +5,37 @@
 package dmidecode
 
 import (
+	"errors"
 	"fmt"
 	"io"
+	"math"
 	"reflect"
 	"strconv"
 	"strings"
 
 	"github.com/u-root/smbios"
 )
 
+// Generic errors.
+var (
+	ErrInvalidArg = errors.New("invalid argument")
+)
+
 // We need this for testing.
 type parseStructure func(t *smbios.Table, off int, complete bool, sp interface{}) (int, error)
 
 type fieldParser interface {
 	ParseField(t *smbios.Table, off int) (int, error)
 }
 
+type fieldWriter interface {
+	WriteField(t *smbios.Table) (int, error)
+}
+
 var (
 	fieldTagKey              = "smbios" // Tag key for annotations.
 	fieldParserInterfaceType = reflect.TypeOf((*fieldParser)(nil)).Elem()
+	fieldWriterInterfaceType = reflect.TypeOf((*fieldWriter)(nil)).Elem()
 )
 
 func parseStruct(t *smbios.Table, off int, complete bool, sp interface{}) (int, error) {
@@ -49,9 +61,6 @@
 			switch tp[0] {
 			case "-":
 				ignore = true
-			case "skip":
-				numBytes, _ := strconv.Atoi(tp[1])
-				off += numBytes
 			}
 		}
 		if ignore {
@@ -83,6 +92,11 @@
 			v, _ := t.GetStringAt(off)
 			fv.SetString(v)
 			off++
+		case reflect.Array:
+			v, err := t.GetBytesAt(off, fv.Len())
+			reflect.Copy(fv, reflect.ValueOf(v))
+			verr = err
+			off += fv.Len()
 		default:
 			if reflect.PtrTo(ft).Implements(fieldParserInterfaceType) {
 				off, err = fv.Addr().Interface().(fieldParser).ParseField(t, off)
@@ -125,9 +139,6 @@
 			switch tp[0] {
 			case "-":
 				ignore = true
-			case "skip":
-				numBytes, _ := strconv.Atoi(tp[1])
-				off += numBytes
 			case "default":
 				defValue, _ = strconv.ParseUint(tp[1], 0, 64)
 			}
@@ -139,6 +150,10 @@
 		case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
 			fv.SetUint(defValue)
 			off += int(ft.Size())
+
+		case reflect.Array:
+			return off, fmt.Errorf("%w: array does not support default values", ErrInvalidArg)
+
 		case reflect.Struct:
 			off, err := parseStruct(t, off, false /* complete */, fv)
 			if err != nil {
@@ -149,3 +164,99 @@
 
 	return off, nil
 }
+
+// Table is an SMBIOS table.
+type Table interface {
+	Typ() smbios.TableType
+}
+
+const headerLen = 4
+
+// ToTable converts a struct to an smbios.Table.
+func ToTable(val Table, handle uint16) (*smbios.Table, error) {
+	t := smbios.Table{
+		Header: smbios.Header{
+			Type:   val.Typ(),
+			Handle: handle,
+		},
+	}
+	m, err := toTable(&t, val)
+	if err != nil {
+		return nil, err
+	}
+	if m+headerLen > math.MaxUint8 {
+		return nil, fmt.Errorf("%w: table is too long, got %d bytes, max is 256", ErrInvalidArg, m+headerLen)
+	}
+	t.Length = uint8(m + headerLen)
+	return &t, nil
+}
+
+func toTable(t *smbios.Table, sp any) (int, error) {
+	sv, ok := sp.(reflect.Value)
+	if !ok {
+		sv = reflect.Indirect(reflect.ValueOf(sp)) // must be a pointer to struct then, dereference it
+	}
+	svtn := sv.Type().Name()
+
+	n := 0
+	for i := 0; i < sv.NumField(); i++ {
+		f := sv.Type().Field(i)
+		fv := sv.Field(i)
+		ft := fv.Type()
+		tags := f.Tag.Get(fieldTagKey)
+		// Check tags first
+		ignore := false
+		for _, tag := range strings.Split(tags, ",") {
+			tp := strings.Split(tag, "=")
+			switch tp[0] { //nolint
+			case "-":
+				ignore = true
+			}
+		}
+		if ignore {
+			continue
+		}
+		// fieldWriter takes precedence.
+		if reflect.PtrTo(ft).Implements(fieldWriterInterfaceType) {
+			m, err := fv.Addr().Interface().(fieldWriter).WriteField(t)
+			n += m
+			if err != nil {
+				return n, err
+			}
+			continue
+		}
+
+		var verr error
+		switch fv.Kind() {
+		case reflect.Uint8:
+			t.WriteByte(uint8(fv.Uint()))
+			n++
+		case reflect.Uint16:
+			t.WriteWord(uint16(fv.Uint()))
+			n += 2
+		case reflect.Uint32:
+			t.WriteDWord(uint32(fv.Uint()))
+			n += 4
+		case reflect.Uint64:
+			t.WriteQWord(fv.Uint())
+			n += 8
+		case reflect.String:
+			t.WriteString(fv.String())
+			n++
+		case reflect.Array:
+			t.WriteBytes(fv.Slice(0, fv.Len()).Bytes())
+			n += fv.Len()
+		case reflect.Struct:
+			var m int
+			// If it's a struct, just invoke toTable recursively.
+			m, verr = toTable(t, fv)
+			n += m
+		default:
+			return n, fmt.Errorf("%s.%s: unsupported type %s", svtn, f.Name, fv.Kind())
+		}
+		if verr != nil {
+			return n, fmt.Errorf("failed to parse %s.%s: %w", svtn, f.Name, verr)
+		}
+	}
+	return n, nil
+}