binary_util.go

// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package vom

import (
	"errors"
	"fmt"
	"math"
	"reflect"
	"unsafe"

	"v.io/v23/vdl"
)

// Binary encoding and decoding routines.

var errInvalid = errors.New("vom: invalid encoding")

func errEndedBeforeVersionByte(err error) error {
	return fmt.Errorf("ended before version byte received: %v", err)
}

func errBadVersionByte(v Version) error {
	return fmt.Errorf("bad version byte: %02x", v)
}

func errMsgLen(l int) error {
	return fmt.Errorf("vom: message larger than %v bytes", l)
}

func errInvalidLenOrControl(first byte) error {
	return fmt.Errorf("vom: invalid len or control byte %02x", first)
}

func errBadControlCode(code byte) error {
	return fmt.Errorf("invalid control code: %02x", code)
}

const (
	uint64Size          = 8
	maxEncodedUintBytes = uint64Size + 1 // +1 for length byte
	maxBinaryMsgLen     = 1 << 30        // 1GiB limit to each message
)

// lenUint returns the number of bytes used to represent the provided
// uint value
func lenUint(v uint64) int {
	switch {
	case v <= 0x7f:
		return 1
	case v <= 0xff:
		return 2
	case v <= 0xffff:
		return 3
	case v <= 0xffffff:
		return 4
	case v <= 0xffffffff:
		return 5
	case v <= 0xffffffffff:
		return 6
	case v <= 0xffffffffffff:
		return 7
	case v <= 0xffffffffffffff:
		return 8
	default:
		return 9
	}
}

func binaryEncodeControl(buf *encbuf, v byte) {
	if v < 0x80 || v > 0xef {
		panic(errBadControlCode(v))
	}
	buf.WriteOneByte(v)
}

// binaryDecodeControlOnly only decodes and advances the read position if the
// next byte is a control byte.  Returns an error if the control byte doesn't
// match want.
func binaryDecodeControlOnly(buf *decbuf, want byte) (bool, error) {
	if !buf.IsAvailable(1) {
		if err := buf.Fill(1); err != nil {
			return false, err
		}
	}
	ctrl := buf.PeekAvailableByte()
	if ctrl < 0x80 || ctrl > 0xef {
		return false, nil // not a control byte
	}
	if ctrl != want {
		return false, errBadControlCode(ctrl)
	}
	buf.SkipAvailable(1)
	return true, nil
}

// binaryPeekControl returns the next byte as a control byte, or 0 if it is not
// a control byte.  Doesn't advance the read position.
func binaryPeekControl(buf *decbuf) (byte, error) {
	if !buf.IsAvailable(1) {
		if err := buf.Fill(1); err != nil {
			return 0, err
		}
	}
	ctrl := buf.PeekAvailableByte()
	if ctrl < 0x80 || ctrl > 0xef {
		return 0, nil
	}
	return ctrl, nil
}

// Bools are encoded as a byte where 0 = false and anything else is true.
func binaryEncodeBool(buf *encbuf, v bool) {
	if v {
		buf.WriteOneByte(1)
	} else {
		buf.WriteOneByte(0)
	}
}

func binaryDecodeBool(buf *decbuf) (bool, error) {
	if !buf.IsAvailable(1) {
		if err := buf.Fill(1); err != nil {
			return false, err
		}
	}
	value := buf.ReadAvailableByte()
	if value > 1 {
		return false, errInvalid // TODO: better error
	}
	return value != 0, nil
}

