Merge pull request #807 from lucas-clemente/type-aliases

use type aliases to clean up the API

.travis.yml

@@ -7,7 +7,6 @@ addons:
 language: go
 
 go:
-  - 1.8.x
   - 1.9
 
 # first part of the GOARCH workaround

Changelog.md

@@ -15,5 +15,5 @@
 - Changed the log level environment variable to only accept strings ("DEBUG", "INFO", "ERROR"), see [the wiki](https://github.com/lucas-clemente/quic-go/wiki/Logging) for more details.
 - Rename the `h2quic.QuicRoundTripper` to `h2quic.RoundTripper`
 - Changed `h2quic.Server.Serve()` to accept a `net.PacketConn`
-- Drop support for Go 1.7.
+- Drop support for Go 1.7 and 1.8.
 - Various bugfixes

README.md

@@ -16,7 +16,7 @@ As Google's QUIC versions are expected to converge towards the [IETF QUIC draft]
 
 ## Guides
 
-We currently support Go 1.8+.
+We currently support Go 1.9+.
 
 Installing and updating dependencies:
 

ackhandler/interfaces.go

@@ -3,18 +3,18 @@ package ackhandler
 import (
 	"time"
 
-	"github.com/lucas-clemente/quic-go/frames"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 )
 
 // SentPacketHandler handles ACKs received for outgoing packets
 type SentPacketHandler interface {
 	// SentPacket may modify the packet
 	SentPacket(packet *Packet) error
-	ReceivedAck(ackFrame *frames.AckFrame, withPacketNumber protocol.PacketNumber, recvTime time.Time) error
+	ReceivedAck(ackFrame *wire.AckFrame, withPacketNumber protocol.PacketNumber, recvTime time.Time) error
 
 	SendingAllowed() bool
-	GetStopWaitingFrame(force bool) *frames.StopWaitingFrame
+	GetStopWaitingFrame(force bool) *wire.StopWaitingFrame
 	ShouldSendRetransmittablePacket() bool
 	DequeuePacketForRetransmission() (packet *Packet)
 	GetLeastUnacked() protocol.PacketNumber
@@ -29,5 +29,5 @@ type ReceivedPacketHandler interface {
 	SetLowerLimit(protocol.PacketNumber)
 
 	GetAlarmTimeout() time.Time
-	GetAckFrame() *frames.AckFrame
+	GetAckFrame() *wire.AckFrame
 }

ackhandler/packet.go

@@ -3,15 +3,15 @@ package ackhandler
 import (
 	"time"
 
-	"github.com/lucas-clemente/quic-go/frames"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 )
 
 // A Packet is a packet
 // +gen linkedlist
 type Packet struct {
 	PacketNumber    protocol.PacketNumber
-	Frames          []frames.Frame
+	Frames          []wire.Frame
 	Length          protocol.ByteCount
 	EncryptionLevel protocol.EncryptionLevel
 
@@ -19,13 +19,13 @@ type Packet struct {
 }
 
 // GetFramesForRetransmission gets all the frames for retransmission
-func (p *Packet) GetFramesForRetransmission() []frames.Frame {
-	var fs []frames.Frame
+func (p *Packet) GetFramesForRetransmission() []wire.Frame {
+	var fs []wire.Frame
 	for _, frame := range p.Frames {
 		switch frame.(type) {
-		case *frames.AckFrame:
+		case *wire.AckFrame:
 			continue
-		case *frames.StopWaitingFrame:
+		case *wire.StopWaitingFrame:
 			continue
 		}
 		fs = append(fs, frame)

ackhandler/packet_test.go

@@ -1,37 +1,37 @@
 package ackhandler
 
 import (
-	"github.com/lucas-clemente/quic-go/frames"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
 
 var _ = Describe("Packet", func() {
 	Context("getting frames for retransmission", func() {
-		ackFrame := &frames.AckFrame{LargestAcked: 13}
-		stopWaitingFrame := &frames.StopWaitingFrame{LeastUnacked: 7331}
-		windowUpdateFrame := &frames.WindowUpdateFrame{StreamID: 999}
+		ackFrame := &wire.AckFrame{LargestAcked: 13}
+		stopWaitingFrame := &wire.StopWaitingFrame{LeastUnacked: 7331}
+		windowUpdateFrame := &wire.WindowUpdateFrame{StreamID: 999}
 
-		streamFrame := &frames.StreamFrame{
+		streamFrame := &wire.StreamFrame{
 			StreamID: 5,
 			Data:     []byte{0x13, 0x37},
 		}
 
-		rstStreamFrame := &frames.RstStreamFrame{
+		rstStreamFrame := &wire.RstStreamFrame{
 			StreamID:  555,
 			ErrorCode: 1337,
 		}
 
 		It("returns nil if there are no retransmittable frames", func() {
 			packet := &Packet{
-				Frames: []frames.Frame{ackFrame, stopWaitingFrame},
+				Frames: []wire.Frame{ackFrame, stopWaitingFrame},
 			}
 			Expect(packet.GetFramesForRetransmission()).To(BeNil())
 		})
 
 		It("returns all retransmittable frames", func() {
 			packet := &Packet{
-				Frames: []frames.Frame{
+				Frames: []wire.Frame{
 					windowUpdateFrame,
 					ackFrame,
 					stopWaitingFrame,

ackhandler/received_packet_handler.go

@@ -4,8 +4,8 @@ import (
 	"errors"
 	"time"
 
-	"github.com/lucas-clemente/quic-go/frames"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 )
 
 var errInvalidPacketNumber = errors.New("ReceivedPacketHandler: Invalid packet number")
@@ -23,7 +23,7 @@ type receivedPacketHandler struct {
 	retransmittablePacketsReceivedSinceLastAck int
 	ackQueued                                  bool
 	ackAlarm                                   time.Time
-	lastAck                                    *frames.AckFrame
+	lastAck                                    *wire.AckFrame
 
 	version protocol.VersionNumber
 }
@@ -113,13 +113,13 @@ func (h *receivedPacketHandler) maybeQueueAck(packetNumber protocol.PacketNumber
 	}
 }
 
-func (h *receivedPacketHandler) GetAckFrame() *frames.AckFrame {
+func (h *receivedPacketHandler) GetAckFrame() *wire.AckFrame {
 	if !h.ackQueued && (h.ackAlarm.IsZero() || h.ackAlarm.After(time.Now())) {
 		return nil
 	}
 
 	ackRanges := h.packetHistory.GetAckRanges()
-	ack := &frames.AckFrame{
+	ack := &wire.AckFrame{
 		LargestAcked:       h.largestObserved,
 		LowestAcked:        ackRanges[len(ackRanges)-1].FirstPacketNumber,
 		PacketReceivedTime: h.largestObservedReceivedTime,

ackhandler/received_packet_handler_test.go

@@ -3,8 +3,8 @@ package ackhandler
 import (
 	"time"
 
-	"github.com/lucas-clemente/quic-go/frames"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
@@ -221,8 +221,8 @@ var _ = Describe("receivedPacketHandler", func() {
 				Expect(ack.LargestAcked).To(Equal(protocol.PacketNumber(4)))
 				Expect(ack.LowestAcked).To(Equal(protocol.PacketNumber(1)))
 				Expect(ack.AckRanges).To(HaveLen(2))
-				Expect(ack.AckRanges[0]).To(Equal(frames.AckRange{FirstPacketNumber: 4, LastPacketNumber: 4}))
-				Expect(ack.AckRanges[1]).To(Equal(frames.AckRange{FirstPacketNumber: 1, LastPacketNumber: 1}))
+				Expect(ack.AckRanges[0]).To(Equal(wire.AckRange{FirstPacketNumber: 4, LastPacketNumber: 4}))
+				Expect(ack.AckRanges[1]).To(Equal(wire.AckRange{FirstPacketNumber: 1, LastPacketNumber: 1}))
 			})
 
 			It("accepts packets below the lower limit", func() {

ackhandler/received_packet_history.go

@@ -1,9 +1,9 @@
 package ackhandler
 
 import (
-	"github.com/lucas-clemente/quic-go/frames"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 	"github.com/lucas-clemente/quic-go/qerr"
 )
 
@@ -122,22 +122,22 @@ func (h *receivedPacketHistory) IsDuplicate(p protocol.PacketNumber) bool {
 }
 
 // GetAckRanges gets a slice of all AckRanges that can be used in an AckFrame
-func (h *receivedPacketHistory) GetAckRanges() []frames.AckRange {
+func (h *receivedPacketHistory) GetAckRanges() []wire.AckRange {
 	if h.ranges.Len() == 0 {
 		return nil
 	}
 
-	var ackRanges []frames.AckRange
+	var ackRanges []wire.AckRange
 
 	for el := h.ranges.Back(); el != nil; el = el.Prev() {
-		ackRanges = append(ackRanges, frames.AckRange{FirstPacketNumber: el.Value.Start, LastPacketNumber: el.Value.End})
+		ackRanges = append(ackRanges, wire.AckRange{FirstPacketNumber: el.Value.Start, LastPacketNumber: el.Value.End})
 	}
 
 	return ackRanges
 }
 
-func (h *receivedPacketHistory) GetHighestAckRange() frames.AckRange {
-	ackRange := frames.AckRange{}
+func (h *receivedPacketHistory) GetHighestAckRange() wire.AckRange {
+	ackRange := wire.AckRange{}
 	if h.ranges.Len() > 0 {
 		r := h.ranges.Back().Value
 		ackRange.FirstPacketNumber = r.Start

ackhandler/received_packet_history_test.go

@@ -1,9 +1,9 @@
 package ackhandler
 
 import (
-	"github.com/lucas-clemente/quic-go/frames"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
@@ -298,7 +298,7 @@ var _ = Describe("receivedPacketHistory", func() {
 			hist.ReceivedPacket(5)
 			ackRanges := hist.GetAckRanges()
 			Expect(ackRanges).To(HaveLen(1))
-			Expect(ackRanges[0]).To(Equal(frames.AckRange{FirstPacketNumber: 4, LastPacketNumber: 5}))
+			Expect(ackRanges[0]).To(Equal(wire.AckRange{FirstPacketNumber: 4, LastPacketNumber: 5}))
 		})
 
 		It("gets multiple ACK ranges", func() {
@@ -311,9 +311,9 @@ var _ = Describe("receivedPacketHistory", func() {
 			hist.ReceivedPacket(2)
 			ackRanges := hist.GetAckRanges()
 			Expect(ackRanges).To(HaveLen(3))
-			Expect(ackRanges[0]).To(Equal(frames.AckRange{FirstPacketNumber: 10, LastPacketNumber: 11}))
-			Expect(ackRanges[1]).To(Equal(frames.AckRange{FirstPacketNumber: 4, LastPacketNumber: 6}))
-			Expect(ackRanges[2]).To(Equal(frames.AckRange{FirstPacketNumber: 1, LastPacketNumber: 2}))
+			Expect(ackRanges[0]).To(Equal(wire.AckRange{FirstPacketNumber: 10, LastPacketNumber: 11}))
+			Expect(ackRanges[1]).To(Equal(wire.AckRange{FirstPacketNumber: 4, LastPacketNumber: 6}))
+			Expect(ackRanges[2]).To(Equal(wire.AckRange{FirstPacketNumber: 1, LastPacketNumber: 2}))
 		})
 	})
 
@@ -325,14 +325,14 @@ var _ = Describe("receivedPacketHistory", func() {
 		It("gets a single ACK range", func() {
 			hist.ReceivedPacket(4)
 			hist.ReceivedPacket(5)
-			Expect(hist.GetHighestAckRange()).To(Equal(frames.AckRange{FirstPacketNumber: 4, LastPacketNumber: 5}))
+			Expect(hist.GetHighestAckRange()).To(Equal(wire.AckRange{FirstPacketNumber: 4, LastPacketNumber: 5}))
 		})
 
 		It("gets the highest of multiple ACK ranges", func() {
 			hist.ReceivedPacket(3)
 			hist.ReceivedPacket(6)
 			hist.ReceivedPacket(7)
-			Expect(hist.GetHighestAckRange()).To(Equal(frames.AckRange{FirstPacketNumber: 6, LastPacketNumber: 7}))
+			Expect(hist.GetHighestAckRange()).To(Equal(wire.AckRange{FirstPacketNumber: 6, LastPacketNumber: 7}))
 		})
 	})
 })

ackhandler/retransmittable.go

@@ -1,12 +1,10 @@
 package ackhandler
 
-import (
-	"github.com/lucas-clemente/quic-go/frames"
-)
+import "github.com/lucas-clemente/quic-go/internal/wire"
 
 // Returns a new slice with all non-retransmittable frames deleted.
-func stripNonRetransmittableFrames(fs []frames.Frame) []frames.Frame {
-	res := make([]frames.Frame, 0, len(fs))
+func stripNonRetransmittableFrames(fs []wire.Frame) []wire.Frame {
+	res := make([]wire.Frame, 0, len(fs))
 	for _, f := range fs {
 		if IsFrameRetransmittable(f) {
 			res = append(res, f)
@@ -16,11 +14,11 @@ func stripNonRetransmittableFrames(fs []frames.Frame) []frames.Frame {
 }
 
 // IsFrameRetransmittable returns true if the frame should be retransmitted.
-func IsFrameRetransmittable(f frames.Frame) bool {
+func IsFrameRetransmittable(f wire.Frame) bool {
 	switch f.(type) {
-	case *frames.StopWaitingFrame:
+	case *wire.StopWaitingFrame:
 		return false
-	case *frames.AckFrame:
+	case *wire.AckFrame:
 		return false
 	default:
 		return true
@@ -28,7 +26,7 @@ func IsFrameRetransmittable(f frames.Frame) bool {
 }
 
 // HasRetransmittableFrames returns true if at least one frame is retransmittable.
-func HasRetransmittableFrames(fs []frames.Frame) bool {
+func HasRetransmittableFrames(fs []wire.Frame) bool {
 	for _, f := range fs {
 		if IsFrameRetransmittable(f) {
 			return true

ackhandler/retransmittable_test.go

@@ -3,22 +3,22 @@ package ackhandler
 import (
 	"reflect"
 
-	"github.com/lucas-clemente/quic-go/frames"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
 
 var _ = Describe("retransmittable frames", func() {
-	for fl, el := range map[frames.Frame]bool{
-		&frames.AckFrame{}:             false,
-		&frames.StopWaitingFrame{}:     false,
-		&frames.BlockedFrame{}:         true,
-		&frames.ConnectionCloseFrame{}: true,
-		&frames.GoawayFrame{}:          true,
-		&frames.PingFrame{}:            true,
-		&frames.RstStreamFrame{}:       true,
-		&frames.StreamFrame{}:          true,
-		&frames.WindowUpdateFrame{}:    true,
+	for fl, el := range map[wire.Frame]bool{
+		&wire.AckFrame{}:             false,
+		&wire.StopWaitingFrame{}:     false,
+		&wire.BlockedFrame{}:         true,
+		&wire.ConnectionCloseFrame{}: true,
+		&wire.GoawayFrame{}:          true,
+		&wire.PingFrame{}:            true,
+		&wire.RstStreamFrame{}:       true,
+		&wire.StreamFrame{}:          true,
+		&wire.WindowUpdateFrame{}:    true,
 	} {
 		f := fl
 		e := el
@@ -29,16 +29,16 @@ var _ = Describe("retransmittable frames", func() {
 		})
 
 		It("stripping non-retransmittable frames works for "+fName, func() {
-			s := []frames.Frame{f}
+			s := []wire.Frame{f}
 			if e {
-				Expect(stripNonRetransmittableFrames(s)).To(Equal([]frames.Frame{f}))
+				Expect(stripNonRetransmittableFrames(s)).To(Equal([]wire.Frame{f}))
 			} else {
 				Expect(stripNonRetransmittableFrames(s)).To(BeEmpty())
 			}
 		})
 
 		It("HasRetransmittableFrames works for "+fName, func() {
-			Expect(HasRetransmittableFrames([]frames.Frame{f})).To(Equal(e))
+			Expect(HasRetransmittableFrames([]wire.Frame{f})).To(Equal(e))
 		})
 	}
 })

ackhandler/sent_packet_handler.go

@@ -6,9 +6,9 @@ import (
 	"time"
 
 	"github.com/lucas-clemente/quic-go/congestion"
-	"github.com/lucas-clemente/quic-go/frames"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 	"github.com/lucas-clemente/quic-go/qerr"
 )
 
@@ -139,7 +139,7 @@ func (h *sentPacketHandler) SentPacket(packet *Packet) error {
 	return nil
 }
 
-func (h *sentPacketHandler) ReceivedAck(ackFrame *frames.AckFrame, withPacketNumber protocol.PacketNumber, rcvTime time.Time) error {
+func (h *sentPacketHandler) ReceivedAck(ackFrame *wire.AckFrame, withPacketNumber protocol.PacketNumber, rcvTime time.Time) error {
 	if ackFrame.LargestAcked > h.lastSentPacketNumber {
 		return errAckForUnsentPacket
 	}
@@ -187,7 +187,7 @@ func (h *sentPacketHandler) ReceivedAck(ackFrame *frames.AckFrame, withPacketNum
 	return nil
 }
 
-func (h *sentPacketHandler) determineNewlyAckedPackets(ackFrame *frames.AckFrame) ([]*PacketElement, error) {
+func (h *sentPacketHandler) determineNewlyAckedPackets(ackFrame *wire.AckFrame) ([]*PacketElement, error) {
 	var ackedPackets []*PacketElement
 	ackRangeIndex := 0
 	for el := h.packetHistory.Front(); el != nil; el = el.Next() {
@@ -332,7 +332,7 @@ func (h *sentPacketHandler) GetLeastUnacked() protocol.PacketNumber {
 	return h.largestInOrderAcked() + 1
 }
 
-func (h *sentPacketHandler) GetStopWaitingFrame(force bool) *frames.StopWaitingFrame {
+func (h *sentPacketHandler) GetStopWaitingFrame(force bool) *wire.StopWaitingFrame {
 	return h.stopWaitingManager.GetStopWaitingFrame(force)
 }
 
@@ -391,7 +391,7 @@ func (h *sentPacketHandler) computeRTOTimeout() time.Duration {
 	return utils.MinDuration(rto, maxRTOTimeout)
 }
 
-func (h *sentPacketHandler) skippedPacketsAcked(ackFrame *frames.AckFrame) bool {
+func (h *sentPacketHandler) skippedPacketsAcked(ackFrame *wire.AckFrame) bool {
 	for _, p := range h.skippedPackets {
 		if ackFrame.AcksPacket(p) {
 			return true

ackhandler/sent_packet_handler_test.go

@@ -4,8 +4,8 @@ import (
 	"time"
 
 	"github.com/lucas-clemente/quic-go/congestion"
-	"github.com/lucas-clemente/quic-go/frames"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
@@ -58,23 +58,23 @@ func (m *mockCongestion) OnPacketLost(n protocol.PacketNumber, l protocol.ByteCo
 }
 
 func retransmittablePacket(num protocol.PacketNumber) *Packet {
-	return &Packet{PacketNumber: num, Length: 1, Frames: []frames.Frame{&frames.PingFrame{}}}
+	return &Packet{PacketNumber: num, Length: 1, Frames: []wire.Frame{&wire.PingFrame{}}}
 }
 
 func nonRetransmittablePacket(num protocol.PacketNumber) *Packet {
-	return &Packet{PacketNumber: num, Length: 1, Frames: []frames.Frame{&frames.AckFrame{}}}
+	return &Packet{PacketNumber: num, Length: 1, Frames: []wire.Frame{&wire.AckFrame{}}}
 }
 
 var _ = Describe("SentPacketHandler", func() {
 	var (
 		handler     *sentPacketHandler
-		streamFrame frames.StreamFrame
+		streamFrame wire.StreamFrame
 	)
 
 	BeforeEach(func() {
 		rttStats := &congestion.RTTStats{}
 		handler = NewSentPacketHandler(rttStats).(*sentPacketHandler)
-		streamFrame = frames.StreamFrame{
+		streamFrame = wire.StreamFrame{
 			StreamID: 5,
 			Data:     []byte{0x13, 0x37},
 		}
@@ -96,8 +96,8 @@ var _ = Describe("SentPacketHandler", func() {
 
 	Context("registering sent packets", func() {
 		It("accepts two consecutive packets", func() {
-			packet1 := Packet{PacketNumber: 1, Frames: []frames.Frame{&streamFrame}, Length: 1}
-			packet2 := Packet{PacketNumber: 2, Frames: []frames.Frame{&streamFrame}, Length: 2}
+			packet1 := Packet{PacketNumber: 1, Frames: []wire.Frame{&streamFrame}, Length: 1}
+			packet2 := Packet{PacketNumber: 2, Frames: []wire.Frame{&streamFrame}, Length: 2}
 			err := handler.SentPacket(&packet1)
 			Expect(err).ToNot(HaveOccurred())
 			err = handler.SentPacket(&packet2)
@@ -110,8 +110,8 @@ var _ = Describe("SentPacketHandler", func() {
 		})
 
 		It("rejects packets with the same packet number", func() {
-			packet1 := Packet{PacketNumber: 1, Frames: []frames.Frame{&streamFrame}, Length: 1}
-			packet2 := Packet{PacketNumber: 1, Frames: []frames.Frame{&streamFrame}, Length: 2}
+			packet1 := Packet{PacketNumber: 1, Frames: []wire.Frame{&streamFrame}, Length: 1}
+			packet2 := Packet{PacketNumber: 1, Frames: []wire.Frame{&streamFrame}, Length: 2}
 			err := handler.SentPacket(&packet1)
 			Expect(err).ToNot(HaveOccurred())
 			err = handler.SentPacket(&packet2)
@@ -123,8 +123,8 @@ var _ = Describe("SentPacketHandler", func() {
 		})
 
 		It("rejects packets with decreasing packet number", func() {
-			packet1 := Packet{PacketNumber: 2, Frames: []frames.Frame{&streamFrame}, Length: 1}
-			packet2 := Packet{PacketNumber: 1, Frames: []frames.Frame{&streamFrame}, Length: 2}
+			packet1 := Packet{PacketNumber: 2, Frames: []wire.Frame{&streamFrame}, Length: 1}
+			packet2 := Packet{PacketNumber: 1, Frames: []wire.Frame{&streamFrame}, Length: 2}
 			err := handler.SentPacket(&packet1)
 			Expect(err).ToNot(HaveOccurred())
 			err = handler.SentPacket(&packet2)
@@ -135,7 +135,7 @@ var _ = Describe("SentPacketHandler", func() {
 		})
 
 		It("stores the sent time", func() {
-			packet := Packet{PacketNumber: 1, Frames: []frames.Frame{&streamFrame}, Length: 1}
+			packet := Packet{PacketNumber: 1, Frames: []wire.Frame{&streamFrame}, Length: 1}
 			err := handler.SentPacket(&packet)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(handler.packetHistory.Front().Value.SendTime.Unix()).To(BeNumerically("~", time.Now().Unix(), 1))
@@ -149,8 +149,8 @@ var _ = Describe("SentPacketHandler", func() {
 
 		Context("skipped packet numbers", func() {
 			It("works with non-consecutive packet numbers", func() {
-				packet1 := Packet{PacketNumber: 1, Frames: []frames.Frame{&streamFrame}, Length: 1}
-				packet2 := Packet{PacketNumber: 3, Frames: []frames.Frame{&streamFrame}, Length: 2}
+				packet1 := Packet{PacketNumber: 1, Frames: []wire.Frame{&streamFrame}, Length: 1}
+				packet2 := Packet{PacketNumber: 3, Frames: []wire.Frame{&streamFrame}, Length: 2}
 				err := handler.SentPacket(&packet1)
 				Expect(err).ToNot(HaveOccurred())
 				err = handler.SentPacket(&packet2)
@@ -166,9 +166,9 @@ var _ = Describe("SentPacketHandler", func() {
 			})
 
 			It("recognizes multiple skipped packets", func() {
-				packet1 := Packet{PacketNumber: 1, Frames: []frames.Frame{&streamFrame}, Length: 1}
-				packet2 := Packet{PacketNumber: 3, Frames: []frames.Frame{&streamFrame}, Length: 2}
-				packet3 := Packet{PacketNumber: 5, Frames: []frames.Frame{&streamFrame}, Length: 2}
+				packet1 := Packet{PacketNumber: 1, Frames: []wire.Frame{&streamFrame}, Length: 1}
+				packet2 := Packet{PacketNumber: 3, Frames: []wire.Frame{&streamFrame}, Length: 2}
+				packet3 := Packet{PacketNumber: 5, Frames: []wire.Frame{&streamFrame}, Length: 2}
 				err := handler.SentPacket(&packet1)
 				Expect(err).ToNot(HaveOccurred())
 				err = handler.SentPacket(&packet2)
@@ -180,8 +180,8 @@ var _ = Describe("SentPacketHandler", func() {
 			})
 
 			It("recognizes multiple consecutive skipped packets", func() {
-				packet1 := Packet{PacketNumber: 1, Frames: []frames.Frame{&streamFrame}, Length: 1}
-				packet2 := Packet{PacketNumber: 4, Frames: []frames.Frame{&streamFrame}, Length: 2}
+				packet1 := Packet{PacketNumber: 1, Frames: []wire.Frame{&streamFrame}, Length: 1}
+				packet2 := Packet{PacketNumber: 4, Frames: []wire.Frame{&streamFrame}, Length: 2}
 				err := handler.SentPacket(&packet1)
 				Expect(err).ToNot(HaveOccurred())
 				err = handler.SentPacket(&packet2)
@@ -192,7 +192,7 @@ var _ = Describe("SentPacketHandler", func() {
 
 			It("limits the lengths of the skipped packet slice", func() {
 				for i := 0; i < protocol.MaxTrackedSkippedPackets+5; i++ {
-					packet := Packet{PacketNumber: protocol.PacketNumber(2*i + 1), Frames: []frames.Frame{&streamFrame}, Length: 1}
+					packet := Packet{PacketNumber: protocol.PacketNumber(2*i + 1), Frames: []wire.Frame{&streamFrame}, Length: 1}
 					err := handler.SentPacket(&packet)
 					Expect(err).ToNot(HaveOccurred())
 				}
@@ -269,17 +269,17 @@ var _ = Describe("SentPacketHandler", func() {
 
 		BeforeEach(func() {
 			packets = []*Packet{
-				{PacketNumber: 1, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 2, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 3, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 4, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 5, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 6, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 7, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 8, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 9, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 10, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 12, Frames: []frames.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 1, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 2, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 3, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 4, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 5, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 6, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 7, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 8, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 9, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 10, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 12, Frames: []wire.Frame{&streamFrame}, Length: 1},
 			}
 			for _, packet := range packets {
 				err := handler.SentPacket(packet)
@@ -293,7 +293,7 @@ var _ = Describe("SentPacketHandler", func() {
 		Context("ACK validation", func() {
 			It("rejects duplicate ACKs", func() {
 				largestAcked := 3
-				ack := frames.AckFrame{
+				ack := wire.AckFrame{
 					LargestAcked: protocol.PacketNumber(largestAcked),
 					LowestAcked:  1,
 				}
@@ -306,7 +306,7 @@ var _ = Describe("SentPacketHandler", func() {
 			})
 
 			It("rejects out of order ACKs", func() {
-				ack := frames.AckFrame{
+				ack := wire.AckFrame{
 					LargestAcked: 3,
 				}
 				err := handler.ReceivedAck(&ack, 1337, time.Now())
@@ -319,7 +319,7 @@ var _ = Describe("SentPacketHandler", func() {
 			})
 
 			It("rejects ACKs with a too high LargestAcked packet number", func() {
-				ack := frames.AckFrame{
+				ack := wire.AckFrame{
 					LargestAcked: packets[len(packets)-1].PacketNumber + 1337,
 				}
 				err := handler.ReceivedAck(&ack, 1, time.Now())
@@ -328,7 +328,7 @@ var _ = Describe("SentPacketHandler", func() {
 			})
 
 			It("ignores repeated ACKs", func() {
-				ack := frames.AckFrame{
+				ack := wire.AckFrame{
 					LargestAcked: 3,
 					LowestAcked:  1,
 				}
@@ -342,7 +342,7 @@ var _ = Describe("SentPacketHandler", func() {
 			})
 
 			It("rejects ACKs for skipped packets", func() {
-				ack := frames.AckFrame{
+				ack := wire.AckFrame{
 					LargestAcked: 12,
 					LowestAcked:  5,
 				}
@@ -351,10 +351,10 @@ var _ = Describe("SentPacketHandler", func() {
 			})
 
 			It("accepts an ACK that correctly nacks a skipped packet", func() {
-				ack := frames.AckFrame{
+				ack := wire.AckFrame{
 					LargestAcked: 12,
 					LowestAcked:  5,
-					AckRanges: []frames.AckRange{
+					AckRanges: []wire.AckRange{
 						{FirstPacketNumber: 12, LastPacketNumber: 12},
 						{FirstPacketNumber: 5, LastPacketNumber: 10},
 					},
@@ -367,7 +367,7 @@ var _ = Describe("SentPacketHandler", func() {
 
 		Context("acks and nacks the right packets", func() {
 			It("adjusts the LargestAcked", func() {
-				ack := frames.AckFrame{
+				ack := wire.AckFrame{
 					LargestAcked: 5,
 					LowestAcked:  1,
 				}
@@ -383,7 +383,7 @@ var _ = Describe("SentPacketHandler", func() {
 			})
 
 			It("ACKs all packets for an ACK frame with no missing packets", func() {
-				ack := frames.AckFrame{
+				ack := wire.AckFrame{
 					LargestAcked: 8,
 					LowestAcked:  2,
 				}
@@ -399,10 +399,10 @@ var _ = Describe("SentPacketHandler", func() {
 			})
 
 			It("handles an ACK frame with one missing packet range", func() {
-				ack := frames.AckFrame{
+				ack := wire.AckFrame{
 					LargestAcked: 9,
 					LowestAcked:  2,
-					AckRanges: []frames.AckRange{ // packets 4 and 5 were lost
+					AckRanges: []wire.AckRange{ // packets 4 and 5 were lost
 						{FirstPacketNumber: 6, LastPacketNumber: 9},
 						{FirstPacketNumber: 2, LastPacketNumber: 3},
 					},
@@ -421,7 +421,7 @@ var _ = Describe("SentPacketHandler", func() {
 			})
 
 			It("Does not ack packets below the LowestAcked", func() {
-				ack := frames.AckFrame{
+				ack := wire.AckFrame{
 					LargestAcked: 8,
 					LowestAcked:  3,
 				}
@@ -435,10 +435,10 @@ var _ = Describe("SentPacketHandler", func() {
 			})
 
 			It("handles an ACK with multiple missing packet ranges", func() {
-				ack := frames.AckFrame{
+				ack := wire.AckFrame{
 					LargestAcked: 9,
 					LowestAcked:  1,
-					AckRanges: []frames.AckRange{ // packets 2, 4 and 5, and 8 were lost
+					AckRanges: []wire.AckRange{ // packets 2, 4 and 5, and 8 were lost
 						{FirstPacketNumber: 9, LastPacketNumber: 9},
 						{FirstPacketNumber: 6, LastPacketNumber: 7},
 						{FirstPacketNumber: 3, LastPacketNumber: 3},
@@ -461,10 +461,10 @@ var _ = Describe("SentPacketHandler", func() {
 
 			It("processes an ACK frame that would be sent after a late arrival of a packet", func() {
 				largestObserved := 6
-				ack1 := frames.AckFrame{
+				ack1 := wire.AckFrame{
 					LargestAcked: protocol.PacketNumber(largestObserved),
 					LowestAcked:  1,
-					AckRanges: []frames.AckRange{
+					AckRanges: []wire.AckRange{
 						{FirstPacketNumber: 4, LastPacketNumber: protocol.PacketNumber(largestObserved)},
 						{FirstPacketNumber: 1, LastPacketNumber: 2},
 					},
@@ -474,7 +474,7 @@ var _ = Describe("SentPacketHandler", func() {
 				Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(len(packets) - 5)))
 				el := handler.packetHistory.Front()
 				Expect(el.Value.PacketNumber).To(Equal(protocol.PacketNumber(3)))
-				ack2 := frames.AckFrame{
+				ack2 := wire.AckFrame{
 					LargestAcked: protocol.PacketNumber(largestObserved),
 					LowestAcked:  1,
 				}
@@ -485,10 +485,10 @@ var _ = Describe("SentPacketHandler", func() {
 			})
 
 			It("processes an ACK frame that would be sent after a late arrival of a packet and another packet", func() {
-				ack1 := frames.AckFrame{
+				ack1 := wire.AckFrame{
 					LargestAcked: 6,
 					LowestAcked:  1,
-					AckRanges: []frames.AckRange{
+					AckRanges: []wire.AckRange{
 						{FirstPacketNumber: 4, LastPacketNumber: 6},
 						{FirstPacketNumber: 1, LastPacketNumber: 2},
 					},
@@ -498,7 +498,7 @@ var _ = Describe("SentPacketHandler", func() {
 				Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(len(packets) - 5)))
 				el := handler.packetHistory.Front()
 				Expect(el.Value.PacketNumber).To(Equal(protocol.PacketNumber(3)))
-				ack2 := frames.AckFrame{
+				ack2 := wire.AckFrame{
 					LargestAcked: 7,
 					LowestAcked:  1,
 				}
@@ -509,7 +509,7 @@ var _ = Describe("SentPacketHandler", func() {
 			})
 
 			It("processes an ACK that contains old ACK ranges", func() {
-				ack1 := frames.AckFrame{
+				ack1 := wire.AckFrame{
 					LargestAcked: 6,
 					LowestAcked:  1,
 				}
@@ -517,10 +517,10 @@ var _ = Describe("SentPacketHandler", func() {
 				Expect(err).ToNot(HaveOccurred())
 				Expect(handler.packetHistory.Front().Value.PacketNumber).To(Equal(protocol.PacketNumber(7)))
 				Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(len(packets) - 6)))
-				ack2 := frames.AckFrame{
+				ack2 := wire.AckFrame{
 					LargestAcked: 10,
 					LowestAcked:  1,
-					AckRanges: []frames.AckRange{
+					AckRanges: []wire.AckRange{
 						{FirstPacketNumber: 8, LastPacketNumber: 10},
 						{FirstPacketNumber: 3, LastPacketNumber: 3},
 						{FirstPacketNumber: 1, LastPacketNumber: 1},
@@ -542,13 +542,13 @@ var _ = Describe("SentPacketHandler", func() {
 				getPacketElement(2).Value.SendTime = now.Add(-5 * time.Minute)
 				getPacketElement(6).Value.SendTime = now.Add(-1 * time.Minute)
 				// Now, check that the proper times are used when calculating the deltas
-				err := handler.ReceivedAck(&frames.AckFrame{LargestAcked: 1}, 1, time.Now())
+				err := handler.ReceivedAck(&wire.AckFrame{LargestAcked: 1}, 1, time.Now())
 				Expect(err).NotTo(HaveOccurred())
 				Expect(handler.rttStats.LatestRTT()).To(BeNumerically("~", 10*time.Minute, 1*time.Second))
-				err = handler.ReceivedAck(&frames.AckFrame{LargestAcked: 2}, 2, time.Now())
+				err = handler.ReceivedAck(&wire.AckFrame{LargestAcked: 2}, 2, time.Now())
 				Expect(err).NotTo(HaveOccurred())
 				Expect(handler.rttStats.LatestRTT()).To(BeNumerically("~", 5*time.Minute, 1*time.Second))
-				err = handler.ReceivedAck(&frames.AckFrame{LargestAcked: 6}, 3, time.Now())
+				err = handler.ReceivedAck(&wire.AckFrame{LargestAcked: 6}, 3, time.Now())
 				Expect(err).NotTo(HaveOccurred())
 				Expect(handler.rttStats.LatestRTT()).To(BeNumerically("~", 1*time.Minute, 1*time.Second))
 			})
@@ -556,7 +556,7 @@ var _ = Describe("SentPacketHandler", func() {
 			It("uses the DelayTime in the ack frame", func() {
 				now := time.Now()
 				getPacketElement(1).Value.SendTime = now.Add(-10 * time.Minute)
-				err := handler.ReceivedAck(&frames.AckFrame{LargestAcked: 1, DelayTime: 5 * time.Minute}, 1, time.Now())
+				err := handler.ReceivedAck(&wire.AckFrame{LargestAcked: 1, DelayTime: 5 * time.Minute}, 1, time.Now())
 				Expect(err).NotTo(HaveOccurred())
 				Expect(handler.rttStats.LatestRTT()).To(BeNumerically("~", 5*time.Minute, 1*time.Second))
 			})
@@ -568,13 +568,13 @@ var _ = Describe("SentPacketHandler", func() {
 
 		BeforeEach(func() {
 			packets = []*Packet{
-				{PacketNumber: 1, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 2, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 3, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 4, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 5, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 6, Frames: []frames.Frame{&streamFrame}, Length: 1},
-				{PacketNumber: 7, Frames: []frames.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 1, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 2, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 3, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 4, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 5, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 6, Frames: []wire.Frame{&streamFrame}, Length: 1},
+				{PacketNumber: 7, Frames: []wire.Frame{&streamFrame}, Length: 1},
 			}
 			for _, packet := range packets {
 				handler.SentPacket(packet)
@@ -582,7 +582,7 @@ var _ = Describe("SentPacketHandler", func() {
 			// Increase RTT, because the tests would be flaky otherwise
 			handler.rttStats.UpdateRTT(time.Minute, 0, time.Now())
 			// Ack a single packet so that we have non-RTO timings
-			handler.ReceivedAck(&frames.AckFrame{LargestAcked: 2, LowestAcked: 2}, 1, time.Now())
+			handler.ReceivedAck(&wire.AckFrame{LargestAcked: 2, LowestAcked: 2}, 1, time.Now())
 			Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(6)))
 		})
 
@@ -604,23 +604,23 @@ var _ = Describe("SentPacketHandler", func() {
 
 		Context("StopWaitings", func() {
 			It("gets a StopWaitingFrame", func() {
-				ack := frames.AckFrame{LargestAcked: 5, LowestAcked: 5}
+				ack := wire.AckFrame{LargestAcked: 5, LowestAcked: 5}
 				err := handler.ReceivedAck(&ack, 2, time.Now())
 				Expect(err).ToNot(HaveOccurred())
-				Expect(handler.GetStopWaitingFrame(false)).To(Equal(&frames.StopWaitingFrame{LeastUnacked: 6}))
+				Expect(handler.GetStopWaitingFrame(false)).To(Equal(&wire.StopWaitingFrame{LeastUnacked: 6}))
 			})
 
 			It("gets a StopWaitingFrame after queueing a retransmission", func() {
 				handler.queuePacketForRetransmission(getPacketElement(5))
-				Expect(handler.GetStopWaitingFrame(false)).To(Equal(&frames.StopWaitingFrame{LeastUnacked: 6}))
+				Expect(handler.GetStopWaitingFrame(false)).To(Equal(&wire.StopWaitingFrame{LeastUnacked: 6}))
 			})
 		})
 	})
 
 	It("calculates bytes in flight", func() {
-		packet1 := Packet{PacketNumber: 1, Frames: []frames.Frame{&streamFrame}, Length: 1}
-		packet2 := Packet{PacketNumber: 2, Frames: []frames.Frame{&streamFrame}, Length: 2}
-		packet3 := Packet{PacketNumber: 3, Frames: []frames.Frame{&streamFrame}, Length: 3}
+		packet1 := Packet{PacketNumber: 1, Frames: []wire.Frame{&streamFrame}, Length: 1}
+		packet2 := Packet{PacketNumber: 2, Frames: []wire.Frame{&streamFrame}, Length: 2}
+		packet3 := Packet{PacketNumber: 3, Frames: []wire.Frame{&streamFrame}, Length: 3}
 		err := handler.SentPacket(&packet1)
 		Expect(err).NotTo(HaveOccurred())
 		Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(1)))
@@ -635,10 +635,10 @@ var _ = Describe("SentPacketHandler", func() {
 		handler.rttStats.UpdateRTT(time.Minute, 0, time.Now())
 
 		// ACK 1 and 3, NACK 2
-		ack := frames.AckFrame{
+		ack := wire.AckFrame{
 			LargestAcked: 3,
 			LowestAcked:  1,
-			AckRanges: []frames.AckRange{
+			AckRanges: []wire.AckRange{
 				{FirstPacketNumber: 3, LastPacketNumber: 3},
 				{FirstPacketNumber: 1, LastPacketNumber: 1},
 			},
@@ -667,7 +667,7 @@ var _ = Describe("SentPacketHandler", func() {
 			p := &Packet{
 				PacketNumber: 1,
 				Length:       42,
-				Frames:       []frames.Frame{&frames.PingFrame{}},
+				Frames:       []wire.Frame{&wire.PingFrame{}},
 			}
 			err := handler.SentPacket(p)
 			Expect(err).NotTo(HaveOccurred())
@@ -680,7 +680,7 @@ var _ = Describe("SentPacketHandler", func() {
 		It("should call MaybeExitSlowStart and OnPacketAcked", func() {
 			handler.SentPacket(retransmittablePacket(1))
 			handler.SentPacket(retransmittablePacket(2))
-			err := handler.ReceivedAck(&frames.AckFrame{LargestAcked: 1, LowestAcked: 1}, 1, time.Now())
+			err := handler.ReceivedAck(&wire.AckFrame{LargestAcked: 1, LowestAcked: 1}, 1, time.Now())
 			Expect(err).NotTo(HaveOccurred())
 			Expect(cong.maybeExitSlowStart).To(BeTrue())
 			Expect(cong.packetsAcked).To(BeEquivalentTo([][]interface{}{
@@ -707,7 +707,7 @@ var _ = Describe("SentPacketHandler", func() {
 			Expect(handler.SendingAllowed()).To(BeTrue())
 			err := handler.SentPacket(&Packet{
 				PacketNumber: 1,
-				Frames:       []frames.Frame{&frames.PingFrame{}},
+				Frames:       []wire.Frame{&wire.PingFrame{}},
 				Length:       protocol.DefaultTCPMSS + 1,
 			})
 			Expect(err).NotTo(HaveOccurred())
@@ -723,7 +723,7 @@ var _ = Describe("SentPacketHandler", func() {
 		It("allows sending if there are retransmisisons outstanding", func() {
 			err := handler.SentPacket(&Packet{
 				PacketNumber: 1,
-				Frames:       []frames.Frame{&frames.PingFrame{}},
+				Frames:       []wire.Frame{&wire.PingFrame{}},
 				Length:       protocol.DefaultTCPMSS + 1,
 			})
 			Expect(err).NotTo(HaveOccurred())
@@ -775,7 +775,7 @@ var _ = Describe("SentPacketHandler", func() {
 			Expect(err).NotTo(HaveOccurred())
 			Expect(handler.lossTime.IsZero()).To(BeTrue())
 
-			err = handler.ReceivedAck(&frames.AckFrame{LargestAcked: 2, LowestAcked: 2}, 1, time.Now().Add(time.Hour))
+			err = handler.ReceivedAck(&wire.AckFrame{LargestAcked: 2, LowestAcked: 2}, 1, time.Now().Add(time.Hour))
 			Expect(err).NotTo(HaveOccurred())
 			Expect(handler.lossTime.IsZero()).To(BeFalse())
 
@@ -798,7 +798,7 @@ var _ = Describe("SentPacketHandler", func() {
 			Expect(err).NotTo(HaveOccurred())
 			Expect(handler.lossTime.IsZero()).To(BeTrue())
 
-			err = handler.ReceivedAck(&frames.AckFrame{LargestAcked: 1, LowestAcked: 1}, 1, time.Now().Add(time.Hour))
+			err = handler.ReceivedAck(&wire.AckFrame{LargestAcked: 1, LowestAcked: 1}, 1, time.Now().Add(time.Hour))
 			Expect(err).NotTo(HaveOccurred())
 			Expect(handler.lossTime.IsZero()).To(BeTrue())
 			Expect(handler.GetAlarmTimeout().Sub(time.Now())).To(BeNumerically("~", handler.computeRTOTimeout(), time.Minute))

ackhandler/stop_waiting_manager.go

@@ -1,8 +1,8 @@
 package ackhandler
 
 import (
-	"github.com/lucas-clemente/quic-go/frames"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 )
 
 // This stopWaitingManager is not supposed to satisfy the StopWaitingManager interface, which is a remnant of the legacy AckHandler, and should be remove once we drop support for QUIC 33
@@ -10,10 +10,10 @@ type stopWaitingManager struct {
 	largestLeastUnackedSent protocol.PacketNumber
 	nextLeastUnacked        protocol.PacketNumber
 
-	lastStopWaitingFrame *frames.StopWaitingFrame
+	lastStopWaitingFrame *wire.StopWaitingFrame
 }
 
-func (s *stopWaitingManager) GetStopWaitingFrame(force bool) *frames.StopWaitingFrame {
+func (s *stopWaitingManager) GetStopWaitingFrame(force bool) *wire.StopWaitingFrame {
 	if s.nextLeastUnacked <= s.largestLeastUnackedSent {
 		if force {
 			return s.lastStopWaitingFrame
@@ -22,14 +22,14 @@ func (s *stopWaitingManager) GetStopWaitingFrame(force bool) *frames.StopWaiting
 	}
 
 	s.largestLeastUnackedSent = s.nextLeastUnacked
-	swf := &frames.StopWaitingFrame{
+	swf := &wire.StopWaitingFrame{
 		LeastUnacked: s.nextLeastUnacked,
 	}
 	s.lastStopWaitingFrame = swf
 	return swf
 }
 
-func (s *stopWaitingManager) ReceivedAck(ack *frames.AckFrame) {
+func (s *stopWaitingManager) ReceivedAck(ack *wire.AckFrame) {
 	if ack.LargestAcked >= s.nextLeastUnacked {
 		s.nextLeastUnacked = ack.LargestAcked + 1
 	}

ackhandler/stop_waiting_manager_test.go

@@ -1,7 +1,7 @@
 package ackhandler
 
 import (
-	"github.com/lucas-clemente/quic-go/frames"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
@@ -18,38 +18,38 @@ var _ = Describe("StopWaitingManager", func() {
 	})
 
 	It("returns a StopWaitingFrame, when a new ACK arrives", func() {
-		manager.ReceivedAck(&frames.AckFrame{LargestAcked: 10})
-		Expect(manager.GetStopWaitingFrame(false)).To(Equal(&frames.StopWaitingFrame{LeastUnacked: 11}))
+		manager.ReceivedAck(&wire.AckFrame{LargestAcked: 10})
+		Expect(manager.GetStopWaitingFrame(false)).To(Equal(&wire.StopWaitingFrame{LeastUnacked: 11}))
 	})
 
 	It("does not decrease the LeastUnacked", func() {
-		manager.ReceivedAck(&frames.AckFrame{LargestAcked: 10})
-		manager.ReceivedAck(&frames.AckFrame{LargestAcked: 9})
-		Expect(manager.GetStopWaitingFrame(false)).To(Equal(&frames.StopWaitingFrame{LeastUnacked: 11}))
+		manager.ReceivedAck(&wire.AckFrame{LargestAcked: 10})
+		manager.ReceivedAck(&wire.AckFrame{LargestAcked: 9})
+		Expect(manager.GetStopWaitingFrame(false)).To(Equal(&wire.StopWaitingFrame{LeastUnacked: 11}))
 	})
 
 	It("does not send the same StopWaitingFrame twice", func() {
-		manager.ReceivedAck(&frames.AckFrame{LargestAcked: 10})
+		manager.ReceivedAck(&wire.AckFrame{LargestAcked: 10})
 		Expect(manager.GetStopWaitingFrame(false)).ToNot(BeNil())
 		Expect(manager.GetStopWaitingFrame(false)).To(BeNil())
 	})
 
 	It("gets the same StopWaitingFrame twice, if forced", func() {
-		manager.ReceivedAck(&frames.AckFrame{LargestAcked: 10})
+		manager.ReceivedAck(&wire.AckFrame{LargestAcked: 10})
 		Expect(manager.GetStopWaitingFrame(false)).ToNot(BeNil())
 		Expect(manager.GetStopWaitingFrame(true)).ToNot(BeNil())
 		Expect(manager.GetStopWaitingFrame(true)).ToNot(BeNil())
 	})
 
 	It("increases the LeastUnacked when a retransmission is queued", func() {
-		manager.ReceivedAck(&frames.AckFrame{LargestAcked: 10})
+		manager.ReceivedAck(&wire.AckFrame{LargestAcked: 10})
 		manager.QueuedRetransmissionForPacketNumber(20)
-		Expect(manager.GetStopWaitingFrame(false)).To(Equal(&frames.StopWaitingFrame{LeastUnacked: 21}))
+		Expect(manager.GetStopWaitingFrame(false)).To(Equal(&wire.StopWaitingFrame{LeastUnacked: 21}))
 	})
 
 	It("does not decrease the LeastUnacked when a retransmission is queued", func() {
-		manager.ReceivedAck(&frames.AckFrame{LargestAcked: 10})
+		manager.ReceivedAck(&wire.AckFrame{LargestAcked: 10})
 		manager.QueuedRetransmissionForPacketNumber(9)
-		Expect(manager.GetStopWaitingFrame(false)).To(Equal(&frames.StopWaitingFrame{LeastUnacked: 11}))
+		Expect(manager.GetStopWaitingFrame(false)).To(Equal(&wire.StopWaitingFrame{LeastUnacked: 11}))
 	})
 })

benchmark/benchmark_test.go

@@ -9,8 +9,8 @@ import (
 	"net"
 
 	quic "github.com/lucas-clemente/quic-go"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/testdata"
-	"github.com/lucas-clemente/quic-go/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )

buffer_pool.go

@@ -3,7 +3,7 @@ package quic
 import (
 	"sync"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
 var bufferPool sync.Pool

buffer_pool_test.go

@@ -1,7 +1,7 @@
 package quic
 
 import (
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"

client.go

@@ -10,8 +10,9 @@ import (
 	"sync"
 	"time"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 	"github.com/lucas-clemente/quic-go/qerr"
 )
 
@@ -224,7 +225,7 @@ func (c *client) handlePacket(remoteAddr net.Addr, packet []byte) {
 	rcvTime := time.Now()
 
 	r := bytes.NewReader(packet)
-	hdr, err := ParsePublicHeader(r, protocol.PerspectiveServer, c.version)
+	hdr, err := wire.ParsePublicHeader(r, protocol.PerspectiveServer, c.version)
 	if err != nil {
 		utils.Errorf("error parsing packet from %s: %s", remoteAddr.String(), err.Error())
 		// drop this packet if we can't parse the Public Header
@@ -243,13 +244,13 @@ func (c *client) handlePacket(remoteAddr net.Addr, packet []byte) {
 			utils.Infof("Received a spoofed Public Reset. Ignoring.")
 			return
 		}
-		pr, err := parsePublicReset(r)
+		pr, err := wire.ParsePublicReset(r)
 		if err != nil {
 			utils.Infof("Received a Public Reset for connection %x. An error occurred parsing the packet.")
 			return
 		}
-		utils.Infof("Received Public Reset, rejected packet number: %#x.", pr.rejectedPacketNumber)
-		c.session.closeRemote(qerr.Error(qerr.PublicReset, fmt.Sprintf("Received a Public Reset for packet number %#x", pr.rejectedPacketNumber)))
+		utils.Infof("Received Public Reset, rejected packet number: %#x.", pr.RejectedPacketNumber)
+		c.session.closeRemote(qerr.Error(qerr.PublicReset, fmt.Sprintf("Received a Public Reset for packet number %#x", pr.RejectedPacketNumber)))
 		return
 	}
 
@@ -280,7 +281,7 @@ func (c *client) handlePacket(remoteAddr net.Addr, packet []byte) {
 	})
 }
 
-func (c *client) handlePacketWithVersionFlag(hdr *PublicHeader) error {
+func (c *client) handlePacketWithVersionFlag(hdr *wire.PublicHeader) error {
 	for _, v := range hdr.SupportedVersions {
 		if v == c.version {
 			// the version negotiation packet contains the version that we offered

client_test.go

@@ -7,7 +7,8 @@ import (
 	"net"
 	"time"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 	"github.com/lucas-clemente/quic-go/qerr"
 
 	. "github.com/onsi/ginkgo"
@@ -228,7 +229,7 @@ var _ = Describe("Client", func() {
 
 		Context("version negotiation", func() {
 			It("recognizes that a packet without VersionFlag means that the server accepted the suggested version", func() {
-				ph := PublicHeader{
+				ph := wire.PublicHeader{
 					PacketNumber:    1,
 					PacketNumberLen: protocol.PacketNumberLen2,
 					ConnectionID:    0x1337,
@@ -262,7 +263,7 @@ var _ = Describe("Client", func() {
 				Expect(newVersion).ToNot(Equal(cl.version))
 				Expect(sess.packetCount).To(BeZero())
 				cl.connectionID = 0x1337
-				cl.handlePacket(nil, composeVersionNegotiation(0x1337, []protocol.VersionNumber{newVersion}))
+				cl.handlePacket(nil, wire.ComposeVersionNegotiation(0x1337, []protocol.VersionNumber{newVersion}))
 				Expect(cl.version).To(Equal(newVersion))
 				Expect(cl.versionNegotiated).To(BeTrue())
 				// it swapped the sessions
@@ -274,7 +275,7 @@ var _ = Describe("Client", func() {
 			})
 
 			It("errors if no matching version is found", func() {
-				cl.handlePacket(nil, composeVersionNegotiation(0x1337, []protocol.VersionNumber{1}))
+				cl.handlePacket(nil, wire.ComposeVersionNegotiation(0x1337, []protocol.VersionNumber{1}))
 				Expect(cl.session.(*mockSession).closed).To(BeTrue())
 				Expect(cl.session.(*mockSession).closeReason).To(MatchError(qerr.InvalidVersion))
 			})
@@ -283,13 +284,13 @@ var _ = Describe("Client", func() {
 				v := protocol.SupportedVersions[1]
 				Expect(v).ToNot(Equal(cl.version))
 				Expect(config.Versions).ToNot(ContainElement(v))
-				cl.handlePacket(nil, composeVersionNegotiation(0x1337, []protocol.VersionNumber{v}))
+				cl.handlePacket(nil, wire.ComposeVersionNegotiation(0x1337, []protocol.VersionNumber{v}))
 				Expect(cl.session.(*mockSession).closed).To(BeTrue())
 				Expect(cl.session.(*mockSession).closeReason).To(MatchError(qerr.InvalidVersion))
 			})
 
 			It("changes to the version preferred by the quic.Config", func() {
-				cl.handlePacket(nil, composeVersionNegotiation(0x1337, []protocol.VersionNumber{config.Versions[2], config.Versions[1]}))
+				cl.handlePacket(nil, wire.ComposeVersionNegotiation(0x1337, []protocol.VersionNumber{config.Versions[2], config.Versions[1]}))
 				Expect(cl.version).To(Equal(config.Versions[1]))
 			})
 
@@ -297,14 +298,14 @@ var _ = Describe("Client", func() {
 				// if the version was not yet negotiated, handlePacket would return a VersionNegotiationMismatch error, see above test
 				cl.versionNegotiated = true
 				Expect(sess.packetCount).To(BeZero())
-				cl.handlePacket(nil, composeVersionNegotiation(0x1337, []protocol.VersionNumber{1}))
+				cl.handlePacket(nil, wire.ComposeVersionNegotiation(0x1337, []protocol.VersionNumber{1}))
 				Expect(cl.versionNegotiated).To(BeTrue())
 				Expect(sess.packetCount).To(BeZero())
 			})
 
 			It("drops version negotiation packets that contain the offered version", func() {
 				ver := cl.version
-				cl.handlePacket(nil, composeVersionNegotiation(0x1337, []protocol.VersionNumber{ver}))
+				cl.handlePacket(nil, wire.ComposeVersionNegotiation(0x1337, []protocol.VersionNumber{ver}))
 				Expect(cl.version).To(Equal(ver))
 			})
 		})
@@ -351,7 +352,7 @@ var _ = Describe("Client", func() {
 
 	Context("handling packets", func() {
 		It("handles packets", func() {
-			ph := PublicHeader{
+			ph := wire.PublicHeader{
 				PacketNumber:    1,
 				PacketNumberLen: protocol.PacketNumberLen2,
 				ConnectionID:    0x1337,
@@ -385,27 +386,27 @@ var _ = Describe("Client", func() {
 
 	Context("Public Reset handling", func() {
 		It("closes the session when receiving a Public Reset", func() {
-			cl.handlePacket(addr, writePublicReset(cl.connectionID, 1, 0))
+			cl.handlePacket(addr, wire.WritePublicReset(cl.connectionID, 1, 0))
 			Expect(cl.session.(*mockSession).closed).To(BeTrue())
 			Expect(cl.session.(*mockSession).closedRemote).To(BeTrue())
 			Expect(cl.session.(*mockSession).closeReason.(*qerr.QuicError).ErrorCode).To(Equal(qerr.PublicReset))
 		})
 
 		It("ignores Public Resets with the wrong connection ID", func() {
-			cl.handlePacket(addr, writePublicReset(cl.connectionID+1, 1, 0))
+			cl.handlePacket(addr, wire.WritePublicReset(cl.connectionID+1, 1, 0))
 			Expect(cl.session.(*mockSession).closed).To(BeFalse())
 			Expect(cl.session.(*mockSession).closedRemote).To(BeFalse())
 		})
 
 		It("ignores Public Resets from the wrong remote address", func() {
 			spoofedAddr := &net.UDPAddr{IP: net.IPv4(1, 2, 3, 4), Port: 5678}
-			cl.handlePacket(spoofedAddr, writePublicReset(cl.connectionID, 1, 0))
+			cl.handlePacket(spoofedAddr, wire.WritePublicReset(cl.connectionID, 1, 0))
 			Expect(cl.session.(*mockSession).closed).To(BeFalse())
 			Expect(cl.session.(*mockSession).closedRemote).To(BeFalse())
 		})
 
 		It("ignores unparseable Public Resets", func() {
-			pr := writePublicReset(cl.connectionID, 1, 0)
+			pr := wire.WritePublicReset(cl.connectionID, 1, 0)
 			cl.handlePacket(addr, pr[:len(pr)-5])
 			Expect(cl.session.(*mockSession).closed).To(BeFalse())
 			Expect(cl.session.(*mockSession).closedRemote).To(BeFalse())

congestion/bandwidth.go

@@ -3,7 +3,7 @@ package congestion
 import (
 	"time"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
 // Bandwidth of a connection

congestion/cubic.go

@@ -4,8 +4,8 @@ import (
 	"math"
 	"time"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 )
 
 // This cubic implementation is based on the one found in Chromiums's QUIC

congestion/cubic_sender.go

@@ -3,8 +3,8 @@ package congestion
 import (
 	"time"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 )
 
 const (

congestion/cubic_sender_test.go

@@ -3,7 +3,7 @@ package congestion
 import (
 	"time"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )

congestion/cubic_test.go

@@ -4,7 +4,7 @@ import (
 	"math"
 	"time"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )

congestion/hybrid_slow_start.go

@@ -3,8 +3,8 @@ package congestion
 import (
 	"time"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 )
 
 // Note(pwestin): the magic clamping numbers come from the original code in

congestion/hybrid_slow_start_test.go

@@ -3,7 +3,7 @@ package congestion
 import (
 	"time"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )

congestion/interface.go

@@ -3,7 +3,7 @@ package congestion
 import (
 	"time"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
 // A SendAlgorithm performs congestion control and calculates the congestion window

congestion/prr_sender.go

@@ -3,8 +3,8 @@ package congestion
 import (
 	"time"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 )
 
 // PrrSender implements the Proportional Rate Reduction (PRR) per RFC 6937

congestion/prr_sender_test.go

@@ -4,8 +4,8 @@ import (
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 )
 
 var _ = Describe("PRR sender", func() {

congestion/stats.go

@@ -1,6 +1,6 @@
 package congestion
 
-import "github.com/lucas-clemente/quic-go/protocol"
+import "github.com/lucas-clemente/quic-go/internal/protocol"
 
 type connectionStats struct {
 	slowstartPacketsLost protocol.PacketNumber

crypto/AEAD.go

@@ -1,6 +1,6 @@
 package crypto
 
-import "github.com/lucas-clemente/quic-go/protocol"
+import "github.com/lucas-clemente/quic-go/internal/protocol"
 
 // An AEAD implements QUIC's authenticated encryption and associated data
 type AEAD interface {

crypto/aesgcm_aead.go

@@ -6,7 +6,7 @@ import (
 
 	"github.com/lucas-clemente/aes12"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
 type aeadAESGCM struct {

crypto/cert_cache.go

@@ -5,7 +5,7 @@ import (
 	"hash/fnv"
 
 	"github.com/hashicorp/golang-lru"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
 var (

crypto/chacha20poly1305_aead.go

@@ -8,7 +8,7 @@ import (
 
 	"github.com/aead/chacha20"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
 type aeadChacha20Poly1305 struct {

crypto/key_derivation.go

@@ -5,8 +5,8 @@ import (
 	"crypto/sha256"
 	"io"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 
 	"golang.org/x/crypto/hkdf"
 )

crypto/key_derivation_test.go

@@ -1,7 +1,7 @@
 package crypto
 
 import (
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"

crypto/nonce.go

@@ -3,7 +3,7 @@ package crypto
 import (
 	"encoding/binary"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
 func makeNonce(iv []byte, packetNumber protocol.PacketNumber) []byte {

crypto/null_aead.go

@@ -5,7 +5,7 @@ import (
 	"errors"
 
 	"github.com/lucas-clemente/fnv128a"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
 // nullAEAD handles not-yet encrypted packets

crypto/null_aead_test.go

@@ -1,7 +1,7 @@
 package crypto
 
 import (
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )

frames/log.go

@@ -1,28 +0,0 @@
-package frames
-
-import "github.com/lucas-clemente/quic-go/internal/utils"
-
-// LogFrame logs a frame, either sent or received
-func LogFrame(frame Frame, sent bool) {
-	if !utils.Debug() {
-		return
-	}
-	dir := "<-"
-	if sent {
-		dir = "->"
-	}
-	switch f := frame.(type) {
-	case *StreamFrame:
-		utils.Debugf("\t%s &frames.StreamFrame{StreamID: %d, FinBit: %t, Offset: 0x%x, Data length: 0x%x, Offset + Data length: 0x%x}", dir, f.StreamID, f.FinBit, f.Offset, f.DataLen(), f.Offset+f.DataLen())
-	case *StopWaitingFrame:
-		if sent {
-			utils.Debugf("\t%s &frames.StopWaitingFrame{LeastUnacked: 0x%x, PacketNumberLen: 0x%x}", dir, f.LeastUnacked, f.PacketNumberLen)
-		} else {
-			utils.Debugf("\t%s &frames.StopWaitingFrame{LeastUnacked: 0x%x}", dir, f.LeastUnacked)
-		}
-	case *AckFrame:
-		utils.Debugf("\t%s &frames.AckFrame{LargestAcked: 0x%x, LowestAcked: 0x%x, AckRanges: %#v, DelayTime: %s}", dir, f.LargestAcked, f.LowestAcked, f.AckRanges, f.DelayTime.String())
-	default:
-		utils.Debugf("\t%s %#v", dir, frame)
-	}
-}

h2quic/client.go

@@ -15,8 +15,8 @@ import (
 	"golang.org/x/net/idna"
 
 	quic "github.com/lucas-clemente/quic-go"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 )
 

h2quic/client_test.go

@@ -12,7 +12,7 @@ import (
 	"golang.org/x/net/http2/hpack"
 
 	quic "github.com/lucas-clemente/quic-go"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 
 	"time"

h2quic/request_writer.go

@@ -13,8 +13,8 @@ import (
 	"golang.org/x/net/lex/httplex"
 
 	quic "github.com/lucas-clemente/quic-go"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 )
 
 type requestWriter struct {

h2quic/response_writer.go

@@ -8,8 +8,8 @@ import (
 	"sync"
 
 	quic "github.com/lucas-clemente/quic-go"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 	"golang.org/x/net/http2"
 	"golang.org/x/net/http2/hpack"
 )

h2quic/response_writer_test.go

@@ -11,7 +11,7 @@ import (
 	"golang.org/x/net/http2"
 	"golang.org/x/net/http2/hpack"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )

h2quic/server.go

@@ -13,8 +13,8 @@ import (
 	"time"
 
 	quic "github.com/lucas-clemente/quic-go"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 	"golang.org/x/net/http2"
 	"golang.org/x/net/http2/hpack"

h2quic/server_test.go

@@ -18,8 +18,8 @@ import (
 	"golang.org/x/net/http2/hpack"
 
 	quic "github.com/lucas-clemente/quic-go"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/testdata"
-	"github.com/lucas-clemente/quic-go/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 
 	. "github.com/onsi/ginkgo"

handshake/connection_parameters_manager.go

@@ -5,8 +5,8 @@ import (
 	"sync"
 	"time"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 )
 

handshake/connection_parameters_manager_test.go

@@ -5,7 +5,7 @@ import (
 	"math"
 	"time"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
@@ -148,10 +148,10 @@ var _ = Describe("ConnectionsParameterManager", func() {
 		})
 
 		It("has the correct default flow control windows for receiving", func() {
-			Expect(cpm.GetReceiveStreamFlowControlWindow()).To(Equal(protocol.ReceiveStreamFlowControlWindow))
-			Expect(cpm.GetReceiveConnectionFlowControlWindow()).To(Equal(protocol.ReceiveConnectionFlowControlWindow))
-			Expect(cpmClient.GetReceiveStreamFlowControlWindow()).To(Equal(protocol.ReceiveStreamFlowControlWindow))
-			Expect(cpmClient.GetReceiveConnectionFlowControlWindow()).To(Equal(protocol.ReceiveConnectionFlowControlWindow))
+			Expect(cpm.GetReceiveStreamFlowControlWindow()).To(BeEquivalentTo(protocol.ReceiveStreamFlowControlWindow))
+			Expect(cpm.GetReceiveConnectionFlowControlWindow()).To(BeEquivalentTo(protocol.ReceiveConnectionFlowControlWindow))
+			Expect(cpmClient.GetReceiveStreamFlowControlWindow()).To(BeEquivalentTo(protocol.ReceiveStreamFlowControlWindow))
+			Expect(cpmClient.GetReceiveConnectionFlowControlWindow()).To(BeEquivalentTo(protocol.ReceiveConnectionFlowControlWindow))
 		})
 
 		It("has the correct maximum flow control windows", func() {

handshake/crypto_setup_client.go

@@ -12,8 +12,8 @@ import (
 	"time"
 
 	"github.com/lucas-clemente/quic-go/crypto"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 )
 

handshake/crypto_setup_client_test.go

@@ -8,8 +8,8 @@ import (
 	"time"
 
 	"github.com/lucas-clemente/quic-go/crypto"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"

handshake/crypto_setup_server.go

@@ -10,8 +10,8 @@ import (
 	"sync"
 
 	"github.com/lucas-clemente/quic-go/crypto"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 )
 

handshake/crypto_setup_server_test.go

@@ -7,8 +7,8 @@ import (
 	"net"
 
 	"github.com/lucas-clemente/quic-go/crypto"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 
 	. "github.com/onsi/ginkgo"

handshake/ephermal_cache.go

@@ -5,8 +5,8 @@ import (
 	"time"
 
 	"github.com/lucas-clemente/quic-go/crypto"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 )
 
 var (

handshake/ephermal_cache_test.go

@@ -4,7 +4,7 @@ import (
 	"time"
 
 	"github.com/lucas-clemente/quic-go/crypto"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )

handshake/handshake_message.go

@@ -7,8 +7,8 @@ import (
 	"io"
 	"sort"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 )
 

handshake/interface.go

@@ -1,6 +1,6 @@
 package handshake
 
-import "github.com/lucas-clemente/quic-go/protocol"
+import "github.com/lucas-clemente/quic-go/internal/protocol"
 
 // Sealer seals a packet
 type Sealer func(dst, src []byte, packetNumber protocol.PacketNumber, associatedData []byte) []byte

integrationtests/chrome/chrome_suite_test.go

@@ -15,8 +15,8 @@ import (
 	"time"
 
 	"github.com/lucas-clemente/quic-go/integrationtests/tools/testserver"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 
 	_ "github.com/lucas-clemente/quic-go/integrationtests/tools/testlog"
 

integrationtests/chrome/chrome_test.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"os"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 
 	. "github.com/onsi/ginkgo"
 )

integrationtests/gquic/drop_test.go

@@ -9,7 +9,7 @@ import (
 	_ "github.com/lucas-clemente/quic-clients" // download clients
 	"github.com/lucas-clemente/quic-go/integrationtests/tools/proxy"
 	"github.com/lucas-clemente/quic-go/integrationtests/tools/testserver"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"

integrationtests/gquic/integration_test.go

@@ -8,7 +8,7 @@ import (
 	"sync"
 
 	"github.com/lucas-clemente/quic-go/integrationtests/tools/testserver"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 
 	_ "github.com/lucas-clemente/quic-clients" // download clients
 

integrationtests/gquic/random_rtt_test.go

@@ -11,7 +11,7 @@ import (
 	_ "github.com/lucas-clemente/quic-clients" // download clients
 	"github.com/lucas-clemente/quic-go/integrationtests/tools/proxy"
 	"github.com/lucas-clemente/quic-go/integrationtests/tools/testserver"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"

integrationtests/gquic/rtt_test.go

@@ -10,7 +10,7 @@ import (
 	_ "github.com/lucas-clemente/quic-clients" // download clients
 	"github.com/lucas-clemente/quic-go/integrationtests/tools/proxy"
 	"github.com/lucas-clemente/quic-go/integrationtests/tools/testserver"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"

integrationtests/self/client_test.go

@@ -11,7 +11,7 @@ import (
 
 	"github.com/lucas-clemente/quic-go/h2quic"
 	"github.com/lucas-clemente/quic-go/integrationtests/tools/testserver"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 	"github.com/onsi/gomega/gbytes"

integrationtests/self/handshake_rtt_test.go

@@ -8,8 +8,8 @@ import (
 
 	quic "github.com/lucas-clemente/quic-go"
 	"github.com/lucas-clemente/quic-go/integrationtests/tools/proxy"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 
 	"github.com/lucas-clemente/quic-go/internal/testdata"

integrationtests/tools/proxy/proxy.go

@@ -7,8 +7,8 @@ import (
 	"sync/atomic"
 	"time"
 
-	"github.com/lucas-clemente/quic-go"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 )
 
 // Connection is a UDP connection
@@ -165,7 +165,7 @@ func (p *QuicProxy) runProxy() error {
 		atomic.AddUint64(&conn.incomingPacketCounter, 1)
 
 		r := bytes.NewReader(raw)
-		hdr, err := quic.ParsePublicHeader(r, protocol.PerspectiveClient, protocol.VersionWhatever)
+		hdr, err := wire.ParsePublicHeader(r, protocol.PerspectiveClient, protocol.VersionWhatever)
 		if err != nil {
 			return err
 		}
@@ -202,7 +202,7 @@ func (p *QuicProxy) runConnection(conn *connection) error {
 
 		// TODO: Switch back to using the public header once Chrome properly sets the type byte.
 		// r := bytes.NewReader(raw)
-		// , err := quic.ParsePublicHeader(r, protocol.PerspectiveServer)
+		// , err := wire.ParsePublicHeader(r, protocol.PerspectiveServer)
 		// if err != nil {
 		// return err
 		// }

integrationtests/tools/proxy/proxy_test.go

@@ -9,8 +9,8 @@ import (
 
 	"fmt"
 
-	"github.com/lucas-clemente/quic-go"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+	"github.com/lucas-clemente/quic-go/internal/wire"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
@@ -22,7 +22,7 @@ var _ = Describe("QUIC Proxy", func() {
 
 	makePacket := func(p protocol.PacketNumber, payload []byte) []byte {
 		b := &bytes.Buffer{}
-		hdr := quic.PublicHeader{
+		hdr := wire.PublicHeader{
 			PacketNumber:         p,
 			PacketNumberLen:      protocol.PacketNumberLen6,
 			ConnectionID:         1337,

interface.go

@@ -6,9 +6,15 @@ import (
 	"net"
 	"time"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
+// The StreamID is the ID of a QUIC stream.
+type StreamID = protocol.StreamID
+
+// A VersionNumber is a QUIC version number.
+type VersionNumber = protocol.VersionNumber
+
 // Stream is the interface implemented by QUIC streams
 type Stream interface {
 	// Read reads data from the stream.
@@ -20,7 +26,7 @@ type Stream interface {
 	// after a fixed time limit; see SetDeadline and SetWriteDeadline.
 	io.Writer
 	io.Closer
-	StreamID() protocol.StreamID
+	StreamID() StreamID
 	// Reset closes the stream with an error.
 	Reset(error)
 	// The context is canceled as soon as the write-side of the stream is closed.
@@ -86,12 +92,11 @@ type STK struct {
 }
 
 // Config contains all configuration data needed for a QUIC server or client.
-// More config parameters (such as timeouts) will be added soon, see e.g. https://github.com/lucas-clemente/quic-go/issues/441.
 type Config struct {
 	// The QUIC versions that can be negotiated.
 	// If not set, it uses all versions available.
 	// Warning: This API should not be considered stable and will change soon.
-	Versions []protocol.VersionNumber
+	Versions []VersionNumber
 	// Ask the server to truncate the connection ID sent in the Public Header.
 	// This saves 8 bytes in the Public Header in every packet. However, if the IP address of the server changes, the connection cannot be migrated.
 	// Currently only valid for the client.
@@ -112,10 +117,10 @@ type Config struct {
 	AcceptSTK func(clientAddr net.Addr, stk *STK) bool
 	// MaxReceiveStreamFlowControlWindow is the maximum stream-level flow control window for receiving data.
 	// If this value is zero, it will default to 1 MB for the server and 6 MB for the client.
-	MaxReceiveStreamFlowControlWindow protocol.ByteCount
+	MaxReceiveStreamFlowControlWindow uint64
 	// MaxReceiveConnectionFlowControlWindow is the connection-level flow control window for receiving data.
 	// If this value is zero, it will default to 1.5 MB for the server and 15 MB for the client.
-	MaxReceiveConnectionFlowControlWindow protocol.ByteCount
+	MaxReceiveConnectionFlowControlWindow uint64
 	// KeepAlive defines whether this peer will periodically send PING frames to keep the connection alive.
 	KeepAlive bool
 }

internal/flowcontrol/flow_control_manager.go

@@ -7,8 +7,8 @@ import (
 
 	"github.com/lucas-clemente/quic-go/congestion"
 	"github.com/lucas-clemente/quic-go/handshake"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 )
 

internal/flowcontrol/flow_control_manager_test.go

@@ -5,7 +5,7 @@ import (
 
 	"github.com/lucas-clemente/quic-go/congestion"
 	"github.com/lucas-clemente/quic-go/internal/mocks"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/qerr"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"

internal/flowcontrol/flow_controller.go

@@ -6,8 +6,8 @@ import (
 
 	"github.com/lucas-clemente/quic-go/congestion"
 	"github.com/lucas-clemente/quic-go/handshake"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 )
 
 type flowController struct {

internal/flowcontrol/flow_controller_test.go

@@ -5,7 +5,7 @@ import (
 
 	"github.com/lucas-clemente/quic-go/congestion"
 	"github.com/lucas-clemente/quic-go/internal/mocks"
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )

internal/flowcontrol/interface.go

@@ -1,6 +1,6 @@
 package flowcontrol
 
-import "github.com/lucas-clemente/quic-go/protocol"
+import "github.com/lucas-clemente/quic-go/internal/protocol"
 
 // WindowUpdate provides the data for WindowUpdateFrames.
 type WindowUpdate struct {

internal/mocks/cpm.go

@@ -4,10 +4,11 @@
 package mocks
 
 import (
+	time "time"
+
 	gomock "github.com/golang/mock/gomock"
 	handshake "github.com/lucas-clemente/quic-go/handshake"
-	protocol "github.com/lucas-clemente/quic-go/protocol"
-	time "time"
+	protocol "github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
 // Mock of ConnectionParametersManager interface

internal/mocks/gen.go

@@ -1,4 +1,4 @@
 package mocks
 
-//go:generate mockgen -destination mocks_fc/flow_control_manager.go -package mocks_fc github.com/lucas-clemente/quic-go/flowcontrol FlowControlManager
+//go:generate mockgen -destination mocks_fc/flow_control_manager.go -package mocks_fc github.com/lucas-clemente/quic-go/internal/flowcontrol FlowControlManager
 //go:generate mockgen -destination cpm.go -package mocks github.com/lucas-clemente/quic-go/handshake ConnectionParametersManager

internal/mocks/mocks_fc/flow_control_manager.go

@@ -1,12 +1,12 @@
 // Automatically generated by MockGen. DO NOT EDIT!
-// Source: github.com/lucas-clemente/quic-go/flowcontrol (interfaces: FlowControlManager)
+// Source: github.com/lucas-clemente/quic-go/internal/flowcontrol (interfaces: FlowControlManager)
 
 package mocks_fc
 
 import (
 	gomock "github.com/golang/mock/gomock"
-	flowcontrol "github.com/lucas-clemente/quic-go/flowcontrol"
-	protocol "github.com/lucas-clemente/quic-go/protocol"
+	flowcontrol "github.com/lucas-clemente/quic-go/internal/flowcontrol"
+	protocol "github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
 // Mock of FlowControlManager interface

internal/protocol/server_parameters.go

@@ -33,27 +33,27 @@ const AckSendDelay = 25 * time.Millisecond
 
 // ReceiveStreamFlowControlWindow is the stream-level flow control window for receiving data
 // This is the value that Google servers are using
-const ReceiveStreamFlowControlWindow ByteCount = (1 << 10) * 32 // 32 kB
+const ReceiveStreamFlowControlWindow = (1 << 10) * 32 // 32 kB
 
 // ReceiveConnectionFlowControlWindow is the connection-level flow control window for receiving data
 // This is the value that Google servers are using
-const ReceiveConnectionFlowControlWindow ByteCount = (1 << 10) * 48 // 48 kB
+const ReceiveConnectionFlowControlWindow = (1 << 10) * 48 // 48 kB
 
 // DefaultMaxReceiveStreamFlowControlWindowServer is the default maximum stream-level flow control window for receiving data, for the server
 // This is the value that Google servers are using
-const DefaultMaxReceiveStreamFlowControlWindowServer ByteCount = 1 * (1 << 20) // 1 MB
+const DefaultMaxReceiveStreamFlowControlWindowServer = 1 * (1 << 20) // 1 MB
 
 // DefaultMaxReceiveConnectionFlowControlWindowServer is the default connection-level flow control window for receiving data, for the server
 // This is the value that Google servers are using
-const DefaultMaxReceiveConnectionFlowControlWindowServer ByteCount = 1.5 * (1 << 20) // 1.5 MB
+const DefaultMaxReceiveConnectionFlowControlWindowServer = 1.5 * (1 << 20) // 1.5 MB
 
 // DefaultMaxReceiveStreamFlowControlWindowClient is the default maximum stream-level flow control window for receiving data, for the client
 // This is the value that Chromium is using
-const DefaultMaxReceiveStreamFlowControlWindowClient ByteCount = 6 * (1 << 20) // 6 MB
+const DefaultMaxReceiveStreamFlowControlWindowClient = 6 * (1 << 20) // 6 MB
 
 // DefaultMaxReceiveConnectionFlowControlWindowClient is the default connection-level flow control window for receiving data, for the client
 // This is the value that Google servers are using
-const DefaultMaxReceiveConnectionFlowControlWindowClient ByteCount = 15 * (1 << 20) // 15 MB
+const DefaultMaxReceiveConnectionFlowControlWindowClient = 15 * (1 << 20) // 15 MB
 
 // ConnectionFlowControlMultiplier determines how much larger the connection flow control windows needs to be relative to any stream's flow control window
 // This is the value that Chromium is using

internal/protocol/version.go.orig

@@ -0,0 +1,61 @@
+package protocol
+
+// VersionNumber is a version number as int
+type VersionNumber int
+
+// The version numbers, making grepping easier
+const (
+	Version35 VersionNumber = 35 + iota
+	Version36
+	Version37
+<<<<<<< Updated upstream
+=======
+	Version38
+>>>>>>> Stashed changes
+	Version39
+	VersionWhatever    VersionNumber = 0 // for when the version doesn't matter
+	VersionUnsupported VersionNumber = -1
+	VersionUnknown     VersionNumber = -2
+)
+
+// SupportedVersions lists the versions that the server supports
+// must be in sorted descending order
+var SupportedVersions = []VersionNumber{
+	Version39, //Version37, Version36, Version35,
+}
+
+// VersionNumberToTag maps version numbers ('32') to tags ('Q032')
+func VersionNumberToTag(vn VersionNumber) uint32 {
+	v := uint32(vn)
+	return 'Q' + ((v/100%10)+'0')<<8 + ((v/10%10)+'0')<<16 + ((v%10)+'0')<<24
+}
+
+// VersionTagToNumber is built from VersionNumberToTag in init()
+func VersionTagToNumber(v uint32) VersionNumber {
+	return VersionNumber(((v>>8)&0xff-'0')*100 + ((v>>16)&0xff-'0')*10 + ((v>>24)&0xff - '0'))
+}
+
+// IsSupportedVersion returns true if the server supports this version
+func IsSupportedVersion(supported []VersionNumber, v VersionNumber) bool {
+	for _, t := range supported {
+		if t == v {
+			return true
+		}
+	}
+	return false
+}
+
+// ChooseSupportedVersion finds the best version in the overlap of ours and theirs
+// ours is a slice of versions that we support, sorted by our preference (descending)
+// theirs is a slice of versions offered by the peer. The order does not matter
+// if no suitable version is found, it returns VersionUnsupported
+func ChooseSupportedVersion(ours, theirs []VersionNumber) VersionNumber {
+	for _, ourVer := range ours {
+		for _, theirVer := range theirs {
+			if ourVer == theirVer {
+				return ourVer
+			}
+		}
+	}
+	return VersionUnsupported
+}

internal/utils/byteorder.go

@@ -4,7 +4,7 @@ import (
 	"bytes"
 	"io"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
 // A ByteOrder specifies how to convert byte sequences into 16-, 32-, or 64-bit unsigned integers.

internal/utils/byteorder_test.go

@@ -1,7 +1,7 @@
 package utils
 
 import (
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )

internal/utils/connection_id.go

@@ -4,7 +4,7 @@ import (
 	"crypto/rand"
 	"encoding/binary"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
 // GenerateConnectionID generates a connection ID using cryptographic random

internal/utils/minmax.go

@@ -4,7 +4,7 @@ import (
 	"math"
 	"time"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
 // InfDuration is a duration of infinite length

internal/utils/minmax_test.go

@@ -3,7 +3,7 @@ package utils
 import (
 	"time"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )

internal/utils/packet_interval.go

@@ -1,6 +1,6 @@
 package utils
 
-import "github.com/lucas-clemente/quic-go/protocol"
+import "github.com/lucas-clemente/quic-go/internal/protocol"
 
 // PacketInterval is an interval from one PacketNumber to the other
 // +gen linkedlist

internal/utils/streamframe_interval.go

@@ -1,6 +1,6 @@
 package utils
 
-import "github.com/lucas-clemente/quic-go/protocol"
+import "github.com/lucas-clemente/quic-go/internal/protocol"
 
 // ByteInterval is an interval from one ByteCount to the other
 // +gen linkedlist

internal/wire/ack_frame.go

@@ -1,12 +1,12 @@
-package frames
+package wire
 
 import (
 	"bytes"
 	"errors"
 	"time"
 
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
-	"github.com/lucas-clemente/quic-go/protocol"
 )
 
 var (

internal/wire/ack_frame_test.go

@@ -1,4 +1,4 @@
-package frames
+package wire
 
 import (
 	"bytes"
@@ -6,7 +6,7 @@ import (
 	"io"
 	"time"
 
-	"github.com/lucas-clemente/quic-go/protocol"
+	"github.com/lucas-clemente/quic-go/internal/protocol"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )

internal/wire/ack_range.go

@@ -1,6 +1,6 @@
-package frames
+package wire
 
-import "github.com/lucas-clemente/quic-go/protocol"
+import "github.com/lucas-clemente/quic-go/internal/protocol"
 
 // AckRange is an ACK range
 type AckRange struct {