wip

1 files changed, 240 insertions, 0 deletions

diff --git a/rrdformat/rrdbinary/unmarshal.go b/rrdformat/rrdbinary/unmarshal.go
new file mode 100644
index 0000000..be0b492
--- /dev/null
+++ b/rrdformat/rrdbinary/unmarshal.go
@@ -0,0 +1,240 @@
+package rrdbinary
+
+import (
+	"bytes"
+	"fmt"
+	"math"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+func Unmarshal(arch Architecture, data []byte, ptr interface{}) error {
+	ptrValue := reflect.ValueOf(ptr)
+	if ptrValue.Kind() != reflect.Ptr {
+		return typeErrorf("ptr is a %v, not a pointer", ptrValue.Kind())
+	}
+	decoder := &unmarshaler{
+		arch: arch,
+		pos:  0,
+		data: data,
+	}
+	return decoder.unmarshal(ptrValue, "")
+}
+
+type unmarshaler struct {
+	arch Architecture
+	pos  int
+	data []byte
+}
+
+func (d *unmarshaler) binError(ctxLen int, msg string) error {
+	return newBinError(msg, d.data, d.pos, ctxLen)
+}
+
+func (d *unmarshaler) binErrorf(ctxLen int, format string, a ...interface{}) error {
+	return d.binError(ctxLen, fmt.Sprintf(format, a...))
+}
+
+func (d *unmarshaler) unmarshal(v reflect.Value, tag string) error {
+	switch v.Type() {
+	case reflect.TypeOf(String("")):
+		return d.unmarshalString(v, tag)
+	case reflect.TypeOf(Float(0)):
+		return d.unmarshalFloat(v, tag)
+	case reflect.TypeOf(Uint(0)):
+		return d.unmarshalUint(v, tag)
+	case reflect.TypeOf(Unival(0)):
+		return d.unmarshalUnival(v, tag)
+	default:
+		switch v.Type().Kind() {
+		case reflect.Struct:
+			return d.unmarshalStruct(v, tag)
+		case reflect.Array:
+			return d.unmarshalArray(v, tag)
+		default:
+			return typeErrorf("invalid type for rrdbinary.Unmarshal: %v", v.Type())
+		}
+	}
+}
+
+func (d *unmarshaler) unmarshalStruct(v reflect.Value, tag string) error {
+	panicUnless(v.Kind() == reflect.Struct)
+	panicUnless(v.CanSet())
+
+	if tag != "" {
+		return typeErrorf("invalid rrdbinary struct tag for struct: %q", tag)
+	}
+
+	for i := 0; i < v.NumField(); i++ {
+		fieldInfo := v.Type().Field(i)
+		tag := fieldInfo.Tag.Get("rrdbinary")
+		if tag == "-" {
+			continue
+		}
+		if err := d.unmarshal(v.Field(i), tag); err != nil {
+			return fmt.Errorf("field %s: %w", fieldInfo.Name, err)
+		}
+	}
+	return nil
+}
+
+func (d *unmarshaler) unmarshalArray(v reflect.Value, tag string) error {
+	panicUnless(v.Kind() == reflect.Array)
+	panicUnless(v.CanSet())
+
+	for i := 0; i < v.Len(); i++ {
+		if err := d.unmarshal(v.Index(i), tag); err != nil {
+			return fmt.Errorf("index %d: %w", i, err)
+		}
+	}
+	return nil
+}
+
+func (d *unmarshaler) unmarshalString(v reflect.Value, tag string) error {
+	panicUnless(v.Type() == reflect.TypeOf(String("")))
+	panicUnless(v.CanSet())
+
+	size := 0
+	switch {
+	case tag == "":
+		// do nothing
+	case strings.HasPrefix(tag, "size="):
+		var err error
+		size, err = strconv.Atoi(strings.TrimPrefix(tag, "size="))
+		if err != nil {
+			return typeErrorf("invalid rrdbinary struct tag for string: %q", tag)
+		}
+	default:
+		return typeErrorf("invalid rrdbinary struct tag for string: %q", tag)
+	}
+
+	data := d.data[d.pos:]
+	if size > 0 {
+		if len(data) < size {
+			return d.binErrorf(size, "unexpected end-of-file in %d-byte string", size)
+		}
+		data = data[:size]
+	}
+
+	nul := bytes.IndexByte(data, 0)
+	if nul < 0 {
+		if size > 0 {
+			return d.binErrorf(size, "missing null-terminator on %d-byte string", size)
+		} else {
+			return d.binErrorf(16, "unexpected end-of-file looking for null-terminator on string")
+		}
+	}
+
+	if size > 0 {
+		for _, byte := range data[nul:] {
+			if byte != 0 {
+				return d.binErrorf(size, "garbage data after null-terminator on fixed %d-byte string", size)
+			}
+		}
+	} else {
+		size = nul + 1
+	}
+
+	v.SetString(string(data[:nul]))
+	d.pos += size
+	return nil
+}
+
+func (d *unmarshaler) unmarshalFloat(v reflect.Value, tag string) error {
+	panicUnless(v.Type() == reflect.TypeOf(Float(0)))
+	panicUnless(v.CanSet())
+
+	if d.arch.FloatWidth != 8 {
+		return archErrorf("rrdbinary does not support FloatWidth=%d; only supports 8", d.arch.FloatWidth)
+	}
+	if tag != "" {
+		return typeErrorf("invalid rrdbinary struct tag for float: %q", tag)
+	}
+
+	data := d.data[d.pos:]
+
+	padding := 0
+	if d.pos%d.arch.FloatAlign != 0 {
+		padding = d.arch.FloatAlign - (d.pos % d.arch.FloatAlign)
+	}
+	if len(data) < padding {
+		return d.binErrorf(padding+d.arch.FloatWidth, "unexpected end-of-file in %d-byte padding-before-float", padding)
+	}
+	data = data[padding:]
+
+	if len(data) < d.arch.FloatWidth {
+		return d.binErrorf(d.arch.FloatWidth, "unexpected end-of-file in %d-byte float", d.arch.FloatWidth)
+	}
+
+	v.SetFloat(math.Float64frombits(d.arch.ByteOrder.Uint64(data)))
+	d.pos += padding + d.arch.FloatWidth
+	return nil
+}
+
+func (d *unmarshaler) unmarshalUint(v reflect.Value, tag string) error {
+	panicUnless(v.Type() == reflect.TypeOf(Uint(0)))
+	panicUnless(v.CanSet())
+
+	if d.arch.UintWidth != 4 && d.arch.UintWidth != 8 {
+		return archErrorf("rrdbinary does not support UintWidth=%d; only supports 4 or 8", d.arch.UintWidth)
+	}
+	if tag != "" {
+		return typeErrorf("invalid rrdbinary struct tag for uint: %q", tag)
+	}
+
+	data := d.data[d.pos:]
+
+	padding := 0
+	if d.pos%d.arch.UintAlign != 0 {
+		padding = d.arch.UintAlign - (d.pos % d.arch.UintAlign)
+	}
+	if len(data) < padding {
+		return d.binErrorf(padding+d.arch.UintWidth, "unexpected end-of-file in %d-byte padding-before-uint", padding)
+	}
+	data = data[padding:]
+
+	if len(data) < d.arch.UintWidth {
+		return d.binErrorf(d.arch.UintWidth, "unexpected end-of-file in %d-byte uint", d.arch.UintWidth)
+	}
+
+	switch d.arch.UintWidth {
+	case 4:
+		v.SetUint(uint64(d.arch.ByteOrder.Uint32(data)))
+	case 8:
+		v.SetUint(d.arch.ByteOrder.Uint64(data))
+	}
+	d.pos += padding + d.arch.UintWidth
+	return nil
+}
+
+func (d *unmarshaler) unmarshalUnival(v reflect.Value, tag string) error {
+	panicUnless(v.Type() == reflect.TypeOf(Unival(0)))
+	panicUnless(v.CanSet())
+
+	if d.arch.UnivalWidth != 8 {
+		return archErrorf("rrdbinary does not support UnivalWidth=%d; only supports 8", d.arch.UnivalWidth)
+	}
+	if tag != "" {
+		return typeErrorf("invalid rrdbinary struct tag for unival: %q", tag)
+	}
+
+	data := d.data[d.pos:]
+
+	padding := 0
+	if d.pos%d.arch.UnivalAlign != 0 {
+		padding = d.arch.UnivalAlign - (d.pos % d.arch.UnivalAlign)
+	}
+	if len(data) < padding {
+		return d.binErrorf(padding+d.arch.UnivalWidth, "unexpected end-of-file in %d-byte padding-before-unival", padding)
+	}
+	data = data[padding:]
+
+	if len(data) < d.arch.UnivalWidth {
+		return d.binErrorf(d.arch.UnivalWidth, "unexpected end-of-file in %d-byte unival", d.arch.UnivalWidth)
+	}
+
+	v.SetUint(d.arch.ByteOrder.Uint64(data))
+	d.pos += padding + d.arch.UnivalWidth
+	return nil
+}