From 2021a219163291f41448603a79f02a131cb58c82 Mon Sep 17 00:00:00 2001 From: Marten Seemann Date: Tue, 13 Nov 2018 11:05:33 +0700 Subject: [PATCH] implement the NEW_CONNECTION_ID frame --- internal/wire/frame_parser.go | 3 +- internal/wire/frame_parser_test.go | 13 +++ internal/wire/new_connection_id_frame.go | 70 +++++++++++++++ internal/wire/new_connection_id_frame_test.go | 85 +++++++++++++++++++ session.go | 1 + 5 files changed, 171 insertions(+), 1 deletion(-) create mode 100644 internal/wire/new_connection_id_frame.go create mode 100644 internal/wire/new_connection_id_frame_test.go diff --git a/internal/wire/frame_parser.go b/internal/wire/frame_parser.go index 5b1e501e..fdba2a71 100644 --- a/internal/wire/frame_parser.go +++ b/internal/wire/frame_parser.go @@ -58,7 +58,8 @@ func parseFrame(r *bytes.Reader, typeByte byte, v protocol.VersionNumber) (Frame frame, err = parseStreamDataBlockedFrame(r, v) case 0x16, 0x17: frame, err = parseStreamsBlockedFrame(r, v) - // TODO: implement NEW_CONNECTION_ID frame + case 0x18: + frame, err = parseNewConnectionIDFrame(r, v) // TODO: implement RETIRE_CONNECTION_ID frame case 0x1a: frame, err = parsePathChallengeFrame(r, v) diff --git a/internal/wire/frame_parser_test.go b/internal/wire/frame_parser_test.go index e3f138e7..053f6682 100644 --- a/internal/wire/frame_parser_test.go +++ b/internal/wire/frame_parser_test.go @@ -183,6 +183,19 @@ var _ = Describe("Frame parsing", func() { Expect(frame).To(Equal(f)) }) + It("unpacks NEW_CONNECTION_ID frames", func() { + f := &NewConnectionIDFrame{ + SequenceNumber: 0x1337, + ConnectionID: protocol.ConnectionID{0xde, 0xad, 0xbe, 0xef}, + StatelessResetToken: [16]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}, + } + buf := &bytes.Buffer{} + Expect(f.Write(buf, versionIETFFrames)).To(Succeed()) + frame, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), versionIETFFrames) + Expect(err).ToNot(HaveOccurred()) + Expect(frame).To(Equal(f)) + }) + It("unpacks PATH_CHALLENGE frames", func() { f := &PathChallengeFrame{Data: [8]byte{1, 2, 3, 4, 5, 6, 7, 8}} err := f.Write(buf, versionIETFFrames) diff --git a/internal/wire/new_connection_id_frame.go b/internal/wire/new_connection_id_frame.go new file mode 100644 index 00000000..9a612aa6 --- /dev/null +++ b/internal/wire/new_connection_id_frame.go @@ -0,0 +1,70 @@ +package wire + +import ( + "bytes" + "fmt" + "io" + + "github.com/lucas-clemente/quic-go/internal/utils" + + "github.com/lucas-clemente/quic-go/internal/protocol" +) + +// A NewConnectionIDFrame is a NEW_CONNECTION_ID frame +type NewConnectionIDFrame struct { + SequenceNumber uint64 + ConnectionID protocol.ConnectionID + StatelessResetToken [16]byte +} + +func parseNewConnectionIDFrame(r *bytes.Reader, _ protocol.VersionNumber) (*NewConnectionIDFrame, error) { + if _, err := r.ReadByte(); err != nil { + return nil, err + } + + seq, err := utils.ReadVarInt(r) + if err != nil { + return nil, err + } + connIDLen, err := r.ReadByte() + if err != nil { + return nil, err + } + if connIDLen < 4 || connIDLen > 18 { + return nil, fmt.Errorf("invalid connection ID length: %d", connIDLen) + } + connID, err := protocol.ReadConnectionID(r, int(connIDLen)) + if err != nil { + return nil, err + } + frame := &NewConnectionIDFrame{ + SequenceNumber: seq, + ConnectionID: connID, + } + if _, err := io.ReadFull(r, frame.StatelessResetToken[:]); err != nil { + if err == io.ErrUnexpectedEOF { + return nil, io.EOF + } + return nil, err + } + + return frame, nil +} + +func (f *NewConnectionIDFrame) Write(b *bytes.Buffer, _ protocol.VersionNumber) error { + b.WriteByte(0x18) + utils.WriteVarInt(b, f.SequenceNumber) + connIDLen := f.ConnectionID.Len() + if connIDLen < 4 || connIDLen > 18 { + return fmt.Errorf("invalid connection ID length: %d", connIDLen) + } + b.WriteByte(uint8(connIDLen)) + b.Write(f.ConnectionID.Bytes()) + b.Write(f.StatelessResetToken[:]) + return nil +} + +// Length of a written frame +func (f *NewConnectionIDFrame) Length(protocol.VersionNumber) protocol.ByteCount { + return 1 + utils.VarIntLen(f.SequenceNumber) + 1 /* connection ID length */ + protocol.ByteCount(f.ConnectionID.Len()) + 16 +} diff --git a/internal/wire/new_connection_id_frame_test.go b/internal/wire/new_connection_id_frame_test.go new file mode 100644 index 00000000..55c38a81 --- /dev/null +++ b/internal/wire/new_connection_id_frame_test.go @@ -0,0 +1,85 @@ +package wire + +import ( + "bytes" + "io" + + "github.com/lucas-clemente/quic-go/internal/protocol" + + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" +) + +var _ = Describe("NEW_CONNECTION_ID frame", func() { + Context("when parsing", func() { + It("accepts a sample frame", func() { + data := []byte{0x18} + data = append(data, encodeVarInt(0xdeadbeef)...) // sequence number + data = append(data, 10) // connection ID length + data = append(data, []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}...) // connection ID + data = append(data, []byte("deadbeefdecafbad")...) // stateless reset token + b := bytes.NewReader(data) + frame, err := parseNewConnectionIDFrame(b, versionIETFFrames) + Expect(err).ToNot(HaveOccurred()) + Expect(frame.SequenceNumber).To(Equal(uint64(0xdeadbeef))) + Expect(frame.ConnectionID).To(Equal(protocol.ConnectionID{1, 2, 3, 4, 5, 6, 7, 8, 9, 10})) + Expect(string(frame.StatelessResetToken[:])).To(Equal("deadbeefdecafbad")) + }) + + It("errors when the connection ID has an invalid length", func() { + data := []byte{0x18} + data = append(data, encodeVarInt(0xdeadbeef)...) // sequence number + data = append(data, 3) // connection ID length + data = append(data, []byte{1, 2, 3}...) // connection ID + data = append(data, []byte("deadbeefdecafbad")...) // stateless reset token + b := bytes.NewReader(data) + _, err := parseNewConnectionIDFrame(b, versionIETFFrames) + Expect(err).To(MatchError("invalid connection ID length: 3")) + }) + + It("errors on EOFs", func() { + data := []byte{0x18} + data = append(data, encodeVarInt(0xdeadbeef)...) // sequence number + data = append(data, 10) // connection ID length + data = append(data, []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}...) // connection ID + data = append(data, []byte("deadbeefdecafbad")...) // stateless reset token + _, err := parseNewConnectionIDFrame(bytes.NewReader(data), versionIETFFrames) + Expect(err).NotTo(HaveOccurred()) + for i := range data { + _, err := parseNewConnectionIDFrame(bytes.NewReader(data[0:i]), versionIETFFrames) + Expect(err).To(MatchError(io.EOF)) + } + }) + }) + + Context("when writing", func() { + It("writes a sample frame", func() { + token := [16]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15} + frame := &NewConnectionIDFrame{ + SequenceNumber: 0x1337, + ConnectionID: protocol.ConnectionID{1, 2, 3, 4, 5, 6}, + StatelessResetToken: token, + } + b := &bytes.Buffer{} + Expect(frame.Write(b, versionIETFFrames)).To(Succeed()) + expected := []byte{0x18} + expected = append(expected, encodeVarInt(0x1337)...) + expected = append(expected, 6) + expected = append(expected, []byte{1, 2, 3, 4, 5, 6}...) + expected = append(expected, token[:]...) + Expect(b.Bytes()).To(Equal(expected)) + }) + + It("has the correct length", func() { + token := [16]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15} + frame := &NewConnectionIDFrame{ + SequenceNumber: 0xdecafbad, + ConnectionID: protocol.ConnectionID{1, 2, 3, 4, 5, 6, 7, 8}, + StatelessResetToken: token, + } + b := &bytes.Buffer{} + Expect(frame.Write(b, versionIETFFrames)).To(Succeed()) + Expect(frame.Length(versionIETFFrames)).To(BeEquivalentTo(b.Len())) + }) + }) +}) diff --git a/session.go b/session.go index bfa4e279..3b4d6db9 100644 --- a/session.go +++ b/session.go @@ -579,6 +579,7 @@ func (s *session) handleFrames(fs []wire.Frame, encLevel protocol.EncryptionLeve // since we don't send PATH_CHALLENGEs, we don't expect PATH_RESPONSEs err = errors.New("unexpected PATH_RESPONSE frame") case *wire.NewTokenFrame: + case *wire.NewConnectionIDFrame: default: return errors.New("Session BUG: unexpected frame type") }