mirrors/uquic
1
0
Fork 0
mirror of https://github.com/refraction-networking/uquic.git synced 2025-04-04 20:57:36 +03:00
Code Issues Projects Releases Packages Wiki Activity

change the transport parameter format to varint

Browse source
This commit is contained in:
Marten Seemann 2020-02-08 18:04:49 +01:00
parent f5d88d3edd
commit 9ee6efd506
2 changed files with 65 additions and 105 deletions
Download patch file Download diff file Expand all files Collapse all files

107
internal/handshake/transport_parameter_test.go
View file

@ -2,7 +2,6 @@ package handshake
import ( import (
"bytes" "bytes"
"encoding/binary"
"fmt" "fmt"
"math" "math"
"math/rand" "math/rand"
@ -16,12 +15,6 @@ import (
) )
var _ = Describe("Transport Parameters", func() { var _ = Describe("Transport Parameters", func() {
prependLength := func(tp []byte) []byte {
data := make([]byte, 2)
binary.BigEndian.PutUint16(data, uint16(len(tp)))
return append(data, tp...)
}
getRandomValue := func() uint64 { getRandomValue := func() uint64 {
maxVals := []int64{math.MaxUint8 / 4, math.MaxUint16 / 4, math.MaxUint32 / 4, math.MaxUint64 / 4} maxVals := []int64{math.MaxUint8 / 4, math.MaxUint16 / 4, math.MaxUint32 / 4, math.MaxUint64 / 4}
return uint64(rand.Int63n(maxVals[int(rand.Int31n(4))])) return uint64(rand.Int63n(maxVals[int(rand.Int31n(4))]))
@ -103,42 +96,31 @@ var _ = Describe("Transport Parameters", func() {
Expect(p.ActiveConnectionIDLimit).To(Equal(params.ActiveConnectionIDLimit)) Expect(p.ActiveConnectionIDLimit).To(Equal(params.ActiveConnectionIDLimit))
}) })
It("errors if the transport parameters are too short to contain the length", func() {
Expect((&TransportParameters{}).Unmarshal([]byte{0}, protocol.PerspectiveClient)).To(MatchError("TRANSPORT_PARAMETER_ERROR: transport parameter data too short"))
})
It("errors if the transport parameters are too short to contain the length", func() {
data := make([]byte, 2)
binary.BigEndian.PutUint16(data, 42)
data = append(data, make([]byte, 41)...)
Expect((&TransportParameters{}).Unmarshal(data, protocol.PerspectiveClient)).To(MatchError("TRANSPORT_PARAMETER_ERROR: expected transport parameters to be 42 bytes long, have 41"))
})
It("errors when the stateless_reset_token has the wrong length", func() { It("errors when the stateless_reset_token has the wrong length", func() {
b := &bytes.Buffer{} b := &bytes.Buffer{}
utils.BigEndian.WriteUint16(b, uint16(statelessResetTokenParameterID)) utils.WriteVarInt(b, uint64(statelessResetTokenParameterID))
utils.BigEndian.WriteUint16(b, 15) utils.WriteVarInt(b, 15)
b.Write(make([]byte, 15)) b.Write(make([]byte, 15))
p := &TransportParameters{} p := &TransportParameters{}
Expect(p.Unmarshal(prependLength(b.Bytes()), protocol.PerspectiveServer)).To(MatchError("TRANSPORT_PARAMETER_ERROR: wrong length for stateless_reset_token: 15 (expected 16)")) Expect(p.Unmarshal(b.Bytes(), protocol.PerspectiveServer)).To(MatchError("TRANSPORT_PARAMETER_ERROR: wrong length for stateless_reset_token: 15 (expected 16)"))
}) })
It("errors when the max_packet_size is too small", func() { It("errors when the max_packet_size is too small", func() {
b := &bytes.Buffer{} b := &bytes.Buffer{}
utils.BigEndian.WriteUint16(b, uint16(maxPacketSizeParameterID)) utils.WriteVarInt(b, uint64(maxPacketSizeParameterID))
utils.BigEndian.WriteUint16(b, uint16(utils.VarIntLen(1199))) utils.WriteVarInt(b, uint64(utils.VarIntLen(1199)))
utils.WriteVarInt(b, 1199) utils.WriteVarInt(b, 1199)
p := &TransportParameters{} p := &TransportParameters{}
Expect(p.Unmarshal(prependLength(b.Bytes()), protocol.PerspectiveServer)).To(MatchError("TRANSPORT_PARAMETER_ERROR: invalid value for max_packet_size: 1199 (minimum 1200)")) Expect(p.Unmarshal(b.Bytes(), protocol.PerspectiveServer)).To(MatchError("TRANSPORT_PARAMETER_ERROR: invalid value for max_packet_size: 1199 (minimum 1200)"))
}) })
It("errors when disable_active_migration has content", func() { It("errors when disable_active_migration has content", func() {
b := &bytes.Buffer{} b := &bytes.Buffer{}
utils.BigEndian.WriteUint16(b, uint16(disableActiveMigrationParameterID)) utils.WriteVarInt(b, uint64(disableActiveMigrationParameterID))
utils.BigEndian.WriteUint16(b, 6) utils.WriteVarInt(b, 6)
b.Write([]byte("foobar")) b.Write([]byte("foobar"))
p := &TransportParameters{} p := &TransportParameters{}
Expect(p.Unmarshal(prependLength(b.Bytes()), protocol.PerspectiveServer)).To(MatchError("TRANSPORT_PARAMETER_ERROR: wrong length for disable_active_migration: 6 (expected empty)")) Expect(p.Unmarshal(b.Bytes(), protocol.PerspectiveServer)).To(MatchError("TRANSPORT_PARAMETER_ERROR: wrong length for disable_active_migration: 6 (expected empty)"))
}) })
It("errors when the max_ack_delay is too large", func() { It("errors when the max_ack_delay is too large", func() {
@ -151,13 +133,15 @@ var _ = Describe("Transport Parameters", func() {
const num = 1000 const num = 1000
var defaultLen, dataLen int var defaultLen, dataLen int
// marshal 1000 times to average out the greasing transport parameter // marshal 1000 times to average out the greasing transport parameter
maxAckDelay := protocol.DefaultMaxAckDelay + time.Millisecond
for i := 0; i < num; i++ { for i := 0; i < num; i++ {
dataDefault := (&TransportParameters{MaxAckDelay: protocol.DefaultMaxAckDelay}).Marshal() dataDefault := (&TransportParameters{MaxAckDelay: protocol.DefaultMaxAckDelay}).Marshal()
defaultLen += len(dataDefault) defaultLen += len(dataDefault)
data := (&TransportParameters{MaxAckDelay: protocol.DefaultMaxAckDelay + time.Millisecond}).Marshal() data := (&TransportParameters{MaxAckDelay: maxAckDelay}).Marshal()
dataLen += len(data) dataLen += len(data)
} }
Expect(float32(dataLen) / num).To(BeNumerically("~", float32(defaultLen)/num+2 /* parameter ID */ +2 /* length field */ +1 /* value */, 1)) entryLen := utils.VarIntLen(uint64(ackDelayExponentParameterID)) /* parameter id */ + utils.VarIntLen(uint64(utils.VarIntLen(uint64(maxAckDelay.Milliseconds())))) /*length */ + utils.VarIntLen(uint64(maxAckDelay.Milliseconds())) /* value */
Expect(float32(dataLen) / num).To(BeNumerically("~", float32(defaultLen)/num+float32(entryLen), 1))
}) })
It("errors when the ack_delay_exponenent is too large", func() { It("errors when the ack_delay_exponenent is too large", func() {
@ -176,7 +160,8 @@ var _ = Describe("Transport Parameters", func() {
data := (&TransportParameters{AckDelayExponent: protocol.DefaultAckDelayExponent + 1}).Marshal() data := (&TransportParameters{AckDelayExponent: protocol.DefaultAckDelayExponent + 1}).Marshal()
dataLen += len(data) dataLen += len(data)
} }
Expect(float32(dataLen) / num).To(BeNumerically("~", float32(defaultLen)/num+2 /* parameter ID */ +2 /* length field */ +1 /* value */, 1)) entryLen := utils.VarIntLen(uint64(ackDelayExponentParameterID)) /* parameter id */ + utils.VarIntLen(uint64(utils.VarIntLen(protocol.DefaultAckDelayExponent+1))) /* length */ + utils.VarIntLen(protocol.DefaultAckDelayExponent+1) /* value */
Expect(float32(dataLen) / num).To(BeNumerically("~", float32(defaultLen)/num+float32(entryLen), 1))
}) })
It("sets the default value for the ack_delay_exponent, when no value was sent", func() { It("sets the default value for the ack_delay_exponent, when no value was sent", func() {
@ -188,13 +173,13 @@ var _ = Describe("Transport Parameters", func() {
It("errors when the varint value has the wrong length", func() { It("errors when the varint value has the wrong length", func() {
b := &bytes.Buffer{} b := &bytes.Buffer{}
utils.BigEndian.WriteUint16(b, uint16(initialMaxStreamDataBidiLocalParameterID)) utils.WriteVarInt(b, uint64(initialMaxStreamDataBidiLocalParameterID))
utils.BigEndian.WriteUint16(b, 2) utils.WriteVarInt(b, 2)
val := uint64(0xdeadbeef) val := uint64(0xdeadbeef)
Expect(utils.VarIntLen(val)).ToNot(BeEquivalentTo(2)) Expect(utils.VarIntLen(val)).ToNot(BeEquivalentTo(2))
utils.WriteVarInt(b, val) utils.WriteVarInt(b, val)
p := &TransportParameters{} p := &TransportParameters{}
err := p.Unmarshal(prependLength(b.Bytes()), protocol.PerspectiveServer) err := p.Unmarshal(b.Bytes(), protocol.PerspectiveServer)
Expect(err).To(HaveOccurred()) Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("TRANSPORT_PARAMETER_ERROR: inconsistent transport parameter length")) Expect(err.Error()).To(ContainSubstring("TRANSPORT_PARAMETER_ERROR: inconsistent transport parameter length"))
}) })
@ -202,30 +187,30 @@ var _ = Describe("Transport Parameters", func() {
It("handles max_ack_delays that decode to a negative duration", func() { It("handles max_ack_delays that decode to a negative duration", func() {
b := &bytes.Buffer{} b := &bytes.Buffer{}
val := uint64(math.MaxUint64) / 5 val := uint64(math.MaxUint64) / 5
utils.BigEndian.WriteUint16(b, uint16(maxAckDelayParameterID)) utils.WriteVarInt(b, uint64(maxAckDelayParameterID))
utils.BigEndian.WriteUint16(b, uint16(utils.VarIntLen(val))) utils.WriteVarInt(b, uint64(utils.VarIntLen(val)))
utils.WriteVarInt(b, val) utils.WriteVarInt(b, val)
p := &TransportParameters{} p := &TransportParameters{}
Expect(p.Unmarshal(prependLength(b.Bytes()), protocol.PerspectiveServer)).To(Succeed()) Expect(p.Unmarshal(b.Bytes(), protocol.PerspectiveServer)).To(Succeed())
Expect(p.MaxAckDelay).To(BeNumerically(">", 290*365*24*time.Hour)) Expect(p.MaxAckDelay).To(BeNumerically(">", 290*365*24*time.Hour))
}) })
It("skips unknown parameters", func() { It("skips unknown parameters", func() {
b := &bytes.Buffer{} b := &bytes.Buffer{}
// write a known parameter // write a known parameter
utils.BigEndian.WriteUint16(b, uint16(initialMaxStreamDataBidiLocalParameterID)) utils.WriteVarInt(b, uint64(initialMaxStreamDataBidiLocalParameterID))
utils.BigEndian.WriteUint16(b, uint16(utils.VarIntLen(0x1337))) utils.WriteVarInt(b, uint64(utils.VarIntLen(0x1337)))
utils.WriteVarInt(b, 0x1337) utils.WriteVarInt(b, 0x1337)
// write an unknown parameter // write an unknown parameter
utils.BigEndian.WriteUint16(b, 0x42) utils.WriteVarInt(b, 0x42)
utils.BigEndian.WriteUint16(b, 6) utils.WriteVarInt(b, 6)
b.Write([]byte("foobar")) b.Write([]byte("foobar"))
// write a known parameter // write a known parameter
utils.BigEndian.WriteUint16(b, uint16(initialMaxStreamDataBidiRemoteParameterID)) utils.WriteVarInt(b, uint64(initialMaxStreamDataBidiRemoteParameterID))
utils.BigEndian.WriteUint16(b, uint16(utils.VarIntLen(0x42))) utils.WriteVarInt(b, uint64(utils.VarIntLen(0x42)))
utils.WriteVarInt(b, 0x42) utils.WriteVarInt(b, 0x42)
p := &TransportParameters{} p := &TransportParameters{}
Expect(p.Unmarshal(prependLength(b.Bytes()), protocol.PerspectiveServer)).To(Succeed()) Expect(p.Unmarshal(b.Bytes(), protocol.PerspectiveServer)).To(Succeed())
Expect(p.InitialMaxStreamDataBidiLocal).To(Equal(protocol.ByteCount(0x1337))) Expect(p.InitialMaxStreamDataBidiLocal).To(Equal(protocol.ByteCount(0x1337)))
Expect(p.InitialMaxStreamDataBidiRemote).To(Equal(protocol.ByteCount(0x42))) Expect(p.InitialMaxStreamDataBidiRemote).To(Equal(protocol.ByteCount(0x42)))
}) })
@ -233,40 +218,30 @@ var _ = Describe("Transport Parameters", func() {
It("rejects duplicate parameters", func() { It("rejects duplicate parameters", func() {
b := &bytes.Buffer{} b := &bytes.Buffer{}
// write first parameter // write first parameter
utils.BigEndian.WriteUint16(b, uint16(initialMaxStreamDataBidiLocalParameterID)) utils.WriteVarInt(b, uint64(initialMaxStreamDataBidiLocalParameterID))
utils.BigEndian.WriteUint16(b, uint16(utils.VarIntLen(0x1337))) utils.WriteVarInt(b, uint64(utils.VarIntLen(0x1337)))
utils.WriteVarInt(b, 0x1337) utils.WriteVarInt(b, 0x1337)
// write a second parameter // write a second parameter
utils.BigEndian.WriteUint16(b, uint16(initialMaxStreamDataBidiRemoteParameterID)) utils.WriteVarInt(b, uint64(initialMaxStreamDataBidiRemoteParameterID))
utils.BigEndian.WriteUint16(b, uint16(utils.VarIntLen(0x42))) utils.WriteVarInt(b, uint64(utils.VarIntLen(0x42)))
utils.WriteVarInt(b, 0x42) utils.WriteVarInt(b, 0x42)
// write first parameter again // write first parameter again
utils.BigEndian.WriteUint16(b, uint16(initialMaxStreamDataBidiLocalParameterID)) utils.WriteVarInt(b, uint64(initialMaxStreamDataBidiLocalParameterID))
utils.BigEndian.WriteUint16(b, uint16(utils.VarIntLen(0x1337))) utils.WriteVarInt(b, uint64(utils.VarIntLen(0x1337)))
utils.WriteVarInt(b, 0x1337) utils.WriteVarInt(b, 0x1337)
p := &TransportParameters{} p := &TransportParameters{}
err := p.Unmarshal(prependLength(b.Bytes()), protocol.PerspectiveServer) err := p.Unmarshal(b.Bytes(), protocol.PerspectiveServer)
Expect(err).To(HaveOccurred()) Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("received duplicate transport parameter")) Expect(err.Error()).To(ContainSubstring("received duplicate transport parameter"))
}) })
It("errors if there's not enough data to read", func() { It("errors if there's not enough data to read", func() {
b := &bytes.Buffer{} b := &bytes.Buffer{}
utils.BigEndian.WriteUint16(b, 0x42) utils.WriteVarInt(b, 0x42)
utils.BigEndian.WriteUint16(b, 7) utils.WriteVarInt(b, 7)
b.Write([]byte("foobar")) b.Write([]byte("foobar"))
p := &TransportParameters{} p := &TransportParameters{}
Expect(p.Unmarshal(prependLength(b.Bytes()), protocol.PerspectiveServer)).To(MatchError("TRANSPORT_PARAMETER_ERROR: remaining length (6) smaller than parameter length (7)")) Expect(p.Unmarshal(b.Bytes(), protocol.PerspectiveServer)).To(MatchError("TRANSPORT_PARAMETER_ERROR: remaining length (6) smaller than parameter length (7)"))
})
It("errors if there's unprocessed data after reading", func() {
b := &bytes.Buffer{}
utils.BigEndian.WriteUint16(b, uint16(initialMaxStreamDataBidiLocalParameterID))
utils.BigEndian.WriteUint16(b, uint16(utils.VarIntLen(0x1337)))
utils.WriteVarInt(b, 0x1337)
b.Write([]byte("foo"))
p := &TransportParameters{}
Expect(p.Unmarshal(prependLength(b.Bytes()), protocol.PerspectiveServer)).To(MatchError("TRANSPORT_PARAMETER_ERROR: should have read all data. Still have 3 bytes"))
}) })
It("errors if the client sent a stateless_reset_token", func() { It("errors if the client sent a stateless_reset_token", func() {
@ -324,10 +299,10 @@ var _ = Describe("Transport Parameters", func() {
} }
for i := 1; i < len(raw); i++ { for i := 1; i < len(raw); i++ {
buf := &bytes.Buffer{} buf := &bytes.Buffer{}
utils.BigEndian.WriteUint16(buf, uint16(preferredAddressParamaterID)) utils.WriteVarInt(buf, uint64(preferredAddressParamaterID))
buf.Write(prependLength(raw[:i])) buf.Write(raw[:i])
p := &TransportParameters{} p := &TransportParameters{}
Expect(p.Unmarshal(prependLength(buf.Bytes()), protocol.PerspectiveServer)).ToNot(Succeed()) Expect(p.Unmarshal(buf.Bytes(), protocol.PerspectiveServer)).ToNot(Succeed())
} }
}) })
}) })

63
internal/handshake/transport_parameters.go
View file

@ -2,7 +2,6 @@ package handshake
import ( import (
"bytes" "bytes"
"encoding/binary"
"errors" "errors"
"fmt" "fmt"
"io" "io"
@ -23,7 +22,7 @@ func init() {
rand.Seed(time.Now().UTC().UnixNano()) rand.Seed(time.Now().UTC().UnixNano())
} }
type transportParameterID uint16 type transportParameterID uint64
const ( const (
originalConnectionIDParameterID transportParameterID = 0x0 originalConnectionIDParameterID transportParameterID = 0x0
@ -88,25 +87,23 @@ func (p *TransportParameters) Unmarshal(data []byte, sentBy protocol.Perspective
} }
func (p *TransportParameters) unmarshal(data []byte, sentBy protocol.Perspective) error { func (p *TransportParameters) unmarshal(data []byte, sentBy protocol.Perspective) error {
if len(data) < 2 {
return errors.New("transport parameter data too short")
}
length := binary.BigEndian.Uint16(data[:2])
if len(data)-2 < int(length) {
return fmt.Errorf("expected transport parameters to be %d bytes long, have %d", length, len(data)-2)
}
// needed to check that every parameter is only sent at most once // needed to check that every parameter is only sent at most once
var parameterIDs []transportParameterID var parameterIDs []transportParameterID
var readAckDelayExponent bool var readAckDelayExponent bool
var readMaxAckDelay bool var readMaxAckDelay bool
r := bytes.NewReader(data[2:]) r := bytes.NewReader(data)
for r.Len() >= 4 { for r.Len() > 0 {
paramIDInt, _ := utils.BigEndian.ReadUint16(r) paramIDInt, err := utils.ReadVarInt(r)
if err != nil {
return err
}
paramID := transportParameterID(paramIDInt) paramID := transportParameterID(paramIDInt)
paramLen, _ := utils.BigEndian.ReadUint16(r) paramLen, err := utils.ReadVarInt(r)
if err != nil {
return err
}
parameterIDs = append(parameterIDs, paramID) parameterIDs = append(parameterIDs, paramID)
switch paramID { switch paramID {
case ackDelayExponentParameterID: case ackDelayExponentParameterID:
@ -187,9 +184,6 @@ func (p *TransportParameters) unmarshal(data []byte, sentBy protocol.Perspective
} }
} }
if r.Len() != 0 {
return fmt.Errorf("should have read all data. Still have %d bytes", r.Len())
}
return nil return nil
} }
@ -293,14 +287,13 @@ func (p *TransportParameters) readNumericTransportParameter(
// Marshal the transport parameters // Marshal the transport parameters
func (p *TransportParameters) Marshal() []byte { func (p *TransportParameters) Marshal() []byte {
b := &bytes.Buffer{} b := &bytes.Buffer{}
b.Write([]byte{0, 0}) // length. Will be replaced later
//add a greased value //add a greased value
utils.BigEndian.WriteUint16(b, uint16(27+31*rand.Intn(100))) utils.WriteVarInt(b, uint64(27+31*rand.Intn(100)))
length := rand.Intn(16) length := rand.Intn(16)
randomData := make([]byte, length) randomData := make([]byte, length)
rand.Read(randomData) rand.Read(randomData)
utils.BigEndian.WriteUint16(b, uint16(length)) utils.WriteVarInt(b, uint64(length))
b.Write(randomData) b.Write(randomData)
// initial_max_stream_data_bidi_local // initial_max_stream_data_bidi_local
@ -331,17 +324,17 @@ func (p *TransportParameters) Marshal() []byte {
} }
// disable_active_migration // disable_active_migration
if p.DisableActiveMigration { if p.DisableActiveMigration {
utils.BigEndian.WriteUint16(b, uint16(disableActiveMigrationParameterID)) utils.WriteVarInt(b, uint64(disableActiveMigrationParameterID))
utils.BigEndian.WriteUint16(b, 0) utils.WriteVarInt(b, 0)
} }
if p.StatelessResetToken != nil { if p.StatelessResetToken != nil {
utils.BigEndian.WriteUint16(b, uint16(statelessResetTokenParameterID)) utils.WriteVarInt(b, uint64(statelessResetTokenParameterID))
utils.BigEndian.WriteUint16(b, 16) utils.WriteVarInt(b, 16)
b.Write(p.StatelessResetToken[:]) b.Write(p.StatelessResetToken[:])
} }
if p.PreferredAddress != nil { if p.PreferredAddress != nil {
utils.BigEndian.WriteUint16(b, uint16(preferredAddressParamaterID)) utils.WriteVarInt(b, uint64(preferredAddressParamaterID))
utils.BigEndian.WriteUint16(b, 4+2+16+2+1+uint16(p.PreferredAddress.ConnectionID.Len())+16) utils.WriteVarInt(b, 4+2+16+2+1+uint64(p.PreferredAddress.ConnectionID.Len())+16)
ipv4 := p.PreferredAddress.IPv4 ipv4 := p.PreferredAddress.IPv4
b.Write(ipv4[len(ipv4)-4:]) b.Write(ipv4[len(ipv4)-4:])
utils.BigEndian.WriteUint16(b, p.PreferredAddress.IPv4Port) utils.BigEndian.WriteUint16(b, p.PreferredAddress.IPv4Port)
@ -352,22 +345,19 @@ func (p *TransportParameters) Marshal() []byte {
b.Write(p.PreferredAddress.StatelessResetToken[:]) b.Write(p.PreferredAddress.StatelessResetToken[:])
} }
if p.OriginalConnectionID.Len() > 0 { if p.OriginalConnectionID.Len() > 0 {
utils.BigEndian.WriteUint16(b, uint16(originalConnectionIDParameterID)) utils.WriteVarInt(b, uint64(originalConnectionIDParameterID))
utils.BigEndian.WriteUint16(b, uint16(p.OriginalConnectionID.Len())) utils.WriteVarInt(b, uint64(p.OriginalConnectionID.Len()))
b.Write(p.OriginalConnectionID.Bytes()) b.Write(p.OriginalConnectionID.Bytes())
} }
// active_connection_id_limit // active_connection_id_limit
p.marshalVarintParam(b, activeConnectionIDLimitParameterID, p.ActiveConnectionIDLimit) p.marshalVarintParam(b, activeConnectionIDLimitParameterID, p.ActiveConnectionIDLimit)
return b.Bytes()
data := b.Bytes()
binary.BigEndian.PutUint16(data[:2], uint16(b.Len()-2))
return data
} }
func (p *TransportParameters) marshalVarintParam(b *bytes.Buffer, id transportParameterID, val uint64) { func (p *TransportParameters) marshalVarintParam(b *bytes.Buffer, id transportParameterID, val uint64) {
utils.BigEndian.WriteUint16(b, uint16(id)) utils.WriteVarInt(b, uint64(id))
utils.BigEndian.WriteUint16(b, uint16(utils.VarIntLen(val))) utils.WriteVarInt(b, uint64(utils.VarIntLen(val)))
utils.WriteVarInt(b, val) utils.WriteVarInt(b, val)
} }
@ -381,8 +371,6 @@ func (p *TransportParameters) marshalVarintParam(b *bytes.Buffer, id transportPa
// For convenience, we use the same format that we also use for sending the transport parameters. // For convenience, we use the same format that we also use for sending the transport parameters.
func (p *TransportParameters) MarshalForSessionTicket(b *bytes.Buffer) { func (p *TransportParameters) MarshalForSessionTicket(b *bytes.Buffer) {
utils.WriteVarInt(b, transportParameterMarshalingVersion) utils.WriteVarInt(b, transportParameterMarshalingVersion)
startLen := b.Len()
b.Write([]byte{0, 0}) // length. Will be replaced later
// initial_max_stream_data_bidi_local // initial_max_stream_data_bidi_local
p.marshalVarintParam(b, initialMaxStreamDataBidiLocalParameterID, uint64(p.InitialMaxStreamDataBidiLocal)) p.marshalVarintParam(b, initialMaxStreamDataBidiLocalParameterID, uint64(p.InitialMaxStreamDataBidiLocal))
@ -396,9 +384,6 @@ func (p *TransportParameters) MarshalForSessionTicket(b *bytes.Buffer) {
p.marshalVarintParam(b, initialMaxStreamsBidiParameterID, uint64(p.MaxBidiStreamNum)) p.marshalVarintParam(b, initialMaxStreamsBidiParameterID, uint64(p.MaxBidiStreamNum))
// initial_max_uni_streams // initial_max_uni_streams
p.marshalVarintParam(b, initialMaxStreamsUniParameterID, uint64(p.MaxUniStreamNum)) p.marshalVarintParam(b, initialMaxStreamsUniParameterID, uint64(p.MaxUniStreamNum))
// replace the length
binary.BigEndian.PutUint16(b.Bytes()[startLen:startLen+2], uint16(b.Len()-2-startLen))
} }
// UnmarshalFromSessionTicket unmarshals transport parameters from a session ticket. // UnmarshalFromSessionTicket unmarshals transport parameters from a session ticket.