// Unsigned integers are the basis for all other primitive values.  This is a
// two-state encoding.  If the number is less than 128 (0 through 0x7f), its
// value is written directly.  Otherwise the value is written in big-endian byte
// order preceded by the negated byte length.
func binaryEncodeUint(buf *encbuf, v uint64) {
	switch {
	case v <= 0x7f:
		buf.Grow(1)[0] = byte(v)
	case v <= 0xff:
		buf := buf.Grow(2)
		buf[0] = 0xff
		buf[1] = byte(v)
	case v <= 0xffff:
		buf := buf.Grow(3)
		buf[0] = 0xfe
		buf[1] = byte(v >> 8)
		buf[2] = byte(v)
	case v <= 0xffffff:
		buf := buf.Grow(4)
		buf[0] = 0xfd
		buf[1] = byte(v >> 16)
		buf[2] = byte(v >> 8)
		buf[3] = byte(v)
	case v <= 0xffffffff:
		buf := buf.Grow(5)
		buf[0] = 0xfc
		buf[1] = byte(v >> 24)
		buf[2] = byte(v >> 16)
		buf[3] = byte(v >> 8)
		buf[4] = byte(v)
	case v <= 0xffffffffff:
		buf := buf.Grow(6)
		buf[0] = 0xfb
		buf[1] = byte(v >> 32)
		buf[2] = byte(v >> 24)
		buf[3] = byte(v >> 16)
		buf[4] = byte(v >> 8)
		buf[5] = byte(v)
	case v <= 0xffffffffffff:
		buf := buf.Grow(7)
		buf[0] = 0xfa
		buf[1] = byte(v >> 40)
		buf[2] = byte(v >> 32)
		buf[3] = byte(v >> 24)
		buf[4] = byte(v >> 16)
		buf[5] = byte(v >> 8)
		buf[6] = byte(v)
	case v <= 0xffffffffffffff:
		buf := buf.Grow(8)
		buf[0] = 0xf9
		buf[1] = byte(v >> 48)
		buf[2] = byte(v >> 40)
		buf[3] = byte(v >> 32)
		buf[4] = byte(v >> 24)
		buf[5] = byte(v >> 16)
		buf[6] = byte(v >> 8)
		buf[7] = byte(v)
	default:
		buf := buf.Grow(9)
		buf[0] = 0xf8
		buf[1] = byte(v >> 56)
		buf[2] = byte(v >> 48)
		buf[3] = byte(v >> 40)
		buf[4] = byte(v >> 32)
		buf[5] = byte(v >> 24)
		buf[6] = byte(v >> 16)
		buf[7] = byte(v >> 8)
		buf[8] = byte(v)
	}
}

func binaryDecodeUint(buf *decbuf) (uint64, error) {
	if !buf.IsAvailable(1) {
		if err := buf.Fill(1); err != nil {
			return 0, err
		}
	}
	firstByte := buf.ReadAvailableByte()
	// Handle single-byte encoding.
	if firstByte <= 0x7f {
		return uint64(firstByte), nil
	}
	// Handle multi-byte encoding.
	byteLen := int(-int8(firstByte))
	if byteLen < 1 || byteLen > uint64Size {
		return 0, errInvalidLenOrControl(firstByte)
	}
	if !buf.IsAvailable(byteLen) {
		if err := buf.Fill(byteLen); err != nil {
			return 0, err
		}
	}
	bytes := buf.ReadAvailable(byteLen)
	var uvalue uint64
	for _, b := range bytes {
		uvalue = uvalue<<8 | uint64(b)
	}
	return uvalue, nil
}

func binaryPeekUint(buf *decbuf) (uint64, int, error) {
	if !buf.IsAvailable(1) {
		if err := buf.Fill(1); err != nil {
			return 0, 0, err
		}
	}
	firstByte := buf.PeekAvailableByte()
	// Handle single-byte encoding.
	if firstByte <= 0x7f {
		return uint64(firstByte), 1, nil
	}
	// Handle multi-byte encoding.
	byteLen := int(-int8(firstByte))
	if byteLen < 1 || byteLen > uint64Size {
		return 0, 0, errInvalidLenOrControl(firstByte)
	}
	byteLen++ // account for initial len byte
	if !buf.IsAvailable(byteLen) {
		if err := buf.Fill(byteLen); err != nil {
			return 0, 0, err
		}
	}
	bytes := buf.PeekAvailable(byteLen)
	var uvalue uint64
	for _, b := range bytes[1:] {
		uvalue = uvalue<<8 | uint64(b)
	}
	return uvalue, byteLen, nil
}

func binarySkipUint(buf *decbuf) error {
	if !buf.IsAvailable(1) {
		if err := buf.Fill(1); err != nil {
			return err
		}
	}
	firstByte := buf.PeekAvailableByte()
	// Handle single-byte encoding.
	if firstByte <= 0x7f {
		buf.SkipAvailable(1)
		return nil
	}
	// Handle multi-byte encoding.
	byteLen := int(-int8(firstByte))
	if byteLen < 1 || byteLen > uint64Size {
		return errInvalidLenOrControl(firstByte)
	}
	byteLen++ // account for initial len byte
	if !buf.IsAvailable(byteLen) {
		if err := buf.Fill(byteLen); err != nil {
			return err
		}
	}
	buf.SkipAvailable(byteLen)
	return nil
}

func binaryPeekUintByteLen(buf *decbuf) (int, error) {
	if !buf.IsAvailable(1) {
		if err := buf.Fill(1); err != nil {
			return 0, err
		}
	}
	firstByte := buf.PeekAvailableByte()
	// Handle single-byte encoding.
	if firstByte <= 0x7f {
		return 1, nil
	}
	// Handle multi-byte encoding.
	byteLen := int(-int8(firstByte))
	if byteLen < 1 || byteLen > uint64Size {
		return 0, errInvalidLenOrControl(firstByte)
	}
	return 1 + byteLen, nil
}

