mirror of
https://github.com/refraction-networking/uquic.git
synced 2025-04-03 20:27:35 +03:00
fd2c345152
This commit introduces additional platform-dependent checking when the kernel returns an error. Previously, the session is terminated when PingFrame sends a discovery packet larger than the limit. With this commit, the error is checked, and if it is "datagram too large", the error is ignored. Additionally, 1. This commit re-enables MTU discovery on Windows unless it is disabled explicitly by user (Undo #3276), 2. Set IP_DONTFRAGMENT and IPV6_DONTFRAG with error checking on Windows, and 3. Set IP_MTU_DISCOVERY to PMTUDISC_DO for both IPv4 and IPv6 on Linux so that the kernel will return "message too long". Fixes #3273 #3327
88 lines
2 KiB
Go
88 lines
2 KiB
Go
package quic
|
|
|
|
type sender interface {
|
|
Send(p *packetBuffer)
|
|
Run() error
|
|
WouldBlock() bool
|
|
Available() <-chan struct{}
|
|
Close()
|
|
}
|
|
|
|
type sendQueue struct {
|
|
queue chan *packetBuffer
|
|
closeCalled chan struct{} // runStopped when Close() is called
|
|
runStopped chan struct{} // runStopped when the run loop returns
|
|
available chan struct{}
|
|
conn sendConn
|
|
}
|
|
|
|
var _ sender = &sendQueue{}
|
|
|
|
const sendQueueCapacity = 8
|
|
|
|
func newSendQueue(conn sendConn) sender {
|
|
return &sendQueue{
|
|
conn: conn,
|
|
runStopped: make(chan struct{}),
|
|
closeCalled: make(chan struct{}),
|
|
available: make(chan struct{}, 1),
|
|
queue: make(chan *packetBuffer, sendQueueCapacity),
|
|
}
|
|
}
|
|
|
|
// Send sends out a packet. It's guaranteed to not block.
|
|
// Callers need to make sure that there's actually space in the send queue by calling WouldBlock.
|
|
// Otherwise Send will panic.
|
|
func (h *sendQueue) Send(p *packetBuffer) {
|
|
select {
|
|
case h.queue <- p:
|
|
case <-h.runStopped:
|
|
default:
|
|
panic("sendQueue.Send would have blocked")
|
|
}
|
|
}
|
|
|
|
func (h *sendQueue) WouldBlock() bool {
|
|
return len(h.queue) == sendQueueCapacity
|
|
}
|
|
|
|
func (h *sendQueue) Available() <-chan struct{} {
|
|
return h.available
|
|
}
|
|
|
|
func (h *sendQueue) Run() error {
|
|
defer close(h.runStopped)
|
|
var shouldClose bool
|
|
for {
|
|
if shouldClose && len(h.queue) == 0 {
|
|
return nil
|
|
}
|
|
select {
|
|
case <-h.closeCalled:
|
|
h.closeCalled = nil // prevent this case from being selected again
|
|
// make sure that all queued packets are actually sent out
|
|
shouldClose = true
|
|
case p := <-h.queue:
|
|
if err := h.conn.Write(p.Data); err != nil {
|
|
// This additional check enables:
|
|
// 1. Checking for "datagram too large" message from the kernel, as such,
|
|
// 2. Path MTU discovery,and
|
|
// 3. Eventual detection of loss PingFrame.
|
|
if !isMsgSizeErr(err) {
|
|
return err
|
|
}
|
|
}
|
|
p.Release()
|
|
select {
|
|
case h.available <- struct{}{}:
|
|
default:
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func (h *sendQueue) Close() {
|
|
close(h.closeCalled)
|
|
// wait until the run loop returned
|
|
<-h.runStopped
|
|
}
|