drop support for QUIC 34

fixes #368

h2quic/server_test.go

@@ -316,7 +316,7 @@ var _ = Describe("H2 server", func() {
 
 	Context("setting http headers", func() {
 		expected := http.Header{
-			"Alt-Svc":            {`quic=":443"; ma=2592000; v="36,35,34"`},
+			"Alt-Svc":            {`quic=":443"; ma=2592000; v="36,35"`},
 			"Alternate-Protocol": {`443:quic`},
 		}
 

handshake/connection_parameters_manager.go

@@ -41,8 +41,7 @@ type connectionParametersManager struct {
 	version     protocol.VersionNumber
 	perspective protocol.Perspective
 
-	flowControlNegotiated                bool
+	flowControlNegotiated bool
-	hasReceivedMaxIncomingDynamicStreams bool
 
 	truncateConnectionID                   bool
 	maxStreamsPerConnection                uint32
@@ -113,7 +112,6 @@ func (h *connectionParametersManager) SetFromMap(params map[Tag][]byte) error {
 			return ErrMalformedTag
 		}
 		h.maxIncomingDynamicStreamsPerConnection = h.negotiateMaxIncomingDynamicStreamsPerConnection(clientValue)
-		h.hasReceivedMaxIncomingDynamicStreams = true
 	}
 	if value, ok := params[TagICSL]; ok {
 		clientValue, err := utils.ReadUint32(bytes.NewBuffer(value))
@@ -175,23 +173,18 @@ func (h *connectionParametersManager) GetHelloMap() (map[Tag][]byte, error) {
 	utils.WriteUint32(cfcw, uint32(h.GetReceiveConnectionFlowControlWindow()))
 	mspc := bytes.NewBuffer([]byte{})
 	utils.WriteUint32(mspc, h.maxStreamsPerConnection)
+	mids := bytes.NewBuffer([]byte{})
+	utils.WriteUint32(mids, protocol.MaxIncomingDynamicStreamsPerConnection)
 	icsl := bytes.NewBuffer([]byte{})
 	utils.WriteUint32(icsl, uint32(h.GetIdleConnectionStateLifetime()/time.Second))
 
-	tags := map[Tag][]byte{
+	return map[Tag][]byte{
 		TagICSL: icsl.Bytes(),
 		TagMSPC: mspc.Bytes(),
+		TagMIDS: mids.Bytes(),
 		TagCFCW: cfcw.Bytes(),
 		TagSFCW: sfcw.Bytes(),
-	}
+	}, nil
-
-	if h.version > protocol.Version34 {
-		mids := bytes.NewBuffer([]byte{})
-		utils.WriteUint32(mids, protocol.MaxIncomingDynamicStreamsPerConnection)
-		tags[TagMIDS] = mids.Bytes()
-	}
-
-	return tags, nil
 }
 
 // GetSendStreamFlowControlWindow gets the size of the stream-level flow control window for sending data
@@ -243,10 +236,7 @@ func (h *connectionParametersManager) GetMaxOutgoingStreams() uint32 {
 	h.mutex.RLock()
 	defer h.mutex.RUnlock()
 
-	if h.version > protocol.Version34 && h.hasReceivedMaxIncomingDynamicStreams {
+	return h.maxIncomingDynamicStreamsPerConnection
-		return h.maxIncomingDynamicStreamsPerConnection
-	}
-	return h.maxStreamsPerConnection
 }
 
 // GetMaxIncomingStreams get the maximum number of incoming streams per connection
@@ -254,14 +244,8 @@ func (h *connectionParametersManager) GetMaxIncomingStreams() uint32 {
 	h.mutex.RLock()
 	defer h.mutex.RUnlock()
 
-	var val uint32
+	maxStreams := protocol.MaxIncomingDynamicStreamsPerConnection
-	if h.version <= protocol.Version34 {
+	return utils.MaxUint32(uint32(maxStreams)+protocol.MaxStreamsMinimumIncrement, uint32(float64(maxStreams)*protocol.MaxStreamsMultiplier))
-		val = h.maxStreamsPerConnection
-	} else {
-		val = protocol.MaxIncomingDynamicStreamsPerConnection
-	}
-
-	return utils.MaxUint32(val+protocol.MaxStreamsMinimumIncrement, uint32(float64(val)*protocol.MaxStreamsMultiplier))
 }
 
 // GetIdleConnectionStateLifetime gets the idle timeout

handshake/connection_parameters_manager_test.go

@@ -32,13 +32,6 @@ var _ = Describe("ConnectionsParameterManager", func() {
 			Expect(entryMap).To(HaveKey(TagMIDS))
 		})
 
-		It("doesn't add the MaximumIncomingDynamicStreams tag for QUIC 34", func() {
-			cpm.version = protocol.Version34
-			entryMap, err := cpm.GetHelloMap()
-			Expect(err).ToNot(HaveOccurred())
-			Expect(entryMap).ToNot(HaveKey(TagMIDS))
-		})
-
 		It("sets the stream-level flow control windows in SHLO", func() {
 			cpm.receiveStreamFlowControlWindow = 0xDEADBEEF
 			entryMap, err := cpm.GetHelloMap()
@@ -102,13 +95,6 @@ var _ = Describe("ConnectionsParameterManager", func() {
 			Expect(entryMap).To(HaveKey(TagCFCW))
 			Expect(binary.LittleEndian.Uint32(entryMap[TagCFCW])).To(BeEquivalentTo(protocol.ReceiveConnectionFlowControlWindow))
 		})
-
-		It("doesn't add the MIDS tag for QUIC 34", func() {
-			cpmClient.version = protocol.Version34
-			entryMap, err := cpmClient.GetHelloMap()
-			Expect(err).ToNot(HaveOccurred())
-			Expect(entryMap).ToNot(HaveKey(TagMIDS))
-		})
 	})
 
 	Context("Truncated connection IDs", func() {
@@ -279,16 +265,6 @@ var _ = Describe("ConnectionsParameterManager", func() {
 				Expect(err).ToNot(HaveOccurred())
 				Expect(cpm.GetMaxOutgoingStreams()).To(Equal(uint32(3)))
 			})
-
-			It("uses the MSPC value for QUIC 34", func() {
-				cpm.version = protocol.Version34
-				err := cpm.SetFromMap(map[Tag][]byte{
-					TagMIDS: {2, 0, 0, 0},
-					TagMSPC: {1, 0, 0, 0},
-				})
-				Expect(err).ToNot(HaveOccurred())
-				Expect(cpm.GetMaxOutgoingStreams()).To(Equal(uint32(1)))
-			})
 		})
 
 		Context("incoming connections", func() {
@@ -300,13 +276,6 @@ var _ = Describe("ConnectionsParameterManager", func() {
 				Expect(err).ToNot(HaveOccurred())
 				Expect(cpm.GetMaxIncomingStreams()).To(BeNumerically(">", protocol.MaxStreamsPerConnection))
 			})
-
-			It("uses the negotiated MSCP value, for QUIC 34", func() {
-				cpm.version = protocol.Version34
-				err := cpm.SetFromMap(map[Tag][]byte{TagMSPC: {60, 0, 0, 0}})
-				Expect(err).ToNot(HaveOccurred())
-				Expect(cpm.GetMaxIncomingStreams()).To(BeNumerically("~", 60*protocol.MaxStreamsMultiplier, 10))
-			})
 		})
 	})
 })

integrationtests/proxy/udp_proxy_test.go

@@ -26,7 +26,7 @@ var _ = Describe("UDP Proxy", func() {
 			ConnectionID:         1337,
 			TruncateConnectionID: false,
 		}
-		hdr.Write(b, protocol.Version34, protocol.PerspectiveServer)
+		hdr.Write(b, protocol.VersionWhatever, protocol.PerspectiveServer)
 		raw := b.Bytes()
 		raw = append(raw, payload...)
 		return raw

packet_packer_test.go

@@ -65,7 +65,7 @@ var _ = Describe("Packet packer", func() {
 		}
 		publicHeaderLen = 1 + 8 + 2 // 1 flag byte, 8 connection ID, 2 packet number
 		maxFrameSize = protocol.MaxFrameAndPublicHeaderSize - publicHeaderLen
-		packer.version = protocol.Version34
+		packer.version = protocol.VersionWhatever
 		packer.isForwardSecure = true
 	})
 

packet_unpacker_test.go

@@ -72,12 +72,12 @@ var _ = Describe("Packet unpacker", func() {
 	})
 
 	It("unpacks ACK frames", func() {
-		unpacker.version = protocol.Version34
+		unpacker.version = protocol.VersionWhatever
 		f := &frames.AckFrame{
 			LargestAcked: 0x13,
 			LowestAcked:  1,
 		}
-		err := f.Write(buf, protocol.Version34)
+		err := f.Write(buf, protocol.VersionWhatever)
 		Expect(err).ToNot(HaveOccurred())
 		setData(buf.Bytes())
 		packet, err := unpacker.Unpack(hdrBin, hdr, data)

protocol/version.go

@@ -11,8 +11,7 @@ type VersionNumber int
 
 // The version numbers, making grepping easier
 const (
-	Version34 VersionNumber = 34 + iota
+	Version35 VersionNumber = 35 + iota
-	Version35
 	Version36
 	VersionWhatever    = 0 // for when the version doesn't matter
 	VersionUnsupported = -1
@@ -21,7 +20,7 @@ const (
 // SupportedVersions lists the versions that the server supports
 // must be in sorted order
 var SupportedVersions = []VersionNumber{
-	Version34, Version35, Version36,
+	Version35, Version36,
 }
 
 // SupportedVersionsAsTags is needed for the SHLO crypto message

protocol/version_test.go

@@ -8,20 +8,18 @@ import (
 var _ = Describe("Version", func() {
 	It("converts tags to numbers", func() {
 		Expect(VersionTagToNumber('Q' + '1'<<8 + '2'<<16 + '3'<<24)).To(Equal(VersionNumber(123)))
-		Expect(VersionTagToNumber('Q' + '0'<<8 + '3'<<16 + '4'<<24)).To(Equal(Version34))
 	})
 
 	It("converts number to tag", func() {
 		Expect(VersionNumberToTag(VersionNumber(123))).To(Equal(uint32('Q' + '1'<<8 + '2'<<16 + '3'<<24)))
-		Expect(VersionNumberToTag(Version34)).To(Equal(uint32('Q' + '0'<<8 + '3'<<16 + '4'<<24)))
 	})
 
 	It("has proper tag list", func() {
-		Expect(SupportedVersionsAsTags).To(Equal([]byte("Q034Q035Q036")))
+		Expect(SupportedVersionsAsTags).To(Equal([]byte("Q035Q036")))
 	})
 
 	It("has proper version list", func() {
-		Expect(SupportedVersionsAsString).To(Equal("36,35,34"))
+		Expect(SupportedVersionsAsString).To(Equal("36,35"))
 	})
 
 	It("recognizes supported versions", func() {

public_header_test.go

@@ -19,7 +19,7 @@ var _ = Describe("Public Header", func() {
 			Expect(hdr.VersionFlag).To(BeTrue())
 			Expect(hdr.ResetFlag).To(BeFalse())
 			Expect(hdr.ConnectionID).To(Equal(protocol.ConnectionID(0x4cfa9f9b668619f6)))
-			Expect(hdr.VersionNumber).To(Equal(protocol.Version34))
+			Expect(hdr.VersionNumber).To(Equal(protocol.VersionNumber(34)))
 			Expect(hdr.SupportedVersions).To(BeEmpty())
 			Expect(hdr.PacketNumber).To(Equal(protocol.PacketNumber(1)))
 			Expect(b.Len()).To(BeZero())