add a method to retrieve non-QUIC packets from the Transport (#3992)

transport_test.go

@@ -2,6 +2,7 @@ package quic
 
 import (
 	"bytes"
+	"context"
 	"crypto/rand"
 	"crypto/tls"
 	"errors"
@@ -122,7 +123,7 @@ var _ = Describe("Transport", func() {
 		tr.Close()
 	})
 
-	It("drops unparseable packets", func() {
+	It("drops unparseable QUIC packets", func() {
 		addr := &net.UDPAddr{IP: net.IPv4(9, 8, 7, 6), Port: 1234}
 		packetChan := make(chan packetToRead)
 		tracer := mocklogging.NewMockTracer(mockCtrl)
@@ -136,7 +137,7 @@ var _ = Describe("Transport", func() {
 		tracer.EXPECT().DroppedPacket(addr, logging.PacketTypeNotDetermined, protocol.ByteCount(4), logging.PacketDropHeaderParseError).Do(func(net.Addr, logging.PacketType, protocol.ByteCount, logging.PacketDropReason) { close(dropped) })
 		packetChan <- packetToRead{
 			addr: addr,
-			data: []byte{0, 1, 2, 3},
+			data: []byte{0x40 /* set the QUIC bit */, 1, 2, 3},
 		}
 		Eventually(dropped).Should(BeClosed())
 
@@ -323,6 +324,78 @@ var _ = Describe("Transport", func() {
 		conns := getMultiplexer().(*connMultiplexer).conns
 		Expect(len(conns)).To(BeZero())
 	})
+
+	It("allows receiving non-QUIC packets", func() {
+		remoteAddr := &net.UDPAddr{IP: net.IPv4(9, 8, 7, 6), Port: 1234}
+		packetChan := make(chan packetToRead)
+		tracer := mocklogging.NewMockTracer(mockCtrl)
+		tr := &Transport{
+			Conn:               newMockPacketConn(packetChan),
+			ConnectionIDLength: 10,
+			Tracer:             tracer,
+		}
+		tr.init(true)
+		receivedPacketChan := make(chan []byte)
+		go func() {
+			defer GinkgoRecover()
+			b := make([]byte, 100)
+			n, addr, err := tr.ReadNonQUICPacket(context.Background(), b)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(addr).To(Equal(remoteAddr))
+			receivedPacketChan <- b[:n]
+		}()
+		// Receiving of non-QUIC packets is enabled when ReadNonQUICPacket is called.
+		// Give the Go routine some time to spin up.
+		time.Sleep(scaleDuration(50 * time.Millisecond))
+		packetChan <- packetToRead{
+			addr: remoteAddr,
+			data: []byte{0 /* don't set the QUIC bit */, 1, 2, 3},
+		}
+
+		Eventually(receivedPacketChan).Should(Receive(Equal([]byte{0, 1, 2, 3})))
+
+		// shutdown
+		close(packetChan)
+		tr.Close()
+	})
+
+	It("drops non-QUIC packet if the application doesn't process them quickly enough", func() {
+		remoteAddr := &net.UDPAddr{IP: net.IPv4(9, 8, 7, 6), Port: 1234}
+		packetChan := make(chan packetToRead)
+		tracer := mocklogging.NewMockTracer(mockCtrl)
+		tr := &Transport{
+			Conn:               newMockPacketConn(packetChan),
+			ConnectionIDLength: 10,
+			Tracer:             tracer,
+		}
+		tr.init(true)
+
+		ctx, cancel := context.WithCancel(context.Background())
+		cancel()
+		_, _, err := tr.ReadNonQUICPacket(ctx, make([]byte, 10))
+		Expect(err).To(MatchError(context.Canceled))
+
+		for i := 0; i < maxQueuedNonQUICPackets; i++ {
+			packetChan <- packetToRead{
+				addr: remoteAddr,
+				data: []byte{0 /* don't set the QUIC bit */, 1, 2, 3},
+			}
+		}
+
+		done := make(chan struct{})
+		tracer.EXPECT().DroppedPacket(remoteAddr, logging.PacketTypeNotDetermined, protocol.ByteCount(4), logging.PacketDropDOSPrevention).Do(func(net.Addr, logging.PacketType, protocol.ByteCount, logging.PacketDropReason) {
+			close(done)
+		})
+		packetChan <- packetToRead{
+			addr: remoteAddr,
+			data: []byte{0 /* don't set the QUIC bit */, 1, 2, 3},
+		}
+		Eventually(done).Should(BeClosed())
+
+		// shutdown
+		close(packetChan)
+		tr.Close()
+	})
 })
 
 type mockSyscallConn struct {