add un/marshalling with native endianess and alignment
This commit is contained in:
thediveo
Michael Stapelberg
parent
3e042f75d7
commit
4b6f0f2b44
|
|
@ -0,0 +1,240 @@
|
|||
// Package alignedbuff implements encoding and decoding aligned data elements
|
||||
// to/from buffers in native endianess.
|
||||
package alignedbuff
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"errors"
|
||||
"fmt"
|
||||
"unsafe"
|
||||
|
||||
"github.com/google/nftables/binaryutil"
|
||||
)
|
||||
|
||||
// ErrEOF signals trying to read beyond the available payload information.
|
||||
var ErrEOF = errors.New("not enough data left")
|
||||
|
||||
// AlignedBuff implements marshalling and unmarshalling information in
|
||||
// platform/architecture native endianess and data type alignment. It
|
||||
// additionally covers some of the nftables-xtables translation-specific
|
||||
// idiosyncracies to the extend needed in order to properly marshal and
|
||||
// unmarshal Match and Target expressions, and their Info payload in particular.
|
||||
type AlignedBuff struct {
|
||||
data []byte
|
||||
pos int
|
||||
}
|
||||
|
||||
// New returns a new AlignedBuff for marshalling aligned data in native
|
||||
// endianess.
|
||||
func New() AlignedBuff {
|
||||
return AlignedBuff{}
|
||||
}
|
||||
|
||||
// NewWithData returns a new AlignedBuff for unmarshalling the passed data in
|
||||
// native endianess.
|
||||
func NewWithData(data []byte) AlignedBuff {
|
||||
return AlignedBuff{data: data}
|
||||
}
|
||||
|
||||
// Data returns the properly padded info payload data written before by calling
|
||||
// the various Uint8, Uint16, ... marshalling functions.
|
||||
func (a *AlignedBuff) Data() []byte {
|
||||
// The Linux kernel expects payloads to be padded to the next uint64
|
||||
// alignment.
|
||||
a.alignWrite(uint64AlignMask)
|
||||
return a.data
|
||||
}
|
||||
|
||||
// BytesAligned32 unmarshals the given amount of bytes starting with the native
|
||||
// alignment for uint32 data types. It returns ErrEOF when trying to read beyond
|
||||
// the payload.
|
||||
//
|
||||
// BytesAligned32 is used to unmarshal IP addresses for different IP versions,
|
||||
// which are always aligned the same way as the native alignment for uint32.
|
||||
func (a *AlignedBuff) BytesAligned32(size int) ([]byte, error) {
|
||||
if err := a.alignCheckedRead(uint32AlignMask); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if a.pos > len(a.data)-size {
|
||||
return nil, ErrEOF
|
||||
}
|
||||
data := a.data[a.pos : a.pos+size]
|
||||
a.pos += size
|
||||
return data, nil
|
||||
}
|
||||
|
||||
// Uint8 unmarshals an uint8 in native endianess and alignment. It returns
|
||||
// ErrEOF when trying to read beyond the payload.
|
||||
func (a *AlignedBuff) Uint8() (uint8, error) {
|
||||
if a.pos >= len(a.data) {
|
||||
return 0, ErrEOF
|
||||
}
|
||||
v := a.data[a.pos]
|
||||
a.pos++
|
||||
return v, nil
|
||||
}
|
||||
|
||||
// Uint16 unmarshals an uint16 in native endianess and alignment. It returns
|
||||
// ErrEOF when trying to read beyond the payload.
|
||||
func (a *AlignedBuff) Uint16() (uint16, error) {
|
||||
if err := a.alignCheckedRead(uint16AlignMask); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
v := binaryutil.NativeEndian.Uint16(a.data[a.pos : a.pos+2])
|
||||
a.pos += 2
|
||||
return v, nil
|
||||
}
|
||||
|
||||
// Uint16BE unmarshals an uint16 in "network" (=big endian) endianess and native
|
||||
// uint16 alignment. It returns ErrEOF when trying to read beyond the payload.
|
||||
func (a *AlignedBuff) Uint16BE() (uint16, error) {
|
||||
if err := a.alignCheckedRead(uint16AlignMask); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
v := binaryutil.BigEndian.Uint16(a.data[a.pos : a.pos+2])
|
||||
a.pos += 2
|
||||
return v, nil
|
||||
}
|
||||
|
||||
// Uint32 unmarshals an uint32 in native endianess and alignment. It returns
|
||||
// ErrEOF when trying to read beyond the payload.
|
||||
func (a *AlignedBuff) Uint32() (uint32, error) {
|
||||
if err := a.alignCheckedRead(uint32AlignMask); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
v := binaryutil.NativeEndian.Uint32(a.data[a.pos : a.pos+4])
|
||||
a.pos += 4
|
||||
return v, nil
|
||||
}
|
||||
|
||||
// Uint64 unmarshals an uint64 in native endianess and alignment. It returns
|
||||
// ErrEOF when trying to read beyond the payload.
|
||||
func (a *AlignedBuff) Uint64() (uint64, error) {
|
||||
if err := a.alignCheckedRead(uint64AlignMask); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
v := binaryutil.NativeEndian.Uint64(a.data[a.pos : a.pos+8])
|
||||
a.pos += 8
|
||||
return v, nil
|
||||
}
|
||||
|
||||
// Uint unmarshals an uint in native endianess and alignment for the C "unsigned
|
||||
// int" type. It returns ErrEOF when trying to read beyond the payload. Please
|
||||
// note that on 64bit platforms, the size and alignment of C's and Go's unsigned
|
||||
// integer data types differ, so we encapsulate this difference here.
|
||||
func (a *AlignedBuff) Uint() (uint, error) {
|
||||
switch uintSize {
|
||||
case 2:
|
||||
v, err := a.Uint16()
|
||||
return uint(v), err
|
||||
case 4:
|
||||
v, err := a.Uint32()
|
||||
return uint(v), err
|
||||
case 8:
|
||||
v, err := a.Uint64()
|
||||
return uint(v), err
|
||||
default:
|
||||
panic(fmt.Sprintf("unsupported uint size %d", uintSize))
|
||||
}
|
||||
}
|
||||
|
||||
// PutBytesAligned32 marshals the given bytes starting with the native alignment
|
||||
// for uint32 data types. It additionaly adds padding to reach the specified
|
||||
// size.
|
||||
//
|
||||
// PutBytesAligned32 is used to marshal IP addresses for different IP versions,
|
||||
// which are always aligned the same way as the native alignment for uint32.
|
||||
func (a *AlignedBuff) PutBytesAligned32(data []byte, size int) {
|
||||
a.alignWrite(uint32AlignMask)
|
||||
a.data = append(a.data, data...)
|
||||
a.pos += len(data)
|
||||
if len(data) < size {
|
||||
padding := size - len(data)
|
||||
a.data = append(a.data, bytes.Repeat([]byte{0}, padding)...)
|
||||
a.pos += padding
|
||||
}
|
||||
}
|
||||
|
||||
// PutUint8 marshals an uint8 in native endianess and alignment.
|
||||
func (a *AlignedBuff) PutUint8(v uint8) {
|
||||
a.data = append(a.data, v)
|
||||
a.pos++
|
||||
}
|
||||
|
||||
// PutUint16 marshals an uint16 in native endianess and alignment.
|
||||
func (a *AlignedBuff) PutUint16(v uint16) {
|
||||
a.alignWrite(uint16AlignMask)
|
||||
a.data = append(a.data, binaryutil.NativeEndian.PutUint16(v)...)
|
||||
a.pos += 2
|
||||
}
|
||||
|
||||
// PutUint16BE marshals an uint16 in "network" (=big endian) endianess and
|
||||
// native uint16 alignment.
|
||||
func (a *AlignedBuff) PutUint16BE(v uint16) {
|
||||
a.alignWrite(uint16AlignMask)
|
||||
a.data = append(a.data, binaryutil.BigEndian.PutUint16(v)...)
|
||||
a.pos += 2
|
||||
}
|
||||
|
||||
// PutUint32 marshals an uint32 in native endianess and alignment.
|
||||
func (a *AlignedBuff) PutUint32(v uint32) {
|
||||
a.alignWrite(uint32AlignMask)
|
||||
a.data = append(a.data, binaryutil.NativeEndian.PutUint32(v)...)
|
||||
a.pos += 4
|
||||
}
|
||||
|
||||
// PutUint64 marshals an uint64 in native endianess and alignment.
|
||||
func (a *AlignedBuff) PutUint64(v uint64) {
|
||||
a.alignWrite(uint64AlignMask)
|
||||
a.data = append(a.data, binaryutil.NativeEndian.PutUint64(v)...)
|
||||
a.pos += 8
|
||||
}
|
||||
|
||||
// PutUint marshals an uint in native endianess and alignment for the C
|
||||
// "unsigned int" type. Please note that on 64bit platforms, the size and
|
||||
// alignment of C's and Go's unsigned integer data types differ, so we
|
||||
// encapsulate this difference here.
|
||||
func (a *AlignedBuff) PutUint(v uint) {
|
||||
switch uintSize {
|
||||
case 2:
|
||||
a.PutUint16(uint16(v))
|
||||
case 4:
|
||||
a.PutUint32(uint32(v))
|
||||
case 8:
|
||||
a.PutUint64(uint64(v))
|
||||
default:
|
||||
panic(fmt.Sprintf("unsupported uint size %d", uintSize))
|
||||
}
|
||||
}
|
||||
|
||||
// alignCheckedRead aligns the (read) position if necessary and suitable
|
||||
// according to the specified alignment mask. alignCheckedRead returns an error
|
||||
// if after any necessary alignment there isn't enough data left to be read into
|
||||
// a value of the size corresponding to the specified alignment mask.
|
||||
func (a *AlignedBuff) alignCheckedRead(m int) error {
|
||||
a.pos = (a.pos + m) & ^m
|
||||
if a.pos > len(a.data)-(m+1) {
|
||||
return ErrEOF
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// alignWrite aligns the (write) position if necessary and suitable according to
|
||||
// the specified alignment mask. It doubles as final payload padding helpmate in
|
||||
// order to keep the kernel happy.
|
||||
func (a *AlignedBuff) alignWrite(m int) {
|
||||
pos := (a.pos + m) & ^m
|
||||
if pos != a.pos {
|
||||
a.data = append(a.data, padding[:pos-a.pos]...)
|
||||
a.pos = pos
|
||||
}
|
||||
}
|
||||
|
||||
// This is ... ugly.
|
||||
var uint16AlignMask = int(unsafe.Alignof(uint16(0)) - 1)
|
||||
var uint32AlignMask = int(unsafe.Alignof(uint32(0)) - 1)
|
||||
var uint64AlignMask = int(unsafe.Alignof(uint64(0)) - 1)
|
||||
var padding = bytes.Repeat([]byte{0}, uint64AlignMask)
|
||||
|
||||
// And this even worse.
|
||||
var uintSize = unsafe.Sizeof(uint32(0))
|
||||
|
|
@ -0,0 +1,204 @@
|
|||
package alignedbuff
|
||||
|
||||
import (
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestAlignmentData(t *testing.T) {
|
||||
if uint16AlignMask == 0 {
|
||||
t.Fatal("zero uint16 alignment mask")
|
||||
}
|
||||
if uint32AlignMask == 0 {
|
||||
t.Fatal("zero uint32 alignment mask")
|
||||
}
|
||||
if uint64AlignMask == 0 {
|
||||
t.Fatal("zero uint64 alignment mask")
|
||||
}
|
||||
if len(padding) == 0 {
|
||||
t.Fatal("zero alignment padding sequence")
|
||||
}
|
||||
if uintSize == 0 {
|
||||
t.Fatal("zero uint size")
|
||||
}
|
||||
}
|
||||
|
||||
func TestAlignedBuff8(t *testing.T) {
|
||||
b := NewWithData([]byte{0x42})
|
||||
tests := []struct {
|
||||
name string
|
||||
v uint8
|
||||
err error
|
||||
}{
|
||||
{
|
||||
name: "first read",
|
||||
v: 0x42,
|
||||
err: nil,
|
||||
},
|
||||
{
|
||||
name: "end of buffer",
|
||||
v: 0,
|
||||
err: ErrEOF,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
v, err := b.Uint8()
|
||||
if v != tt.v || err != tt.err {
|
||||
t.Errorf("expected: %#v %#v, got: %#v, %#v",
|
||||
tt.v, tt.err, v, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestAlignedBuff16(t *testing.T) {
|
||||
b0 := New()
|
||||
b0.PutUint8(0x42)
|
||||
b0.PutUint16(0x1234)
|
||||
b0.PutUint16(0x5678)
|
||||
|
||||
b := NewWithData(b0.data)
|
||||
v, err := b.Uint8()
|
||||
if v != 0x42 || err != nil {
|
||||
t.Fatalf("unaligment read failed")
|
||||
}
|
||||
tests := []struct {
|
||||
name string
|
||||
v uint16
|
||||
err error
|
||||
}{
|
||||
{
|
||||
name: "first read",
|
||||
v: 0x1234,
|
||||
err: nil,
|
||||
},
|
||||
{
|
||||
name: "second read",
|
||||
v: 0x5678,
|
||||
err: nil,
|
||||
},
|
||||
{
|
||||
name: "end of buffer",
|
||||
v: 0,
|
||||
err: ErrEOF,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
v, err := b.Uint16()
|
||||
if v != tt.v || err != tt.err {
|
||||
t.Errorf("%s failed, expected: %#v %#v, got: %#v, %#v",
|
||||
tt.name, tt.v, tt.err, v, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestAlignedBuff32(t *testing.T) {
|
||||
b0 := New()
|
||||
b0.PutUint8(0x42)
|
||||
b0.PutUint32(0x12345678)
|
||||
b0.PutUint32(0x01cecafe)
|
||||
|
||||
b := NewWithData(b0.data)
|
||||
|
||||
if len(b0.Data()) != 4*4 {
|
||||
t.Fatalf("alignment padding failed")
|
||||
}
|
||||
|
||||
v, err := b.Uint8()
|
||||
if v != 0x42 || err != nil {
|
||||
t.Fatalf("unaligment read failed")
|
||||
}
|
||||
tests := []struct {
|
||||
name string
|
||||
v uint32
|
||||
err error
|
||||
}{
|
||||
{
|
||||
name: "first read",
|
||||
v: 0x12345678,
|
||||
err: nil,
|
||||
},
|
||||
{
|
||||
name: "second read",
|
||||
v: 0x01cecafe,
|
||||
err: nil,
|
||||
},
|
||||
{
|
||||
name: "end of buffer",
|
||||
v: 0,
|
||||
err: ErrEOF,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
v, err := b.Uint32()
|
||||
if v != tt.v || err != tt.err {
|
||||
t.Errorf("expected: %#v %#v, got: %#v, %#v",
|
||||
tt.v, tt.err, v, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestAlignedBuff64(t *testing.T) {
|
||||
b0 := New()
|
||||
b0.PutUint8(0x42)
|
||||
b0.PutUint64(0x1234567823456789)
|
||||
b0.PutUint64(0x01cecafec001beef)
|
||||
|
||||
b := NewWithData(b0.data)
|
||||
v, err := b.Uint8()
|
||||
if v != 0x42 || err != nil {
|
||||
t.Fatalf("unaligment read failed")
|
||||
}
|
||||
tests := []struct {
|
||||
name string
|
||||
v uint64
|
||||
err error
|
||||
}{
|
||||
{
|
||||
name: "first read",
|
||||
v: 0x1234567823456789,
|
||||
err: nil,
|
||||
},
|
||||
{
|
||||
name: "second read",
|
||||
v: 0x01cecafec001beef,
|
||||
err: nil,
|
||||
},
|
||||
{
|
||||
name: "end of buffer",
|
||||
v: 0,
|
||||
err: ErrEOF,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
v, err := b.Uint64()
|
||||
if v != tt.v || err != tt.err {
|
||||
t.Errorf("expected: %#v %#v, got: %#v, %#v",
|
||||
tt.v, tt.err, v, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestAlignedUint(t *testing.T) {
|
||||
expectedv := uint(^uint32(0) - 1)
|
||||
b0 := New()
|
||||
b0.PutUint8(0x55)
|
||||
b0.PutUint(expectedv)
|
||||
b0.PutUint8(0xAA)
|
||||
|
||||
b := NewWithData(b0.data)
|
||||
v, err := b.Uint8()
|
||||
if v != 0x55 || err != nil {
|
||||
t.Fatalf("sentinel read failed")
|
||||
}
|
||||
uiv, err := b.Uint()
|
||||
if uiv != expectedv || err != nil {
|
||||
t.Fatalf("uint read failed, expected: %d, got: %d", expectedv, uiv)
|
||||
}
|
||||
v, err = b.Uint8()
|
||||
if v != 0xAA || err != nil {
|
||||
t.Fatalf("sentinel read failed")
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue