summaryrefslogtreecommitdiff
path: root/pkg
diff options
context:
space:
mode:
Diffstat (limited to 'pkg')
-rw-r--r--pkg/binstruct/binstruct_test.go49
-rw-r--r--pkg/binstruct/l1.go163
-rw-r--r--pkg/binstruct/l2.go156
-rw-r--r--pkg/binstruct/l3.go61
4 files changed, 429 insertions, 0 deletions
diff --git a/pkg/binstruct/binstruct_test.go b/pkg/binstruct/binstruct_test.go
new file mode 100644
index 0000000..33a2f0a
--- /dev/null
+++ b/pkg/binstruct/binstruct_test.go
@@ -0,0 +1,49 @@
+package binstruct_test
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+
+ "lukeshu.com/btrfs-tools/pkg/binstruct"
+)
+
+func TestSmoke(t *testing.T) {
+ type UUID [16]byte
+ type DevItem struct {
+ DeviceID uint64 `bin:"off=0, siz=8, desc=device id"`
+
+ NumBytes uint64 `bin:"off=8, siz=8, desc=number of bytes"`
+ NumBytesUsed uint64 `bin:"off=10, siz=8, desc=number of bytes used"`
+
+ IOOptimalAlign uint32 `bin:"off=18, siz=4, desc=optimal I/O align"`
+ IOOptimalWidth uint32 `bin:"off=1c, siz=4, desc=optimal I/O width"`
+ IOMinSize uint32 `bin:"off=20, siz=4, desc=minimal I/O size (sector size)"`
+
+ Type uint64 `bin:"off=24, siz=8, desc=type"`
+ Generation uint64 `bin:"off=2c, siz=8, desc=generation"`
+ StartOffset uint64 `bin:"off=34, siz=8, desc=start offset"`
+ DevGroup uint32 `bin:"off=3c, siz=4, desc=dev group"`
+ SeekSpeed uint8 `bin:"off=40, siz=1, desc=seek speed"`
+ Bandwidth uint8 `bin:"off=41, siz=1, desc=bandwidth"`
+
+ DevUUID UUID `bin:"off=42, siz=10, desc=device UUID"`
+ FSUUID UUID `bin:"off=52, siz=10, desc=FS UUID"`
+
+ binstruct.End `bin:"off=62"`
+ }
+ type TestType struct {
+ Magic [5]byte `bin:"off=0,siz=5"`
+ Dev DevItem `bin:"off=5,siz=62"`
+
+ binstruct.End `bin:"off=67"`
+ }
+
+ input := TestType{}
+ copy(input.Magic[:], "mAgIc")
+ input.Dev.DeviceID = 12
+
+ bs, err := binstruct.Marshal(input)
+ assert.NoError(t, err)
+ assert.True(t, len(bs) == 0x67, "len(bs)=0x%x", len(bs))
+}
diff --git a/pkg/binstruct/l1.go b/pkg/binstruct/l1.go
new file mode 100644
index 0000000..c535d2e
--- /dev/null
+++ b/pkg/binstruct/l1.go
@@ -0,0 +1,163 @@
+package binstruct
+
+import (
+ "encoding/binary"
+ "fmt"
+ "reflect"
+)
+
+type handler interface {
+ Unmarshal(dat []byte) interface{}
+ Marshal(val interface{}) []byte
+ Size() int64
+}
+
+type primitive struct {
+ unmarshal func(dat []byte) interface{}
+ marshal func(val interface{}) []byte
+ size int64
+}
+
+func (p primitive) Unmarshal(dat []byte) interface{} { return p.unmarshal(dat) }
+func (p primitive) Marshal(val interface{}) []byte { return p.marshal(val) }
+func (p primitive) Size() int64 { return p.size }
+
+var _ handler = primitive{}
+
+func genHandler(typ reflect.Type) (handler, error) {
+ switch typ.Kind() {
+ case reflect.Invalid: // invalid
+ return nil, fmt.Errorf("unsupported kind: %s: %v", typ.Kind(), typ)
+ case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Complex64, reflect.Complex128: // I don't wanna
+ return nil, fmt.Errorf("unsupported kind: %s: %v", typ.Kind(), typ)
+ case reflect.Int, reflect.Uint, reflect.Uintptr: // platform specific
+ return nil, fmt.Errorf("unsupported kind: %s: %v", typ.Kind(), typ)
+ case reflect.Chan, reflect.Func, reflect.Interface, reflect.UnsafePointer: // runtime
+ return nil, fmt.Errorf("unsupported kind: %s: %v", typ.Kind(), typ)
+ case reflect.Map, reflect.Slice, reflect.String: // dynamic size
+ return nil, fmt.Errorf("unsupported kind: %s: %v", typ.Kind(), typ)
+
+ // uint ////////////////////////////////////////////////////////////////
+ case reflect.Uint8:
+ return primitive{
+ unmarshal: func(dat []byte) interface{} { return dat[0] },
+ marshal: func(val interface{}) []byte { return []byte{val.(uint8)} },
+ size: 1,
+ }, nil
+ case reflect.Uint16:
+ return primitive{
+ unmarshal: func(dat []byte) interface{} { return binary.LittleEndian.Uint16(dat) },
+ marshal: func(val interface{}) []byte {
+ var buf [2]byte
+ binary.LittleEndian.PutUint16(buf[:], val.(uint16))
+ return buf[:]
+ },
+ size: 2,
+ }, nil
+ case reflect.Uint32:
+ return primitive{
+ unmarshal: func(dat []byte) interface{} { return binary.LittleEndian.Uint32(dat) },
+ marshal: func(val interface{}) []byte {
+ var buf [4]byte
+ binary.LittleEndian.PutUint32(buf[:], val.(uint32))
+ return buf[:]
+ },
+ size: 4,
+ }, nil
+ case reflect.Uint64:
+ return primitive{
+ unmarshal: func(dat []byte) interface{} { return binary.LittleEndian.Uint64(dat) },
+ marshal: func(val interface{}) []byte {
+ var buf [8]byte
+ binary.LittleEndian.PutUint64(buf[:], val.(uint64))
+ return buf[:]
+ },
+ size: 8,
+ }, nil
+
+ // int /////////////////////////////////////////////////////////////////
+ case reflect.Int8:
+ return primitive{
+ unmarshal: func(dat []byte) interface{} { return int8(dat[0]) },
+ marshal: func(val interface{}) []byte { return []byte{uint8(val.(int8))} },
+ size: 1,
+ }, nil
+ case reflect.Int16:
+ return primitive{
+ unmarshal: func(dat []byte) interface{} { return int16(binary.LittleEndian.Uint16(dat)) },
+ marshal: func(val interface{}) []byte {
+ var buf [2]byte
+ binary.LittleEndian.PutUint16(buf[:], uint16(val.(int16)))
+ return buf[:]
+ },
+ size: 2,
+ }, nil
+ case reflect.Int32:
+ return primitive{
+ unmarshal: func(dat []byte) interface{} { return int32(binary.LittleEndian.Uint32(dat)) },
+ marshal: func(val interface{}) []byte {
+ var buf [4]byte
+ binary.LittleEndian.PutUint32(buf[:], uint32(val.(int32)))
+ return buf[:]
+ },
+ size: 4,
+ }, nil
+ case reflect.Int64:
+ return primitive{
+ unmarshal: func(dat []byte) interface{} { return int64(binary.LittleEndian.Uint64(dat)) },
+ marshal: func(val interface{}) []byte {
+ var buf [8]byte
+ binary.LittleEndian.PutUint64(buf[:], uint64(val.(int64)))
+ return buf[:]
+ },
+ size: 8,
+ }, nil
+
+ // composite ///////////////////////////////////////////////////////////
+
+ case reflect.Ptr:
+ inner, err := getHandler(typ.Elem())
+ if err != nil {
+ return nil, fmt.Errorf("%v: %w", typ, err)
+ }
+ return primitive{
+ unmarshal: func(dat []byte) interface{} {
+ return reflect.ValueOf(inner.Unmarshal(dat)).Addr().Interface()
+ },
+ marshal: func(val interface{}) []byte {
+ return inner.Marshal(reflect.ValueOf(val).Elem().Interface())
+ },
+ size: inner.Size(),
+ }, nil
+ case reflect.Array:
+ inner, err := getHandler(typ.Elem())
+ if err != nil {
+ return nil, fmt.Errorf("%v: %w", typ, err)
+ }
+ return primitive{
+ unmarshal: func(dat []byte) interface{} {
+ val := reflect.Zero(typ)
+ for i := 0; i < typ.Len(); i++ {
+ fmt.Printf("%v[%d]: %v\n", typ, i, val.Index(i))
+ val.Index(i).Set(reflect.ValueOf(inner.Unmarshal(dat[i*int(inner.Size()):])))
+ }
+ return val.Interface()
+ },
+ marshal: func(val interface{}) []byte {
+ _val := reflect.ValueOf(val)
+ var ret []byte
+ for i := 0; i < typ.Len(); i++ {
+ ret = append(ret, inner.Marshal(_val.Index(i).Interface())...)
+ }
+ return ret
+ },
+ size: inner.Size() * int64(typ.Len()),
+ }, nil
+ case reflect.Struct:
+ return genStructHandler(typ)
+
+ // end /////////////////////////////////////////////////////////////////
+ default:
+ panic(fmt.Errorf("unknown kind: %v: %v", typ.Kind(), typ))
+ }
+}
diff --git a/pkg/binstruct/l2.go b/pkg/binstruct/l2.go
new file mode 100644
index 0000000..005d686
--- /dev/null
+++ b/pkg/binstruct/l2.go
@@ -0,0 +1,156 @@
+package binstruct
+
+import (
+ "fmt"
+ "reflect"
+ "strconv"
+ "strings"
+)
+
+type End struct{}
+
+type structHandler struct {
+ typ reflect.Type
+ fields []structField
+ size int64
+}
+
+type structField struct {
+ tag
+ handler
+ name string
+}
+
+func (sh structHandler) Unmarshal(dat []byte) interface{} {
+ val := reflect.Zero(sh.typ)
+ for i, field := range sh.fields {
+ if field.skip {
+ continue
+ }
+ val.Field(i).Set(reflect.ValueOf(field.Unmarshal(dat[field.off:])))
+ }
+ return val.Interface()
+}
+func (sh structHandler) Marshal(_val interface{}) []byte {
+ val := reflect.ValueOf(_val)
+ ret := make([]byte, 0, sh.size)
+ for i, field := range sh.fields {
+ if field.skip {
+ continue
+ }
+ if int64(len(ret)) != field.off {
+ panic(fmt.Errorf("field %d %q: len(ret)=0x%x but field.off=0x%x", i, field.name, len(ret), field.off))
+ }
+ ret = append(ret, field.Marshal(val.Field(i).Interface())...)
+ }
+ return ret
+}
+func (sh structHandler) Size() int64 {
+ return sh.size
+}
+
+var _ handler = structHandler{}
+
+func genStructHandler(structInfo reflect.Type) (handler, error) {
+ ret := structHandler{
+ typ: structInfo,
+ }
+
+ var curOffset, endOffset int64
+ for i := 0; i < structInfo.NumField(); i++ {
+ var fieldInfo reflect.StructField = structInfo.Field(i)
+
+ fieldTag, err := parseStructTag(fieldInfo.Tag.Get("bin"))
+ if err != nil {
+ return nil, fmt.Errorf("%v: field %q: %w",
+ structInfo, fieldInfo.Name, err)
+ }
+ if fieldTag.skip {
+ ret.fields = append(ret.fields, structField{
+ tag: fieldTag,
+ name: fieldInfo.Name,
+ })
+ continue
+ }
+
+ if fieldTag.off != curOffset {
+ err := fmt.Errorf("tag says off=0x%x but curOffset=0x%x", fieldTag.off, curOffset)
+ return nil, fmt.Errorf("%v: field %q: %w",
+ structInfo, fieldInfo.Name, err)
+ }
+ if fieldInfo.Type == reflect.TypeOf(End{}) {
+ endOffset = curOffset
+ }
+
+ fieldHandler, err := getHandler(fieldInfo.Type)
+ if err != nil {
+ return nil, fmt.Errorf("%v: field %q: %w",
+ structInfo, fieldInfo.Name, err)
+ }
+
+ if fieldTag.siz != fieldHandler.Size() {
+ err := fmt.Errorf("tag says siz=0x%x but handler.Size()=0x%x", fieldTag.siz, fieldHandler.Size())
+ return nil, fmt.Errorf("%v: field %q: %w",
+ structInfo, fieldInfo.Name, err)
+ }
+ curOffset += fieldTag.siz
+
+ ret.fields = append(ret.fields, structField{
+ tag: fieldTag,
+ handler: fieldHandler,
+ name: fieldInfo.Name,
+ })
+ }
+ ret.size = curOffset
+
+ if ret.size != endOffset {
+ return nil, fmt.Errorf("%v: .size=%v but endOffset=%v",
+ structInfo, ret.size, endOffset)
+ }
+
+ return ret, nil
+}
+
+type tag struct {
+ skip bool
+
+ off int64
+ siz int64
+ desc string
+}
+
+func parseStructTag(str string) (tag, error) {
+ var ret tag
+ for _, part := range strings.Split(str, ",") {
+ part = strings.TrimSpace(part)
+ if part == "" {
+ continue
+ }
+ if part == "-" {
+ return tag{skip: true}, nil
+ }
+ keyval := strings.SplitN(part, "=", 2)
+ if len(keyval) != 2 {
+ return tag{}, fmt.Errorf("option is not a key=value pair: %q", part)
+ }
+ key := keyval[0]
+ val := keyval[1]
+ switch key {
+ case "off":
+ vint, err := strconv.ParseInt(val, 16, 64)
+ if err != nil {
+ return tag{}, err
+ }
+ ret.off = vint
+ case "siz":
+ vint, err := strconv.ParseInt(val, 16, 64)
+ if err != nil {
+ return tag{}, err
+ }
+ ret.siz = vint
+ case "desc":
+ ret.desc = val
+ }
+ }
+ return ret, nil
+}
diff --git a/pkg/binstruct/l3.go b/pkg/binstruct/l3.go
new file mode 100644
index 0000000..f9fb8b1
--- /dev/null
+++ b/pkg/binstruct/l3.go
@@ -0,0 +1,61 @@
+package binstruct
+
+import (
+ "fmt"
+ "reflect"
+)
+
+var handlerCache = make(map[reflect.Type]handler)
+
+func getHandler(typ reflect.Type) (handler, error) {
+ h, ok := handlerCache[typ]
+ if ok {
+ return h, nil
+ }
+
+ h, err := genHandler(typ)
+ if err != nil {
+ return nil, err
+ }
+ handlerCache[typ] = h
+ return h, nil
+}
+
+func Unmarshal(dat []byte, dst interface{}) error {
+ _dst := reflect.ValueOf(dst)
+ if _dst.Kind() != reflect.Ptr {
+ return fmt.Errorf("not a pointer: %v", _dst.Type())
+ }
+ handler, err := getHandler(_dst.Type().Elem())
+ if err != nil {
+ return err
+ }
+ if int64(len(dat)) < handler.Size() {
+ return fmt.Errorf("need at least %d bytes of data, only have %d",
+ handler.Size(), len(dat))
+ }
+ val := handler.Unmarshal(dat[:handler.Size()])
+ _dst.Elem().Set(reflect.ValueOf(val))
+ return nil
+}
+
+func Marshal(val interface{}) ([]byte, error) {
+ handler, err := getHandler(reflect.TypeOf(val))
+ if err != nil {
+ return nil, err
+ }
+ bs := handler.Marshal(val)
+ if int64(len(bs)) != handler.Size() {
+ return nil, fmt.Errorf("got %d bytes but expected %d bytes",
+ len(bs), handler.Size())
+ }
+ return bs, nil
+}
+
+func Size(val interface{}) (int64, error) {
+ handler, err := getHandler(reflect.TypeOf(val))
+ if err != nil {
+ return 0, err
+ }
+ return handler.Size(), nil
+}
generated by cgit v1.2.3-2-g168b (git 2.25.1) at 2025-03-16 17:58:01 +0000