Use v2 of XDR package (auto generated)

lib/db/leveldb_xdr.go

@@ -5,9 +5,6 @@
 package db
 
 import (
-	"bytes"
-	"io"
-
 	"github.com/calmh/xdr"
 )
 
@@ -22,10 +19,8 @@ fileVersion Structure:
 \                       Vector Structure                        \
 /                                                               /
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                       Length of device                        |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 /                                                               /
-\                   device (variable length)                    \
+\                 device (length + padded data)                 \
 /                                                               /
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
@@ -37,13 +32,15 @@ struct fileVersion {
 
 */
 
-func (o fileVersion) EncodeXDR(w io.Writer) (int, error) {
-	var xw = xdr.NewWriter(w)
-	return o.EncodeXDRInto(xw)
+func (o fileVersion) XDRSize() int {
+	return o.version.XDRSize() +
+		4 + len(o.device) + xdr.Padding(len(o.device))
 }
 
 func (o fileVersion) MarshalXDR() ([]byte, error) {
-	return o.AppendXDR(make([]byte, 0, 128))
+	buf := make([]byte, o.XDRSize())
+	m := &xdr.Marshaller{Data: buf}
+	return buf, o.MarshalXDRInto(m)
 }
 
 func (o fileVersion) MustMarshalXDR() []byte {
@@ -54,37 +51,22 @@ func (o fileVersion) MustMarshalXDR() []byte {
 	return bs
 }
 
-func (o fileVersion) AppendXDR(bs []byte) ([]byte, error) {
-	var aw = xdr.AppendWriter(bs)
-	var xw = xdr.NewWriter(&aw)
-	_, err := o.EncodeXDRInto(xw)
-	return []byte(aw), err
-}
-
-func (o fileVersion) EncodeXDRInto(xw *xdr.Writer) (int, error) {
-	_, err := o.version.EncodeXDRInto(xw)
-	if err != nil {
-		return xw.Tot(), err
+func (o fileVersion) MarshalXDRInto(m *xdr.Marshaller) error {
+	if err := o.version.MarshalXDRInto(m); err != nil {
+		return err
 	}
-	xw.WriteBytes(o.device)
-	return xw.Tot(), xw.Error()
-}
-
-func (o *fileVersion) DecodeXDR(r io.Reader) error {
-	xr := xdr.NewReader(r)
-	return o.DecodeXDRFrom(xr)
+	m.MarshalBytes(o.device)
+	return m.Error
 }
 
 func (o *fileVersion) UnmarshalXDR(bs []byte) error {
-	var br = bytes.NewReader(bs)
-	var xr = xdr.NewReader(br)
-	return o.DecodeXDRFrom(xr)
+	u := &xdr.Unmarshaller{Data: bs}
+	return o.UnmarshalXDRFrom(u)
 }
-
-func (o *fileVersion) DecodeXDRFrom(xr *xdr.Reader) error {
-	(&o.version).DecodeXDRFrom(xr)
-	o.device = xr.ReadBytes()
-	return xr.Error()
+func (o *fileVersion) UnmarshalXDRFrom(u *xdr.Unmarshaller) error {
+	(&o.version).UnmarshalXDRFrom(u)
+	o.device = u.UnmarshalBytes()
+	return u.Error
 }
 
 /*
@@ -108,13 +90,14 @@ struct versionList {
 
 */
 
-func (o versionList) EncodeXDR(w io.Writer) (int, error) {
-	var xw = xdr.NewWriter(w)
-	return o.EncodeXDRInto(xw)
+func (o versionList) XDRSize() int {
+	return 4 + xdr.SizeOfSlice(o.versions)
 }
 
 func (o versionList) MarshalXDR() ([]byte, error) {
-	return o.AppendXDR(make([]byte, 0, 128))
+	buf := make([]byte, o.XDRSize())
+	m := &xdr.Marshaller{Data: buf}
+	return buf, o.MarshalXDRInto(m)
 }
 
 func (o versionList) MustMarshalXDR() []byte {
@@ -125,43 +108,35 @@ func (o versionList) MustMarshalXDR() []byte {
 	return bs
 }
 
-func (o versionList) AppendXDR(bs []byte) ([]byte, error) {
-	var aw = xdr.AppendWriter(bs)
-	var xw = xdr.NewWriter(&aw)
-	_, err := o.EncodeXDRInto(xw)
-	return []byte(aw), err
-}
-
-func (o versionList) EncodeXDRInto(xw *xdr.Writer) (int, error) {
-	xw.WriteUint32(uint32(len(o.versions)))
+func (o versionList) MarshalXDRInto(m *xdr.Marshaller) error {
+	m.MarshalUint32(uint32(len(o.versions)))
 	for i := range o.versions {
-		_, err := o.versions[i].EncodeXDRInto(xw)
-		if err != nil {
-			return xw.Tot(), err
+		if err := o.versions[i].MarshalXDRInto(m); err != nil {
+			return err
 		}
 	}
-	return xw.Tot(), xw.Error()
-}
-
-func (o *versionList) DecodeXDR(r io.Reader) error {
-	xr := xdr.NewReader(r)
-	return o.DecodeXDRFrom(xr)
+	return m.Error
 }
 
 func (o *versionList) UnmarshalXDR(bs []byte) error {
-	var br = bytes.NewReader(bs)
-	var xr = xdr.NewReader(br)
-	return o.DecodeXDRFrom(xr)
+	u := &xdr.Unmarshaller{Data: bs}
+	return o.UnmarshalXDRFrom(u)
 }
-
-func (o *versionList) DecodeXDRFrom(xr *xdr.Reader) error {
-	_versionsSize := int(xr.ReadUint32())
+func (o *versionList) UnmarshalXDRFrom(u *xdr.Unmarshaller) error {
+	_versionsSize := int(u.UnmarshalUint32())
 	if _versionsSize < 0 {
 		return xdr.ElementSizeExceeded("versions", _versionsSize, 0)
+	} else if _versionsSize == 0 {
+		o.versions = nil
+	} else {
+		if _versionsSize <= len(o.versions) {
+			o.versions = o.versions[:_versionsSize]
+		} else {
+			o.versions = make([]fileVersion, _versionsSize)
+		}
+		for i := range o.versions {
+			(&o.versions[i]).UnmarshalXDRFrom(u)
+		}
 	}
-	o.versions = make([]fileVersion, _versionsSize)
-	for i := range o.versions {
-		(&o.versions[i]).DecodeXDRFrom(xr)
-	}
-	return xr.Error()
+	return u.Error
 }

lib/db/truncated.go

@@ -7,8 +7,6 @@
 package db
 
 import (
-	"bytes"
-
 	"github.com/calmh/xdr"
 	"github.com/syncthing/syncthing/lib/protocol"
 )
@@ -18,32 +16,32 @@ type FileInfoTruncated struct {
 }
 
 func (o *FileInfoTruncated) UnmarshalXDR(bs []byte) error {
-	var br = bytes.NewReader(bs)
-	var xr = xdr.NewReader(br)
-	return o.DecodeXDRFrom(xr)
+	return o.UnmarshalXDRFrom(&xdr.Unmarshaller{Data: bs})
 }
 
-func (o *FileInfoTruncated) DecodeXDRFrom(xr *xdr.Reader) error {
-	o.Name = xr.ReadStringMax(8192)
-	o.Flags = xr.ReadUint32()
-	o.Modified = int64(xr.ReadUint64())
-	(&o.Version).DecodeXDRFrom(xr)
-	o.LocalVersion = int64(xr.ReadUint64())
-	_BlocksSize := int(xr.ReadUint32())
+func (o *FileInfoTruncated) UnmarshalXDRFrom(u *xdr.Unmarshaller) error {
+	o.Name = u.UnmarshalStringMax(8192)
+	o.Flags = u.UnmarshalUint32()
+	o.Modified = int64(u.UnmarshalUint64())
+	(&o.Version).UnmarshalXDRFrom(u)
+	o.LocalVersion = int64(u.UnmarshalUint64())
+	_BlocksSize := int(u.UnmarshalUint32())
 	if _BlocksSize < 0 {
 		return xdr.ElementSizeExceeded("Blocks", _BlocksSize, 1000000)
-	}
-	if _BlocksSize > 1000000 {
-		return xdr.ElementSizeExceeded("Blocks", _BlocksSize, 1000000)
+	} else if _BlocksSize == 0 {
+		o.Blocks = nil
+	} else {
+		if _BlocksSize > 1000000 {
+			return xdr.ElementSizeExceeded("Blocks", _BlocksSize, 1000000)
+		}
+		for i := 0; i < _BlocksSize; i++ {
+			size := int64(u.UnmarshalUint32())
+			o.CachedSize += size
+			u.UnmarshalBytes()
+		}
 	}
 
-	buf := make([]byte, 64)
-	for i := 0; i < _BlocksSize; i++ {
-		size := xr.ReadUint32()
-		o.CachedSize += int64(size)
-		xr.ReadBytesMaxInto(64, buf)
-	}
-	return xr.Error()
+	return u.Error
 }
 
 func BlocksToSize(num int) int64 {

lib/discover/localpackets_xdr.go

@@ -5,9 +5,6 @@
 package discover
 
 import (
-	"bytes"
-	"io"
-
 	"github.com/calmh/xdr"
 )
 
@@ -40,13 +37,16 @@ struct Announce {
 
 */
 
-func (o Announce) EncodeXDR(w io.Writer) (int, error) {
-	var xw = xdr.NewWriter(w)
-	return o.EncodeXDRInto(xw)
+func (o Announce) XDRSize() int {
+	return 4 +
+		o.This.XDRSize() +
+		4 + xdr.SizeOfSlice(o.Extra)
 }
 
 func (o Announce) MarshalXDR() ([]byte, error) {
-	return o.AppendXDR(make([]byte, 0, 128))
+	buf := make([]byte, o.XDRSize())
+	m := &xdr.Marshaller{Data: buf}
+	return buf, o.MarshalXDRInto(m)
 }
 
 func (o Announce) MustMarshalXDR() []byte {
@@ -57,58 +57,49 @@ func (o Announce) MustMarshalXDR() []byte {
 	return bs
 }
 
-func (o Announce) AppendXDR(bs []byte) ([]byte, error) {
-	var aw = xdr.AppendWriter(bs)
-	var xw = xdr.NewWriter(&aw)
-	_, err := o.EncodeXDRInto(xw)
-	return []byte(aw), err
-}
-
-func (o Announce) EncodeXDRInto(xw *xdr.Writer) (int, error) {
-	xw.WriteUint32(o.Magic)
-	_, err := o.This.EncodeXDRInto(xw)
-	if err != nil {
-		return xw.Tot(), err
+func (o Announce) MarshalXDRInto(m *xdr.Marshaller) error {
+	m.MarshalUint32(o.Magic)
+	if err := o.This.MarshalXDRInto(m); err != nil {
+		return err
 	}
 	if l := len(o.Extra); l > 16 {
-		return xw.Tot(), xdr.ElementSizeExceeded("Extra", l, 16)
+		return xdr.ElementSizeExceeded("Extra", l, 16)
 	}
-	xw.WriteUint32(uint32(len(o.Extra)))
+	m.MarshalUint32(uint32(len(o.Extra)))
 	for i := range o.Extra {
-		_, err := o.Extra[i].EncodeXDRInto(xw)
-		if err != nil {
-			return xw.Tot(), err
+		if err := o.Extra[i].MarshalXDRInto(m); err != nil {
+			return err
 		}
 	}
-	return xw.Tot(), xw.Error()
-}
-
-func (o *Announce) DecodeXDR(r io.Reader) error {
-	xr := xdr.NewReader(r)
-	return o.DecodeXDRFrom(xr)
+	return m.Error
 }
 
 func (o *Announce) UnmarshalXDR(bs []byte) error {
-	var br = bytes.NewReader(bs)
-	var xr = xdr.NewReader(br)
-	return o.DecodeXDRFrom(xr)
+	u := &xdr.Unmarshaller{Data: bs}
+	return o.UnmarshalXDRFrom(u)
 }
-
-func (o *Announce) DecodeXDRFrom(xr *xdr.Reader) error {
-	o.Magic = xr.ReadUint32()
-	(&o.This).DecodeXDRFrom(xr)
-	_ExtraSize := int(xr.ReadUint32())
+func (o *Announce) UnmarshalXDRFrom(u *xdr.Unmarshaller) error {
+	o.Magic = u.UnmarshalUint32()
+	(&o.This).UnmarshalXDRFrom(u)
+	_ExtraSize := int(u.UnmarshalUint32())
 	if _ExtraSize < 0 {
 		return xdr.ElementSizeExceeded("Extra", _ExtraSize, 16)
+	} else if _ExtraSize == 0 {
+		o.Extra = nil
+	} else {
+		if _ExtraSize > 16 {
+			return xdr.ElementSizeExceeded("Extra", _ExtraSize, 16)
+		}
+		if _ExtraSize <= len(o.Extra) {
+			o.Extra = o.Extra[:_ExtraSize]
+		} else {
+			o.Extra = make([]Device, _ExtraSize)
+		}
+		for i := range o.Extra {
+			(&o.Extra[i]).UnmarshalXDRFrom(u)
+		}
 	}
-	if _ExtraSize > 16 {
-		return xdr.ElementSizeExceeded("Extra", _ExtraSize, 16)
-	}
-	o.Extra = make([]Device, _ExtraSize)
-	for i := range o.Extra {
-		(&o.Extra[i]).DecodeXDRFrom(xr)
-	}
-	return xr.Error()
+	return u.Error
 }
 
 /*
@@ -118,10 +109,8 @@ Device Structure:
  0                   1                   2                   3
  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                         Length of ID                          |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 /                                                               /
-\                     ID (variable length)                      \
+\                   ID (length + padded data)                   \
 /                                                               /
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 |                      Number of Addresses                      |
@@ -146,13 +135,16 @@ struct Device {
 
 */
 
-func (o Device) EncodeXDR(w io.Writer) (int, error) {
-	var xw = xdr.NewWriter(w)
-	return o.EncodeXDRInto(xw)
+func (o Device) XDRSize() int {
+	return 4 + len(o.ID) + xdr.Padding(len(o.ID)) +
+		4 + xdr.SizeOfSlice(o.Addresses) +
+		4 + xdr.SizeOfSlice(o.Relays)
 }
 
 func (o Device) MarshalXDR() ([]byte, error) {
-	return o.AppendXDR(make([]byte, 0, 128))
+	buf := make([]byte, o.XDRSize())
+	m := &xdr.Marshaller{Data: buf}
+	return buf, o.MarshalXDRInto(m)
 }
 
 func (o Device) MustMarshalXDR() []byte {
@@ -163,77 +155,75 @@ func (o Device) MustMarshalXDR() []byte {
 	return bs
 }
 
-func (o Device) AppendXDR(bs []byte) ([]byte, error) {
-	var aw = xdr.AppendWriter(bs)
-	var xw = xdr.NewWriter(&aw)
-	_, err := o.EncodeXDRInto(xw)
-	return []byte(aw), err
-}
-
-func (o Device) EncodeXDRInto(xw *xdr.Writer) (int, error) {
+func (o Device) MarshalXDRInto(m *xdr.Marshaller) error {
 	if l := len(o.ID); l > 32 {
-		return xw.Tot(), xdr.ElementSizeExceeded("ID", l, 32)
+		return xdr.ElementSizeExceeded("ID", l, 32)
 	}
-	xw.WriteBytes(o.ID)
+	m.MarshalBytes(o.ID)
 	if l := len(o.Addresses); l > 16 {
-		return xw.Tot(), xdr.ElementSizeExceeded("Addresses", l, 16)
+		return xdr.ElementSizeExceeded("Addresses", l, 16)
 	}
-	xw.WriteUint32(uint32(len(o.Addresses)))
+	m.MarshalUint32(uint32(len(o.Addresses)))
 	for i := range o.Addresses {
-		_, err := o.Addresses[i].EncodeXDRInto(xw)
-		if err != nil {
-			return xw.Tot(), err
+		if err := o.Addresses[i].MarshalXDRInto(m); err != nil {
+			return err
 		}
 	}
 	if l := len(o.Relays); l > 16 {
-		return xw.Tot(), xdr.ElementSizeExceeded("Relays", l, 16)
+		return xdr.ElementSizeExceeded("Relays", l, 16)
 	}
-	xw.WriteUint32(uint32(len(o.Relays)))
+	m.MarshalUint32(uint32(len(o.Relays)))
 	for i := range o.Relays {
-		_, err := o.Relays[i].EncodeXDRInto(xw)
-		if err != nil {
-			return xw.Tot(), err
+		if err := o.Relays[i].MarshalXDRInto(m); err != nil {
+			return err
 		}
 	}
-	return xw.Tot(), xw.Error()
-}
-
-func (o *Device) DecodeXDR(r io.Reader) error {
-	xr := xdr.NewReader(r)
-	return o.DecodeXDRFrom(xr)
+	return m.Error
 }
 
 func (o *Device) UnmarshalXDR(bs []byte) error {
-	var br = bytes.NewReader(bs)
-	var xr = xdr.NewReader(br)
-	return o.DecodeXDRFrom(xr)
+	u := &xdr.Unmarshaller{Data: bs}
+	return o.UnmarshalXDRFrom(u)
 }
-
-func (o *Device) DecodeXDRFrom(xr *xdr.Reader) error {
-	o.ID = xr.ReadBytesMax(32)
-	_AddressesSize := int(xr.ReadUint32())
+func (o *Device) UnmarshalXDRFrom(u *xdr.Unmarshaller) error {
+	o.ID = u.UnmarshalBytesMax(32)
+	_AddressesSize := int(u.UnmarshalUint32())
 	if _AddressesSize < 0 {
 		return xdr.ElementSizeExceeded("Addresses", _AddressesSize, 16)
+	} else if _AddressesSize == 0 {
+		o.Addresses = nil
+	} else {
+		if _AddressesSize > 16 {
+			return xdr.ElementSizeExceeded("Addresses", _AddressesSize, 16)
+		}
+		if _AddressesSize <= len(o.Addresses) {
+			o.Addresses = o.Addresses[:_AddressesSize]
+		} else {
+			o.Addresses = make([]Address, _AddressesSize)
+		}
+		for i := range o.Addresses {
+			(&o.Addresses[i]).UnmarshalXDRFrom(u)
+		}
 	}
-	if _AddressesSize > 16 {
-		return xdr.ElementSizeExceeded("Addresses", _AddressesSize, 16)
-	}
-	o.Addresses = make([]Address, _AddressesSize)
-	for i := range o.Addresses {
-		(&o.Addresses[i]).DecodeXDRFrom(xr)
-	}
-	_RelaysSize := int(xr.ReadUint32())
+	_RelaysSize := int(u.UnmarshalUint32())
 	if _RelaysSize < 0 {
 		return xdr.ElementSizeExceeded("Relays", _RelaysSize, 16)
+	} else if _RelaysSize == 0 {
+		o.Relays = nil
+	} else {
+		if _RelaysSize > 16 {
+			return xdr.ElementSizeExceeded("Relays", _RelaysSize, 16)
+		}
+		if _RelaysSize <= len(o.Relays) {
+			o.Relays = o.Relays[:_RelaysSize]
+		} else {
+			o.Relays = make([]Relay, _RelaysSize)
+		}
+		for i := range o.Relays {
+			(&o.Relays[i]).UnmarshalXDRFrom(u)
+		}
 	}
-	if _RelaysSize > 16 {
-		return xdr.ElementSizeExceeded("Relays", _RelaysSize, 16)
-	}
-	o.Relays = make([]Relay, _RelaysSize)
-	for i := range o.Relays {
-		(&o.Relays[i]).DecodeXDRFrom(xr)
-	}
-	return xr.Error()
+	return u.Error
 }
 
 /*
@@ -243,10 +233,8 @@ Address Structure:
  0                   1                   2                   3
  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                         Length of URL                         |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 /                                                               /
-\                     URL (variable length)                     \
+\                  URL (length + padded data)                   \
 /                                                               /
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
@@ -257,13 +245,14 @@ struct Address {
 
 */
 
-func (o Address) EncodeXDR(w io.Writer) (int, error) {
-	var xw = xdr.NewWriter(w)
-	return o.EncodeXDRInto(xw)
+func (o Address) XDRSize() int {
+	return 4 + len(o.URL) + xdr.Padding(len(o.URL))
 }
 
 func (o Address) MarshalXDR() ([]byte, error) {
-	return o.AppendXDR(make([]byte, 0, 128))
+	buf := make([]byte, o.XDRSize())
+	m := &xdr.Marshaller{Data: buf}
+	return buf, o.MarshalXDRInto(m)
 }
 
 func (o Address) MustMarshalXDR() []byte {
@@ -274,35 +263,21 @@ func (o Address) MustMarshalXDR() []byte {
 	return bs
 }
 
-func (o Address) AppendXDR(bs []byte) ([]byte, error) {
-	var aw = xdr.AppendWriter(bs)
-	var xw = xdr.NewWriter(&aw)
-	_, err := o.EncodeXDRInto(xw)
-	return []byte(aw), err
-}
-
-func (o Address) EncodeXDRInto(xw *xdr.Writer) (int, error) {
+func (o Address) MarshalXDRInto(m *xdr.Marshaller) error {
 	if l := len(o.URL); l > 2083 {
-		return xw.Tot(), xdr.ElementSizeExceeded("URL", l, 2083)
+		return xdr.ElementSizeExceeded("URL", l, 2083)
 	}
-	xw.WriteString(o.URL)
-	return xw.Tot(), xw.Error()
-}
-
-func (o *Address) DecodeXDR(r io.Reader) error {
-	xr := xdr.NewReader(r)
-	return o.DecodeXDRFrom(xr)
+	m.MarshalString(o.URL)
+	return m.Error
 }
 
 func (o *Address) UnmarshalXDR(bs []byte) error {
-	var br = bytes.NewReader(bs)
-	var xr = xdr.NewReader(br)
-	return o.DecodeXDRFrom(xr)
+	u := &xdr.Unmarshaller{Data: bs}
+	return o.UnmarshalXDRFrom(u)
 }
-
-func (o *Address) DecodeXDRFrom(xr *xdr.Reader) error {
-	o.URL = xr.ReadStringMax(2083)
-	return xr.Error()
+func (o *Address) UnmarshalXDRFrom(u *xdr.Unmarshaller) error {
+	o.URL = u.UnmarshalStringMax(2083)
+	return u.Error
 }
 
 /*
@@ -312,10 +287,8 @@ Relay Structure:
  0                   1                   2                   3
  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                         Length of URL                         |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 /                                                               /
-\                     URL (variable length)                     \
+\                  URL (length + padded data)                   \
 /                                                               /
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 |                            Latency                            |
@@ -329,13 +302,14 @@ struct Relay {
 
 */
 
-func (o Relay) EncodeXDR(w io.Writer) (int, error) {
-	var xw = xdr.NewWriter(w)
-	return o.EncodeXDRInto(xw)
+func (o Relay) XDRSize() int {
+	return 4 + len(o.URL) + xdr.Padding(len(o.URL)) + 4
 }
 
 func (o Relay) MarshalXDR() ([]byte, error) {
-	return o.AppendXDR(make([]byte, 0, 128))
+	buf := make([]byte, o.XDRSize())
+	m := &xdr.Marshaller{Data: buf}
+	return buf, o.MarshalXDRInto(m)
 }
 
 func (o Relay) MustMarshalXDR() []byte {
@@ -346,35 +320,21 @@ func (o Relay) MustMarshalXDR() []byte {
 	return bs
 }
 
-func (o Relay) AppendXDR(bs []byte) ([]byte, error) {
-	var aw = xdr.AppendWriter(bs)
-	var xw = xdr.NewWriter(&aw)
-	_, err := o.EncodeXDRInto(xw)
-	return []byte(aw), err
-}
-
-func (o Relay) EncodeXDRInto(xw *xdr.Writer) (int, error) {
+func (o Relay) MarshalXDRInto(m *xdr.Marshaller) error {
 	if l := len(o.URL); l > 2083 {
-		return xw.Tot(), xdr.ElementSizeExceeded("URL", l, 2083)
+		return xdr.ElementSizeExceeded("URL", l, 2083)
 	}
-	xw.WriteString(o.URL)
-	xw.WriteUint32(uint32(o.Latency))
-	return xw.Tot(), xw.Error()
-}
-
-func (o *Relay) DecodeXDR(r io.Reader) error {
-	xr := xdr.NewReader(r)
-	return o.DecodeXDRFrom(xr)
+	m.MarshalString(o.URL)
+	m.MarshalUint32(uint32(o.Latency))
+	return m.Error
 }
 
 func (o *Relay) UnmarshalXDR(bs []byte) error {
-	var br = bytes.NewReader(bs)
-	var xr = xdr.NewReader(br)
-	return o.DecodeXDRFrom(xr)
+	u := &xdr.Unmarshaller{Data: bs}
+	return o.UnmarshalXDRFrom(u)
 }
-
-func (o *Relay) DecodeXDRFrom(xr *xdr.Reader) error {
-	o.URL = xr.ReadStringMax(2083)
-	o.Latency = int32(xr.ReadUint32())
-	return xr.Error()
+func (o *Relay) UnmarshalXDRFrom(u *xdr.Unmarshaller) error {
+	o.URL = u.UnmarshalStringMax(2083)
+	o.Latency = int32(u.UnmarshalUint32())
+	return u.Error
 }

lib/protocol/vector_xdr.go

@@ -7,37 +7,29 @@ import "github.com/calmh/xdr"
 // This stuff is hacked up manually because genxdr doesn't support 'type
 // Vector []Counter' declarations and it was tricky when I tried to add it...
 
-type xdrWriter interface {
-	WriteUint32(uint32) (int, error)
-	WriteUint64(uint64) (int, error)
-}
-type xdrReader interface {
-	ReadUint32() uint32
-	ReadUint64() uint64
-}
-
-// EncodeXDRInto encodes the vector as an XDR object into the given XDR
-// encoder.
-func (v Vector) EncodeXDRInto(w xdrWriter) (int, error) {
-	w.WriteUint32(uint32(len(v)))
+func (v Vector) MarshalXDRInto(m *xdr.Marshaller) error {
+	m.MarshalUint32(uint32(len(v)))
 	for i := range v {
-		w.WriteUint64(uint64(v[i].ID))
-		w.WriteUint64(v[i].Value)
+		m.MarshalUint64(uint64(v[i].ID))
+		m.MarshalUint64(v[i].Value)
 	}
-	return 4 + 16*len(v), nil
+	return m.Error
 }
 
-// DecodeXDRFrom decodes the XDR objects from the given reader into itself.
-func (v *Vector) DecodeXDRFrom(r xdrReader) error {
-	l := int(r.ReadUint32())
+func (v *Vector) UnmarshalXDRFrom(u *xdr.Unmarshaller) error {
+	l := int(u.UnmarshalUint32())
 	if l > 1e6 {
 		return xdr.ElementSizeExceeded("number of counters", l, 1e6)
 	}
 	n := make(Vector, l)
 	for i := range n {
-		n[i].ID = ShortID(r.ReadUint64())
-		n[i].Value = r.ReadUint64()
+		n[i].ID = ShortID(u.UnmarshalUint64())
+		n[i].Value = u.UnmarshalUint64()
 	}
 	*v = n
-	return nil
+	return u.Error
+}
+
+func (v Vector) XDRSize() int {
+	return 4 + 16*len(v)
 }

lib/relay/protocol/packets_xdr.go

@@ -5,9 +5,6 @@
 package protocol
 
 import (
-	"bytes"
-	"io"
-
 	"github.com/calmh/xdr"
 )
 
@@ -34,13 +31,14 @@ struct header {
 
 */
 
-func (o header) EncodeXDR(w io.Writer) (int, error) {
-	var xw = xdr.NewWriter(w)
-	return o.EncodeXDRInto(xw)
+func (o header) XDRSize() int {
+	return 4 + 4 + 4
 }
 
 func (o header) MarshalXDR() ([]byte, error) {
-	return o.AppendXDR(make([]byte, 0, 128))
+	buf := make([]byte, o.XDRSize())
+	m := &xdr.Marshaller{Data: buf}
+	return buf, o.MarshalXDRInto(m)
 }
 
 func (o header) MustMarshalXDR() []byte {
@@ -51,36 +49,22 @@ func (o header) MustMarshalXDR() []byte {
 	return bs
 }
 
-func (o header) AppendXDR(bs []byte) ([]byte, error) {
-	var aw = xdr.AppendWriter(bs)
-	var xw = xdr.NewWriter(&aw)
-	_, err := o.EncodeXDRInto(xw)
-	return []byte(aw), err
-}
-
-func (o header) EncodeXDRInto(xw *xdr.Writer) (int, error) {
-	xw.WriteUint32(o.magic)
-	xw.WriteUint32(uint32(o.messageType))
-	xw.WriteUint32(uint32(o.messageLength))
-	return xw.Tot(), xw.Error()
-}
-
-func (o *header) DecodeXDR(r io.Reader) error {
-	xr := xdr.NewReader(r)
-	return o.DecodeXDRFrom(xr)
+func (o header) MarshalXDRInto(m *xdr.Marshaller) error {
+	m.MarshalUint32(o.magic)
+	m.MarshalUint32(uint32(o.messageType))
+	m.MarshalUint32(uint32(o.messageLength))
+	return m.Error
 }
 
 func (o *header) UnmarshalXDR(bs []byte) error {
-	var br = bytes.NewReader(bs)
-	var xr = xdr.NewReader(br)
-	return o.DecodeXDRFrom(xr)
+	u := &xdr.Unmarshaller{Data: bs}
+	return o.UnmarshalXDRFrom(u)
 }
-
-func (o *header) DecodeXDRFrom(xr *xdr.Reader) error {
-	o.magic = xr.ReadUint32()
-	o.messageType = int32(xr.ReadUint32())
-	o.messageLength = int32(xr.ReadUint32())
-	return xr.Error()
+func (o *header) UnmarshalXDRFrom(u *xdr.Unmarshaller) error {
+	o.magic = u.UnmarshalUint32()
+	o.messageType = int32(u.UnmarshalUint32())
+	o.messageLength = int32(u.UnmarshalUint32())
+	return u.Error
 }
 
 /*
@@ -94,10 +78,9 @@ struct Ping {
 
 */
 
-func (o Ping) EncodeXDR(w io.Writer) (int, error) {
-	return 0, nil
+func (o Ping) XDRSize() int {
+	return 0
 }
-
 func (o Ping) MarshalXDR() ([]byte, error) {
 	return nil, nil
 }
@@ -106,15 +89,7 @@ func (o Ping) MustMarshalXDR() []byte {
 	return nil
 }
 
-func (o Ping) AppendXDR(bs []byte) ([]byte, error) {
-	return bs, nil
-}
-
-func (o Ping) EncodeXDRInto(xw *xdr.Writer) (int, error) {
-	return xw.Tot(), xw.Error()
-}
-
-func (o *Ping) DecodeXDR(r io.Reader) error {
+func (o Ping) MarshalXDRInto(m *xdr.Marshaller) error {
 	return nil
 }
 
@@ -122,8 +97,8 @@ func (o *Ping) UnmarshalXDR(bs []byte) error {
 	return nil
 }
 
-func (o *Ping) DecodeXDRFrom(xr *xdr.Reader) error {
-	return xr.Error()
+func (o *Ping) UnmarshalXDRFrom(u *xdr.Unmarshaller) error {
+	return nil
 }
 
 /*
@@ -137,10 +112,9 @@ struct Pong {
 
 */
 
-func (o Pong) EncodeXDR(w io.Writer) (int, error) {
-	return 0, nil
+func (o Pong) XDRSize() int {
+	return 0
 }
-
 func (o Pong) MarshalXDR() ([]byte, error) {
 	return nil, nil
 }
@@ -149,15 +123,7 @@ func (o Pong) MustMarshalXDR() []byte {
 	return nil
 }
 
-func (o Pong) AppendXDR(bs []byte) ([]byte, error) {
-	return bs, nil
-}
-
-func (o Pong) EncodeXDRInto(xw *xdr.Writer) (int, error) {
-	return xw.Tot(), xw.Error()
-}
-
-func (o *Pong) DecodeXDR(r io.Reader) error {
+func (o Pong) MarshalXDRInto(m *xdr.Marshaller) error {
 	return nil
 }
 
@@ -165,8 +131,8 @@ func (o *Pong) UnmarshalXDR(bs []byte) error {
 	return nil
 }
 
-func (o *Pong) DecodeXDRFrom(xr *xdr.Reader) error {
-	return xr.Error()
+func (o *Pong) UnmarshalXDRFrom(u *xdr.Unmarshaller) error {
+	return nil
 }
 
 /*
@@ -180,10 +146,9 @@ struct JoinRelayRequest {
 
 */
 
-func (o JoinRelayRequest) EncodeXDR(w io.Writer) (int, error) {
-	return 0, nil
+func (o JoinRelayRequest) XDRSize() int {
+	return 0
 }
-
 func (o JoinRelayRequest) MarshalXDR() ([]byte, error) {
 	return nil, nil
 }
@@ -192,15 +157,7 @@ func (o JoinRelayRequest) MustMarshalXDR() []byte {
 	return nil
 }
 
-func (o JoinRelayRequest) AppendXDR(bs []byte) ([]byte, error) {
-	return bs, nil
-}
-
-func (o JoinRelayRequest) EncodeXDRInto(xw *xdr.Writer) (int, error) {
-	return xw.Tot(), xw.Error()
-}
-
-func (o *JoinRelayRequest) DecodeXDR(r io.Reader) error {
+func (o JoinRelayRequest) MarshalXDRInto(m *xdr.Marshaller) error {
 	return nil
 }
 
@@ -208,8 +165,8 @@ func (o *JoinRelayRequest) UnmarshalXDR(bs []byte) error {
 	return nil
 }
 
-func (o *JoinRelayRequest) DecodeXDRFrom(xr *xdr.Reader) error {
-	return xr.Error()
+func (o *JoinRelayRequest) UnmarshalXDRFrom(u *xdr.Unmarshaller) error {
+	return nil
 }
 
 /*
@@ -223,10 +180,9 @@ struct RelayFull {
 
 */
 
-func (o RelayFull) EncodeXDR(w io.Writer) (int, error) {
-	return 0, nil
+func (o RelayFull) XDRSize() int {
+	return 0
 }
-
 func (o RelayFull) MarshalXDR() ([]byte, error) {
 	return nil, nil
 }
@@ -235,15 +191,7 @@ func (o RelayFull) MustMarshalXDR() []byte {
 	return nil
 }
 
-func (o RelayFull) AppendXDR(bs []byte) ([]byte, error) {
-	return bs, nil
-}
-
-func (o RelayFull) EncodeXDRInto(xw *xdr.Writer) (int, error) {
-	return xw.Tot(), xw.Error()
-}
-
-func (o *RelayFull) DecodeXDR(r io.Reader) error {
+func (o RelayFull) MarshalXDRInto(m *xdr.Marshaller) error {
 	return nil
 }
 
@@ -251,8 +199,8 @@ func (o *RelayFull) UnmarshalXDR(bs []byte) error {
 	return nil
 }
 
-func (o *RelayFull) DecodeXDRFrom(xr *xdr.Reader) error {
-	return xr.Error()
+func (o *RelayFull) UnmarshalXDRFrom(u *xdr.Unmarshaller) error {
+	return nil
 }
 
 /*
@@ -262,10 +210,8 @@ JoinSessionRequest Structure:
  0                   1                   2                   3
  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                         Length of Key                         |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 /                                                               /
-\                     Key (variable length)                     \
+\                  Key (length + padded data)                   \
 /                                                               /
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
@@ -276,13 +222,14 @@ struct JoinSessionRequest {
 
 */
 
-func (o JoinSessionRequest) EncodeXDR(w io.Writer) (int, error) {
-	var xw = xdr.NewWriter(w)
-	return o.EncodeXDRInto(xw)
+func (o JoinSessionRequest) XDRSize() int {
+	return 4 + len(o.Key) + xdr.Padding(len(o.Key))
 }
 
 func (o JoinSessionRequest) MarshalXDR() ([]byte, error) {
-	return o.AppendXDR(make([]byte, 0, 128))
+	buf := make([]byte, o.XDRSize())
+	m := &xdr.Marshaller{Data: buf}
+	return buf, o.MarshalXDRInto(m)
 }
 
 func (o JoinSessionRequest) MustMarshalXDR() []byte {
@@ -293,35 +240,21 @@ func (o JoinSessionRequest) MustMarshalXDR() []byte {
 	return bs
 }
 
-func (o JoinSessionRequest) AppendXDR(bs []byte) ([]byte, error) {
-	var aw = xdr.AppendWriter(bs)
-	var xw = xdr.NewWriter(&aw)
-	_, err := o.EncodeXDRInto(xw)
-	return []byte(aw), err
-}
-
-func (o JoinSessionRequest) EncodeXDRInto(xw *xdr.Writer) (int, error) {
+func (o JoinSessionRequest) MarshalXDRInto(m *xdr.Marshaller) error {
 	if l := len(o.Key); l > 32 {
-		return xw.Tot(), xdr.ElementSizeExceeded("Key", l, 32)
+		return xdr.ElementSizeExceeded("Key", l, 32)
 	}
-	xw.WriteBytes(o.Key)
-	return xw.Tot(), xw.Error()
-}
-
-func (o *JoinSessionRequest) DecodeXDR(r io.Reader) error {
-	xr := xdr.NewReader(r)
-	return o.DecodeXDRFrom(xr)
+	m.MarshalBytes(o.Key)
+	return m.Error
 }
 
 func (o *JoinSessionRequest) UnmarshalXDR(bs []byte) error {
-	var br = bytes.NewReader(bs)
-	var xr = xdr.NewReader(br)
-	return o.DecodeXDRFrom(xr)
+	u := &xdr.Unmarshaller{Data: bs}
+	return o.UnmarshalXDRFrom(u)
 }
-
-func (o *JoinSessionRequest) DecodeXDRFrom(xr *xdr.Reader) error {
-	o.Key = xr.ReadBytesMax(32)
-	return xr.Error()
+func (o *JoinSessionRequest) UnmarshalXDRFrom(u *xdr.Unmarshaller) error {
+	o.Key = u.UnmarshalBytesMax(32)
+	return u.Error
 }
 
 /*
@@ -333,10 +266,8 @@ Response Structure:
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 |                             Code                              |
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                       Length of Message                       |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 /                                                               /
-\                   Message (variable length)                   \
+\                Message (length + padded data)                 \
 /                                                               /
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
@@ -348,13 +279,15 @@ struct Response {
 
 */
 
-func (o Response) EncodeXDR(w io.Writer) (int, error) {
-	var xw = xdr.NewWriter(w)
-	return o.EncodeXDRInto(xw)
+func (o Response) XDRSize() int {
+	return 4 +
+		4 + len(o.Message) + xdr.Padding(len(o.Message))
 }
 
 func (o Response) MarshalXDR() ([]byte, error) {
-	return o.AppendXDR(make([]byte, 0, 128))
+	buf := make([]byte, o.XDRSize())
+	m := &xdr.Marshaller{Data: buf}
+	return buf, o.MarshalXDRInto(m)
 }
 
 func (o Response) MustMarshalXDR() []byte {
@@ -365,34 +298,20 @@ func (o Response) MustMarshalXDR() []byte {
 	return bs
 }
 
-func (o Response) AppendXDR(bs []byte) ([]byte, error) {
-	var aw = xdr.AppendWriter(bs)
-	var xw = xdr.NewWriter(&aw)
-	_, err := o.EncodeXDRInto(xw)
-	return []byte(aw), err
-}
-
-func (o Response) EncodeXDRInto(xw *xdr.Writer) (int, error) {
-	xw.WriteUint32(uint32(o.Code))
-	xw.WriteString(o.Message)
-	return xw.Tot(), xw.Error()
-}
-
-func (o *Response) DecodeXDR(r io.Reader) error {
-	xr := xdr.NewReader(r)
-	return o.DecodeXDRFrom(xr)
+func (o Response) MarshalXDRInto(m *xdr.Marshaller) error {
+	m.MarshalUint32(uint32(o.Code))
+	m.MarshalString(o.Message)
+	return m.Error
 }
 
 func (o *Response) UnmarshalXDR(bs []byte) error {
-	var br = bytes.NewReader(bs)
-	var xr = xdr.NewReader(br)
-	return o.DecodeXDRFrom(xr)
+	u := &xdr.Unmarshaller{Data: bs}
+	return o.UnmarshalXDRFrom(u)
 }
-
-func (o *Response) DecodeXDRFrom(xr *xdr.Reader) error {
-	o.Code = int32(xr.ReadUint32())
-	o.Message = xr.ReadString()
-	return xr.Error()
+func (o *Response) UnmarshalXDRFrom(u *xdr.Unmarshaller) error {
+	o.Code = int32(u.UnmarshalUint32())
+	o.Message = u.UnmarshalString()
+	return u.Error
 }
 
 /*
@@ -402,10 +321,8 @@ ConnectRequest Structure:
  0                   1                   2                   3
  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                         Length of ID                          |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 /                                                               /
-\                     ID (variable length)                      \
+\                   ID (length + padded data)                   \
 /                                                               /
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
@@ -416,13 +333,14 @@ struct ConnectRequest {
 
 */
 
-func (o ConnectRequest) EncodeXDR(w io.Writer) (int, error) {
-	var xw = xdr.NewWriter(w)
-	return o.EncodeXDRInto(xw)
+func (o ConnectRequest) XDRSize() int {
+	return 4 + len(o.ID) + xdr.Padding(len(o.ID))
 }
 
 func (o ConnectRequest) MarshalXDR() ([]byte, error) {
-	return o.AppendXDR(make([]byte, 0, 128))
+	buf := make([]byte, o.XDRSize())
+	m := &xdr.Marshaller{Data: buf}
+	return buf, o.MarshalXDRInto(m)
 }
 
 func (o ConnectRequest) MustMarshalXDR() []byte {
@@ -433,35 +351,21 @@ func (o ConnectRequest) MustMarshalXDR() []byte {
 	return bs
 }
 
-func (o ConnectRequest) AppendXDR(bs []byte) ([]byte, error) {
-	var aw = xdr.AppendWriter(bs)
-	var xw = xdr.NewWriter(&aw)
-	_, err := o.EncodeXDRInto(xw)
-	return []byte(aw), err
-}
-
-func (o ConnectRequest) EncodeXDRInto(xw *xdr.Writer) (int, error) {
+func (o ConnectRequest) MarshalXDRInto(m *xdr.Marshaller) error {
 	if l := len(o.ID); l > 32 {
-		return xw.Tot(), xdr.ElementSizeExceeded("ID", l, 32)
+		return xdr.ElementSizeExceeded("ID", l, 32)
 	}
-	xw.WriteBytes(o.ID)
-	return xw.Tot(), xw.Error()
-}
-
-func (o *ConnectRequest) DecodeXDR(r io.Reader) error {
-	xr := xdr.NewReader(r)
-	return o.DecodeXDRFrom(xr)
+	m.MarshalBytes(o.ID)
+	return m.Error
 }
 
 func (o *ConnectRequest) UnmarshalXDR(bs []byte) error {
-	var br = bytes.NewReader(bs)
-	var xr = xdr.NewReader(br)
-	return o.DecodeXDRFrom(xr)
+	u := &xdr.Unmarshaller{Data: bs}
+	return o.UnmarshalXDRFrom(u)
 }
-
-func (o *ConnectRequest) DecodeXDRFrom(xr *xdr.Reader) error {
-	o.ID = xr.ReadBytesMax(32)
-	return xr.Error()
+func (o *ConnectRequest) UnmarshalXDRFrom(u *xdr.Unmarshaller) error {
+	o.ID = u.UnmarshalBytesMax(32)
+	return u.Error
 }
 
 /*
@@ -471,25 +375,19 @@ SessionInvitation Structure:
  0                   1                   2                   3
  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                        Length of From                         |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 /                                                               /
-\                    From (variable length)                     \
+\                  From (length + padded data)                  \
 /                                                               /
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                         Length of Key                         |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 /                                                               /
-\                     Key (variable length)                     \
+\                  Key (length + padded data)                   \
 /                                                               /
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                       Length of Address                       |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 /                                                               /
-\                   Address (variable length)                   \
+\                Address (length + padded data)                 \
 /                                                               /
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|            0x0000             |             Port              |
+|         16 zero bits          |             Port              |
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 |                  Server Socket (V=0 or 1)                   |V|
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
@@ -505,13 +403,16 @@ struct SessionInvitation {
 
 */
 
-func (o SessionInvitation) EncodeXDR(w io.Writer) (int, error) {
-	var xw = xdr.NewWriter(w)
-	return o.EncodeXDRInto(xw)
+func (o SessionInvitation) XDRSize() int {
+	return 4 + len(o.From) + xdr.Padding(len(o.From)) +
+		4 + len(o.Key) + xdr.Padding(len(o.Key)) +
+		4 + len(o.Address) + xdr.Padding(len(o.Address)) + 4 + 4
 }
 
 func (o SessionInvitation) MarshalXDR() ([]byte, error) {
-	return o.AppendXDR(make([]byte, 0, 128))
+	buf := make([]byte, o.XDRSize())
+	m := &xdr.Marshaller{Data: buf}
+	return buf, o.MarshalXDRInto(m)
 }
 
 func (o SessionInvitation) MustMarshalXDR() []byte {
@@ -522,47 +423,33 @@ func (o SessionInvitation) MustMarshalXDR() []byte {
 	return bs
 }
 
-func (o SessionInvitation) AppendXDR(bs []byte) ([]byte, error) {
-	var aw = xdr.AppendWriter(bs)
-	var xw = xdr.NewWriter(&aw)
-	_, err := o.EncodeXDRInto(xw)
-	return []byte(aw), err
-}
-
-func (o SessionInvitation) EncodeXDRInto(xw *xdr.Writer) (int, error) {
+func (o SessionInvitation) MarshalXDRInto(m *xdr.Marshaller) error {
 	if l := len(o.From); l > 32 {
-		return xw.Tot(), xdr.ElementSizeExceeded("From", l, 32)
+		return xdr.ElementSizeExceeded("From", l, 32)
 	}
-	xw.WriteBytes(o.From)
+	m.MarshalBytes(o.From)
 	if l := len(o.Key); l > 32 {
-		return xw.Tot(), xdr.ElementSizeExceeded("Key", l, 32)
+		return xdr.ElementSizeExceeded("Key", l, 32)
 	}
-	xw.WriteBytes(o.Key)
+	m.MarshalBytes(o.Key)
 	if l := len(o.Address); l > 32 {
-		return xw.Tot(), xdr.ElementSizeExceeded("Address", l, 32)
+		return xdr.ElementSizeExceeded("Address", l, 32)
 	}
-	xw.WriteBytes(o.Address)
-	xw.WriteUint16(o.Port)
-	xw.WriteBool(o.ServerSocket)
-	return xw.Tot(), xw.Error()
-}
-
-func (o *SessionInvitation) DecodeXDR(r io.Reader) error {
-	xr := xdr.NewReader(r)
-	return o.DecodeXDRFrom(xr)
+	m.MarshalBytes(o.Address)
+	m.MarshalUint16(o.Port)
+	m.MarshalBool(o.ServerSocket)
+	return m.Error
 }
 
 func (o *SessionInvitation) UnmarshalXDR(bs []byte) error {
-	var br = bytes.NewReader(bs)
-	var xr = xdr.NewReader(br)
-	return o.DecodeXDRFrom(xr)
-}
-
-func (o *SessionInvitation) DecodeXDRFrom(xr *xdr.Reader) error {
-	o.From = xr.ReadBytesMax(32)
-	o.Key = xr.ReadBytesMax(32)
-	o.Address = xr.ReadBytesMax(32)
-	o.Port = xr.ReadUint16()
-	o.ServerSocket = xr.ReadBool()
-	return xr.Error()
+	u := &xdr.Unmarshaller{Data: bs}
+	return o.UnmarshalXDRFrom(u)
+}
+func (o *SessionInvitation) UnmarshalXDRFrom(u *xdr.Unmarshaller) error {
+	o.From = u.UnmarshalBytesMax(32)
+	o.Key = u.UnmarshalBytesMax(32)
+	o.Address = u.UnmarshalBytesMax(32)
+	o.Port = u.UnmarshalUint16()
+	o.ServerSocket = u.UnmarshalBool()
+	return u.Error
 }