func binaryDecodeLen(buf *decbuf) (int, error) {
	ulen, err := binaryDecodeUint(buf)
	switch {
	case err != nil:
		return 0, err
	case ulen > maxBinaryMsgLen:
		return 0, errMsgLen(maxBinaryMsgLen)
	}
	return int(ulen), nil
}

func binaryDecodeLenOrArrayLen(buf *decbuf, t *vdl.Type) (int, error) {
	len, err := binaryDecodeLen(buf)
	if err != nil {
		return 0, err
	}
	if t.Kind() == vdl.Array {
		if len != 0 {
			return 0, errInvalid // TODO(toddw): better error
		}
		return t.Len(), nil
	}
	return len, nil
}

// Signed integers are encoded as unsigned integers, where the low bit says
// whether to complement the other bits to recover the int.
func binaryEncodeInt(buf *encbuf, v int64) {
	var uvalue uint64
	if v < 0 {
		uvalue = uint64(^v<<1) | 1
	} else {
		uvalue = uint64(v << 1)
	}
	binaryEncodeUint(buf, uvalue)
}

func binaryDecodeInt(buf *decbuf) (int64, error) {
	if !buf.IsAvailable(1) {
		if err := buf.Fill(1); err != nil {
			return 0, err
		}
	}
	firstByte := buf.ReadAvailableByte()
	// Handle single-byte encoding.
	if firstByte <= 0x7f {
		if firstByte&1 == 1 {
			return ^int64(firstByte >> 1), nil
		}
		return int64(firstByte >> 1), nil
	}
	// Handle multi-byte encoding.
	byteLen := int(-int8(firstByte))
	if byteLen < 1 || byteLen > uint64Size {
		return 0, errInvalidLenOrControl(firstByte)
	}
	if !buf.IsAvailable(byteLen) {
		if err := buf.Fill(byteLen); err != nil {
			return 0, err
		}
	}
	bytes := buf.ReadAvailable(byteLen)
	var uvalue uint64
	for _, b := range bytes {
		uvalue = uvalue<<8 | uint64(b)
	}
	if uvalue&1 == 1 {
		return ^int64(uvalue >> 1), nil
	}
	return int64(uvalue >> 1), nil
}

func binaryPeekInt(buf *decbuf) (int64, int, error) {
	if !buf.IsAvailable(1) {
		if err := buf.Fill(1); err != nil {
			return 0, 0, err
		}
	}
	firstByte := buf.PeekAvailableByte()
	// Handle single-byte encoding.
	if firstByte <= 0x7f {
		if firstByte&1 == 1 {
			return ^int64(firstByte >> 1), 1, nil
		}
		return int64(firstByte >> 1), 1, nil
	}
	// Handle multi-byte encoding.
	byteLen := int(-int8(firstByte))
	if byteLen < 1 || byteLen > uint64Size {
		return 0, 0, errInvalidLenOrControl(firstByte)
	}
	byteLen++ // account for initial len byte
	if !buf.IsAvailable(byteLen) {
		if err := buf.Fill(byteLen); err != nil {
			return 0, 0, err
		}
	}
	bytes := buf.PeekAvailable(byteLen)
	var uvalue uint64
	for _, b := range bytes[1:] {
		uvalue = uvalue<<8 | uint64(b)
	}
	if uvalue&1 == 1 {
		return ^int64(uvalue >> 1), byteLen, nil
	}
	return int64(uvalue >> 1), byteLen, nil
}

// Floating point numbers are encoded as byte-reversed ieee754.
func binaryEncodeFloat(buf *encbuf, v float64) {
	ieee := math.Float64bits(v)
	// Manually-unrolled byte-reversing.
	uvalue := (ieee&0xff)<<56 |
		(ieee&0xff00)<<40 |
		(ieee&0xff0000)<<24 |
		(ieee&0xff000000)<<8 |
		(ieee&0xff00000000)>>8 |
		(ieee&0xff0000000000)>>24 |
		(ieee&0xff000000000000)>>40 |
		(ieee&0xff00000000000000)>>56
	binaryEncodeUint(buf, uvalue)
}

func binaryDecodeFloat(buf *decbuf) (float64, error) {
	uvalue, err := binaryDecodeUint(buf)
	if err != nil {
		return 0, err
	}
	// Manually-unrolled byte-reversing.
	ieee := (uvalue&0xff)<<56 |
		(uvalue&0xff00)<<40 |
		(uvalue&0xff0000)<<24 |
		(uvalue&0xff000000)<<8 |
		(uvalue&0xff00000000)>>8 |
		(uvalue&0xff0000000000)>>24 |
		(uvalue&0xff000000000000)>>40 |
		(uvalue&0xff00000000000000)>>56
	return math.Float64frombits(ieee), nil
}

// Strings are encoded as the byte count followed by uninterpreted bytes.
func binaryEncodeString(buf *encbuf, s string) {
	binaryEncodeUint(buf, uint64(len(s)))
	buf.WriteString(s)
}

func binaryDecodeString(buf *decbuf) (s string, err error) {
	len, err := binaryDecodeLen(buf)
	if len == 0 || err != nil {
		return
	}
	data := make([]byte, len)
	if err = buf.ReadIntoBuf(data); err != nil {
		return
	}
	// Go makes an extra copy if we simply perform the conversion string(data), so
	// we use unsafe to transfer the contents from data into s without a copy.
	p := (*reflect.StringHeader)(unsafe.Pointer(&s))
	p.Data = uintptr(unsafe.Pointer(&data[0]))
	p.Len = len
	return
}

func binarySkipString(buf *decbuf) error {
	len, err := binaryDecodeLen(buf)
	if err != nil {
		return err
	}
	return buf.Skip(len)
}

// binaryEncodeUintEnd writes into the trailing part of buf and returns the start
// index of the encoded data.
//
// REQUIRES: buf is big enough to hold the encoded value.
func binaryEncodeUintEnd(buf []byte, v uint64) int {
	end := len(buf) - 1
	switch {
	case v <= 0x7f:
		buf[end] = byte(v)
		return end
	case v <= 0xff:
		buf[end-1] = 0xff
		buf[end] = byte(v)
		return end - 1
	case v <= 0xffff:
		buf[end-2] = 0xfe
		buf[end-1] = byte(v >> 8)
		buf[end] = byte(v)
		return end - 2
	case v <= 0xffffff:
		buf[end-3] = 0xfd
		buf[end-2] = byte(v >> 16)
		buf[end-1] = byte(v >> 8)
		buf[end] = byte(v)
		return end - 3
	case v <= 0xffffffff:
		buf[end-4] = 0xfc
		buf[end-3] = byte(v >> 24)
		buf[end-2] = byte(v >> 16)
		buf[end-1] = byte(v >> 8)
		buf[end] = byte(v)
		return end - 4
	case v <= 0xffffffffff:
		buf[end-5] = 0xfb
		buf[end-4] = byte(v >> 32)
		buf[end-3] = byte(v >> 24)
		buf[end-2] = byte(v >> 16)
		buf[end-1] = byte(v >> 8)
		buf[end] = byte(v)
		return end - 5
	case v <= 0xffffffffffff:
		buf[end-6] = 0xfa
		buf[end-5] = byte(v >> 40)
		buf[end-4] = byte(v >> 32)
		buf[end-3] = byte(v >> 24)
		buf[end-2] = byte(v >> 16)
		buf[end-1] = byte(v >> 8)
		buf[end] = byte(v)
		return end - 6
	case v <= 0xffffffffffffff:
		buf[end-7] = 0xf9
		buf[end-6] = byte(v >> 48)
		buf[end-5] = byte(v >> 40)
		buf[end-4] = byte(v >> 32)
		buf[end-3] = byte(v >> 24)
		buf[end-2] = byte(v >> 16)
		buf[end-1] = byte(v >> 8)
		buf[end] = byte(v)
		return end - 7
	default:
		buf[end-8] = 0xf8
		buf[end-7] = byte(v >> 56)
		buf[end-6] = byte(v >> 48)
		buf[end-5] = byte(v >> 40)
		buf[end-4] = byte(v >> 32)
		buf[end-3] = byte(v >> 24)
		buf[end-2] = byte(v >> 16)
		buf[end-1] = byte(v >> 8)
		buf[end] = byte(v)
		return end - 8
	}
}

// binaryEncodeIntEnd writes into the trailing part of buf and returns the start
// index of the encoded data.
//
// REQUIRES: buf is big enough to hold the encoded value.
func binaryEncodeIntEnd(buf []byte, v int64) int {
	var uvalue uint64
	if v < 0 {
		uvalue = uint64(^v<<1) | 1
	} else {
		uvalue = uint64(v << 1)
	}
	return binaryEncodeUintEnd(buf, uvalue)
}