mirrors/uquic
1
0
Fork 0
mirror of https://github.com/refraction-networking/uquic.git synced 2025-04-06 21:57:36 +03:00
Code Issues Projects Releases Packages Wiki Activity

add server.Serve() API and improve server tests by listening on port 0

Browse source
This commit is contained in:
Lucas Clemente 2016-06-03 13:10:04 +02:00
parent c0b73c4beb
commit a47a04d16d
2 changed files with 50 additions and 48 deletions
Download patch file Download diff file Expand all files Collapse all files

4
server.go
View file

@ -76,6 +76,10 @@ func (s *Server) ListenAndServe() error {
if err != nil { if err != nil {
return err return err
} }
return s.Serve(conn)
}
func (s *Server) Serve(conn *net.UDPConn) error {
s.connMutex.Lock() s.connMutex.Lock()
s.conn = conn s.conn = conn
s.connMutex.Unlock() s.connMutex.Unlock()

72
server_test.go
View file

@ -2,7 +2,6 @@ package quic
import ( import (
"net" "net"
"time"
"github.com/lucas-clemente/quic-go/crypto" "github.com/lucas-clemente/quic-go/crypto"
"github.com/lucas-clemente/quic-go/handshake" "github.com/lucas-clemente/quic-go/handshake"
@ -92,76 +91,75 @@ var _ = Describe("Server", func() {
}) })
It("setups and responds with version negotiation", func(done Done) { It("setups and responds with version negotiation", func(done Done) {
server, err := NewServer("127.0.0.1:13370", testdata.GetTLSConfig(), nil) addr, err := net.ResolveUDPAddr("udp", "127.0.0.1:0")
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
server, err := NewServer("", testdata.GetTLSConfig(), nil)
Expect(err).ToNot(HaveOccurred())
serverConn, err := net.ListenUDP("udp", addr)
Expect(err).NotTo(HaveOccurred())
addr = serverConn.LocalAddr().(*net.UDPAddr)
go func() { go func() {
defer GinkgoRecover() defer GinkgoRecover()
err := server.ListenAndServe() err := server.Serve(serverConn)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
close(done) close(done)
}() }()
addr, err := net.ResolveUDPAddr("udp", "127.0.0.1:13370") clientConn, err := net.DialUDP("udp", nil, addr)
Expect(err).ToNot(HaveOccurred())
conn, err := net.DialUDP("udp", nil, addr)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Eventually(func() error { _, err = clientConn.Write([]byte{0x09, 0x01, 0, 0, 0, 0, 0, 0, 0, 0x01, 0x01, 'Q', '0', '0', '0', 0x01})
_, err = conn.Write([]byte{0x09, 0x01, 0, 0, 0, 0, 0, 0, 0, 0x01, 0x01, 'Q', '0', '0', '0', 0x01}) Expect(err).NotTo(HaveOccurred())
if err != nil {
return err
}
data := make([]byte, 1000) data := make([]byte, 1000)
var n int var n int
n, _, err = conn.ReadFromUDP(data) n, _, err = clientConn.ReadFromUDP(data)
if err != nil { Expect(err).NotTo(HaveOccurred())
return err
}
data = data[:n] data = data[:n]
expected := append( expected := append(
[]byte{0xd, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, []byte{0xd, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
protocol.SupportedVersionsAsTags..., protocol.SupportedVersionsAsTags...,
) )
Expect(data).To(Equal(expected)) Expect(data).To(Equal(expected))
return nil
}).ShouldNot(HaveOccurred())
err = server.Close() err = server.Close()
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
}, 1) })
It("setups and responds with error on invalid frame", func(done Done) { It("setups and responds with error on invalid frame", func(done Done) {
server, err := NewServer("127.0.0.1:13370", testdata.GetTLSConfig(), nil) addr, err := net.ResolveUDPAddr("udp", "127.0.0.1:0")
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
server, err := NewServer("", testdata.GetTLSConfig(), nil)
Expect(err).ToNot(HaveOccurred())
serverConn, err := net.ListenUDP("udp", addr)
Expect(err).NotTo(HaveOccurred())
addr = serverConn.LocalAddr().(*net.UDPAddr)
go func() { go func() {
defer GinkgoRecover() defer GinkgoRecover()
err := server.ListenAndServe() err := server.Serve(serverConn)
Expect(err).NotTo(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
close(done) close(done)
}() }()
addr, err := net.ResolveUDPAddr("udp", "127.0.0.1:13370") clientConn, err := net.DialUDP("udp", nil, addr)
Expect(err).ToNot(HaveOccurred())
conn, err := net.DialUDP("udp", nil, addr)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Eventually(func() error { _, err = clientConn.Write([]byte{0x09, 0x01, 0, 0, 0, 0, 0, 0, 0, 0x01, 0x01, 'Q', '0', '0', '0', 0x01, 0x00})
_, err = conn.Write([]byte{0x09, 0x01, 0, 0, 0, 0, 0, 0, 0, 0x01, 0x01, 'Q', '0', '0', '0', 0x01, 0x00}) Expect(err).NotTo(HaveOccurred())
if err != nil {
return err
}
data := make([]byte, 1000) data := make([]byte, 1000)
var n int var n int
n, _, err = conn.ReadFromUDP(data) n, _, err = clientConn.ReadFromUDP(data)
if err != nil { Expect(err).NotTo(HaveOccurred())
return err
}
Expect(n).ToNot(BeZero()) Expect(n).ToNot(BeZero())
return nil
}).ShouldNot(HaveOccurred())
time.Sleep(20 * time.Millisecond)
err = server.Close() err = server.Close()
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
}, 1) })
}) })