Convert structs to SMBIOS tables

Signed-off-by: Chris Koch <[email protected]>

dmidecode/struct_parser.go

@@ -21,9 +21,14 @@ 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) {
@@ -148,3 +153,76 @@ func parseStruct(t *smbios.Table, off int, complete bool, sp interface{}) (int,
 
 	return off, nil
 }
+
+func toTable(t *smbios.Table, sp interface{}) (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()
+
+	//fmt.Printf("toTable t %s\n", svtn)
+
+	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)
+		//fmt.Printf("toTable XX %02Xh f %s t %s k %s %s\n", n, f.Name, f.Type.Name(), fv.Kind(), tags)
+		// Check tags first
+		ignore := false
+		for _, tag := range strings.Split(tags, ",") {
+			tp := strings.Split(tag, "=")
+			switch tp[0] {
+			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(uint64(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
+}

dmidecode/struct_parser_test.go

@@ -185,5 +185,63 @@ func TestParseStructWithTPMDevice(t *testing.T) {
 			}
 		})
 	}
+}
 
+func TestToTable(t *testing.T) {
+	type foobar struct {
+		Foo uint8 `smbios:"default=0xe"`
+	}
+	type someStruct struct {
+		Off0  uint64
+		Off8  uint8
+		Off9  string
+		_     uint8 `smbios:"-"`
+		Off10 uint16
+		_     uint8 `smbios:"-"`
+		Off11 uint8 `smbios:"default=0xf"`
+		Off12 foobar
+	}
+
+	for _, tt := range []struct {
+		value any
+		err   error
+		want  *smbios.Table
+	}{
+		{
+			value: &someStruct{
+				Off0:  0x01,
+				Off8:  0xff,
+				Off9:  "foobar",
+				Off10: 0x102,
+				Off11: 0x05,
+				Off12: foobar{
+					Foo: 0xe,
+				},
+			},
+			want: &smbios.Table{
+				Data: []byte{
+					0x1, 0x0, 0x0, 0x0,
+					0x0, 0x0, 0x0, 0x0,
+					0xff,     // Off8
+					0x1,      // Off9
+					0x2, 0x1, // Off10
+					0x5, // Off11
+					0xe, // foobar
+				},
+				Strings: []string{
+					"foobar",
+				},
+			},
+		},
+	} {
+		t.Run("", func(t *testing.T) {
+			got := &smbios.Table{}
+			if _, err := toTable(got, tt.value); !errors.Is(err, tt.err) {
+				t.Errorf("toTable = %v, want %v", err, tt.err)
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("toTable = %v, want %v", got, tt.want)
+			}
+		})
+	}
 }

table.go

@@ -54,6 +54,45 @@ func (t *Table) Len() int {
 	return len(t.Data) + headerLen
 }
 
+// WriteByte writes one byte to the table's data.
+func (t *Table) WriteByte(b uint8) {
+	t.Data = append(t.Data, b)
+}
+
+// WriteWord writes two little endian bytes to the table's data.
+func (t *Table) WriteWord(v uint16) {
+	t.Data = append(t.Data, 0, 0)
+	binary.LittleEndian.PutUint16(t.Data[len(t.Data)-2:], v)
+}
+
+// WriteDWord writes four little endian bytes to the table's data.
+func (t *Table) WriteDWord(v uint32) {
+	t.Data = append(t.Data, 0, 0, 0, 0)
+	binary.LittleEndian.PutUint32(t.Data[len(t.Data)-4:], v)
+}
+
+// WriteQWord writes eight little endian bytes to the table's data.
+func (t *Table) WriteQWord(v uint64) {
+	t.Data = append(t.Data, 0, 0, 0, 0, 0, 0, 0, 0)
+	binary.LittleEndian.PutUint64(t.Data[len(t.Data)-8:], v)
+}
+
+// WriteString writes a string index and appends the string to table.
+func (t *Table) WriteString(s string) {
+	if s == "" {
+		t.WriteByte(0)
+	} else {
+		t.Strings = append(t.Strings, s)
+		// strings are 1-indexed bytes.
+		t.WriteByte(uint8(len(t.Strings)))
+	}
+}
+
+// WriteBytes writes arbitrary bytes to the Table.
+func (t *Table) WriteBytes(v []byte) {
+	t.Data = append(t.Data, v...)
+}
+
 // GetByteAt returns a byte from the structured part at the specified offset.
 func (t *Table) GetByteAt(offset int) (uint8, error) {
 	if offset > len(t.Data)-1 {