implement receiving of DATAGRAM frames

datagram_queue.go

@@ -1,50 +1,76 @@
 package quic
 
 import (
-	"sync"
-
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+	"github.com/lucas-clemente/quic-go/internal/utils"
 	"github.com/lucas-clemente/quic-go/internal/wire"
 )
 
 type datagramQueue struct {
-	mutex sync.Mutex
-	queue chan *wire.DatagramFrame
+	sendQueue chan *wire.DatagramFrame
+	rcvQueue  chan []byte
 
 	closeErr error
 	closed   chan struct{}
 
 	hasData func()
+
+	logger utils.Logger
 }
 
-func newDatagramQueue(hasData func()) *datagramQueue {
+func newDatagramQueue(hasData func(), logger utils.Logger) *datagramQueue {
 	return &datagramQueue{
-		queue:   make(chan *wire.DatagramFrame),
-		hasData: hasData,
-		closed:  make(chan struct{}),
+		hasData:   hasData,
+		sendQueue: make(chan *wire.DatagramFrame),
+		rcvQueue:  make(chan []byte, protocol.DatagramRcvQueueLen),
+		closed:    make(chan struct{}),
+		logger:    logger,
 	}
 }
 
-// AddAndWait queues a new DATAGRAM frame.
+// AddAndWait queues a new DATAGRAM frame for sending.
 // It blocks until the frame has been dequeued.
 func (h *datagramQueue) AddAndWait(f *wire.DatagramFrame) error {
 	h.hasData()
 	select {
-	case h.queue <- f:
+	case h.sendQueue <- f:
 		return nil
 	case <-h.closed:
 		return h.closeErr
 	}
 }
 
+// Get dequeues a DATAGRAM frame for sending.
 func (h *datagramQueue) Get() *wire.DatagramFrame {
 	select {
-	case f := <-h.queue:
+	case f := <-h.sendQueue:
 		return f
 	default:
 		return nil
 	}
 }
 
+// HandleDatagramFrame handles a received DATAGRAM frame.
+func (h *datagramQueue) HandleDatagramFrame(f *wire.DatagramFrame) {
+	data := make([]byte, len(f.Data))
+	copy(data, f.Data)
+	select {
+	case h.rcvQueue <- data:
+	default:
+		h.logger.Debugf("Discarding DATAGRAM frame (%d bytes payload)", len(f.Data))
+	}
+}
+
+// Receive gets a received DATAGRAM frame.
+func (h *datagramQueue) Receive() ([]byte, error) {
+	select {
+	case data := <-h.rcvQueue:
+		return data, nil
+	case <-h.closed:
+		return nil, h.closeErr
+	}
+}
+
 func (h *datagramQueue) CloseWithError(e error) {
 	h.closeErr = e
 	close(h.closed)