values.go

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.

package sml

import (
	"bytes"
	"errors"
	"fmt"
	"io"

	"3e8.eu/go/sml/tlv"
)

const (
	tlEndOfSmlMsg  = 0b00000000
	tlMaskContinue = 0b10000000
	tlMaskType     = 0b01110000
	tlMaskLength   = 0b00001111
)

const (
	tlTypeOctetString = 0b00000000
	tlTypeBoolean     = 0b01000000
	tlTypeInteger     = 0b01010000
	tlTypeUnsigned    = 0b01100000
	tlTypeList        = 0b01110000
	tlTypeContinue    = 0b00000000
)

// ParseValues parses the content of an SML file into its raw TLV values. It returns a list of TLV
// values (which should each correspond to an SML message) or an error.
func ParseValues(data []byte) ([]tlv.Value, error) {
	messages := []tlv.Value{}

	r := bytes.NewReader(data)
	for r.Len() > 0 {
		msg, err := parseNextValue(r)
		if err != nil {
			index := r.Size() - int64(r.Len())
			return []tlv.Value{}, fmt.Errorf("error at index %d: %w", index, err)
		}
		messages = append(messages, msg)
	}

	return messages, nil
}

func parseNextValue(r io.ByteReader) (tlv.Value, error) {
	val, err := r.ReadByte()
	if err != nil {
		return tlv.Value{}, err
	}

	if val == tlEndOfSmlMsg {
		out, _ := tlv.MakeValue(tlv.EndOfSmlMsg, 0, nil)
		return out, nil
	}

	switch val & tlMaskType {
	case tlTypeOctetString, tlTypeBoolean, tlTypeInteger, tlTypeUnsigned, tlTypeList:
	default:
		return tlv.Value{}, fmt.Errorf("unexpected TL field type: %02x", val)
	}

	length := int(val & tlMaskLength)

	tlCount := 1

	if (val & tlMaskContinue) != 0 {
		count, err := parseContinuedLength(&length, r)
		if err != nil {
			return tlv.Value{}, err
		}
		tlCount += count
	}

	out, err := parseActualValue(val, length, tlCount, r)
	if err != nil {
		return tlv.Value{}, err
	}

	return out, nil
}

func parseContinuedLength(length *int, r io.ByteReader) (int, error) {
	maxCount := 3

	for i := 0; i <= maxCount; i++ {
		val, err := r.ReadByte()
		if err != nil {
			return i, err
		}

		if (val & tlMaskType) != tlTypeContinue {
			return i, fmt.Errorf("unexpected continued TL field: %02x", val)
		}

		addLength := int(val & tlMaskLength)
		*length = *length<<4 | addLength

		if (val & tlMaskContinue) == 0 {
			return i + 1, nil
		}
	}

	return maxCount, errors.New("unreasonable continuation of TL field")
}

func parseActualValue(firstVal byte, length, tlCount int, r io.ByteReader) (tlv.Value, error) {
	valLength := length - tlCount

	switch firstVal & tlMaskType {

	case tlTypeOctetString:
		if valLength < 0 {
			return tlv.Value{}, fmt.Errorf("OctetString field with invalid value length %d", valLength)
		}

		buf := make([]byte, valLength)
		for i := range valLength {
			val, err := r.ReadByte()
			if err != nil {
				return tlv.Value{}, err
			}
			buf[i] = val
		}

		return tlv.MakeValue(tlv.OctetString, length, buf)

	case tlTypeBoolean:
		if length != 2 || valLength != 1 {
			return tlv.Value{}, fmt.Errorf("Boolean field with invalid length %d", length)
		}

		val, err := r.ReadByte()
		if err != nil {
			return tlv.Value{}, err
		}

		return tlv.MakeValue(tlv.OctetString, length, val != 0)

	case tlTypeInteger:
		if valLength > 8 {
			return tlv.Value{}, fmt.Errorf("Integer with unsupported value length %d", valLength)
		}

		var intVal int64
		for _ = range valLength {
			val, err := r.ReadByte()
			if err != nil {
				return tlv.Value{}, err
			}
			intVal = intVal<<8 | int64(val)
		}

		return tlv.MakeValue(tlv.Integer, length, intVal)

	case tlTypeUnsigned:
		if valLength > 8 {
			return tlv.Value{}, fmt.Errorf("Unsigned with unsupported value length %d", valLength)
		}

		var uintVal uint64
		for _ = range valLength {
			val, err := r.ReadByte()
			if err != nil {
				return tlv.Value{}, err
			}
			uintVal = uintVal<<8 | uint64(val)
		}

		return tlv.MakeValue(tlv.Unsigned, length, uintVal)

	case tlTypeList:
		list := make([]tlv.Value, length)
		for i := range length {
			val, err := parseNextValue(r)
			if err != nil {
				return tlv.Value{}, err
			}
			list[i] = val
		}

		return tlv.MakeValue(tlv.List, length, list)

	}

	// This should never happen
	return tlv.Value{}, errors.New("unexpected TLV type")
}