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

use a connection in the Client

Browse source
This commit is contained in:
Marten Seemann 2017-02-19 14:29:00 +07:00
parent d61c0eb85d
commit af4b36b002
No known key found for this signature in database
GPG key ID: 3603F40B121FCDEA
4 changed files with 52 additions and 73 deletions
Download patch file Download diff file Expand all files Collapse all files

26
client.go
View file

@ -16,8 +16,7 @@ import (
// A Client of QUIC
type Client struct {
addr *net.UDPAddr
conn *net.UDPConn
conn connection
hostname string
connectionID protocol.ConnectionID
@ -48,7 +47,7 @@ func NewClient(host string, tlsConfig *tls.Config, cryptoChangeCallback CryptoCh
return nil, err
}
conn, err := net.ListenUDP("udp", &net.UDPAddr{IP: net.IPv4zero, Port: 0})
udpConn, err := net.ListenUDP("udp", &net.UDPAddr{IP: net.IPv4zero, Port: 0})
if err != nil {
return nil, err
}
@ -64,8 +63,7 @@ func NewClient(host string, tlsConfig *tls.Config, cryptoChangeCallback CryptoCh
}
client := &Client{
addr: udpAddr,
conn: conn,
conn: &conn{pconn: udpConn, currentAddr: udpAddr},
hostname: hostname,
version: protocol.SupportedVersions[len(protocol.SupportedVersions)-1], // use the highest supported version by default
connectionID: connectionID,
@ -90,7 +88,7 @@ func (c *Client) Listen() error {
data := getPacketBuffer()
data = data[:protocol.MaxPacketSize]
n, _, err := c.conn.ReadFromUDP(data)
n, addr, err := c.conn.Read(data)
if err != nil {
if strings.HasSuffix(err.Error(), "use of closed network connection") {
return nil
@ -99,7 +97,7 @@ func (c *Client) Listen() error {
}
data = data[:n]
err = c.handlePacket(data)
err = c.handlePacket(addr, data)
if err != nil {
utils.Errorf("error handling packet: %s", err.Error())
c.session.Close(err)
@ -124,7 +122,7 @@ func (c *Client) Close(e error) error {
return c.conn.Close()
}
func (c *Client) handlePacket(packet []byte) error {
func (c *Client) handlePacket(remoteAddr net.Addr, packet []byte) error {
if protocol.ByteCount(len(packet)) > protocol.MaxPacketSize {
return qerr.PacketTooLarge
}
@ -198,7 +196,7 @@ func (c *Client) handlePacket(packet []byte) error {
}
c.session.handlePacket(&receivedPacket{
remoteAddr: c.addr,
remoteAddr: remoteAddr,
publicHeader: hdr,
data: packet[len(packet)-r.Len():],
rcvTime: rcvTime,
@ -208,7 +206,15 @@ func (c *Client) handlePacket(packet []byte) error {
func (c *Client) createNewSession(negotiatedVersions []protocol.VersionNumber) error {
var err error
c.session, err = newClientSession(c.conn, c.addr, c.hostname, c.version, c.connectionID, c.tlsConfig, c.closeCallback, c.cryptoChangeCallback, negotiatedVersions)
c.session, err = newClientSession(
c.conn,
c.hostname,
c.version,
c.connectionID,
c.tlsConfig,
c.closeCallback,
c.cryptoChangeCallback,
negotiatedVersions)
if err != nil {
return err
}

92
client_test.go
View file

@ -21,10 +21,12 @@ var _ = Describe("Client", func() {
var (
client *Client
sess *mockSession
packetConn *mockPacketConn
versionNegotiateCallbackCalled bool
)
BeforeEach(func() {
packetConn = &mockPacketConn{}
versionNegotiateCallbackCalled = false
client = &Client{
versionNegotiateCallback: func() error {
@ -32,20 +34,14 @@ var _ = Describe("Client", func() {
return nil
},
}
addr := &net.UDPAddr{IP: net.IPv4(192, 168, 100, 200), Port: 1337}
sess = &mockSession{connectionID: 0x1337}
client.connectionID = 0x1337
client.session = sess
client.version = protocol.Version36
client.conn = &conn{pconn: packetConn, currentAddr: addr}
})
startUDPConn := func() {
var err error
client.addr, err = net.ResolveUDPAddr("udp", "127.0.0.1:0")
Expect(err).ToNot(HaveOccurred())
client.conn, err = net.ListenUDP("udp", client.addr)
Expect(err).NotTo(HaveOccurred())
}
It("creates a new client", func() {
var err error
client, err = NewClient("quic.clemente.io:1337", nil, nil, nil)
@ -55,27 +51,28 @@ var _ = Describe("Client", func() {
})
It("errors on invalid public header", func() {
err := client.handlePacket(nil)
err := client.handlePacket(nil, nil)
Expect(err.(*qerr.QuicError).ErrorCode).To(Equal(qerr.InvalidPacketHeader))
})
It("errors on large packets", func() {
err := client.handlePacket(bytes.Repeat([]byte{'a'}, int(protocol.MaxPacketSize)+1))
err := client.handlePacket(nil, bytes.Repeat([]byte{'a'}, int(protocol.MaxPacketSize)+1))
Expect(err).To(MatchError(qerr.PacketTooLarge))
})
It("properly closes the client", func(done Done) {
PIt("properly closes the client", func(done Done) {
testErr := errors.New("test error")
time.Sleep(10 * time.Millisecond) // Wait for old goroutines to finish
numGoRoutines := runtime.NumGoroutine()
startUDPConn()
var stoppedListening bool
go func() {
defer GinkgoRecover()
err := client.Listen()
Expect(err).ToNot(HaveOccurred())
stoppedListening = true
}()
testErr := errors.New("test error")
err := client.Close(testErr)
Expect(err).ToNot(HaveOccurred())
Eventually(sess.closed).Should(BeTrue())
@ -84,7 +81,7 @@ var _ = Describe("Client", func() {
Eventually(func() bool { return stoppedListening }).Should(BeTrue())
Eventually(runtime.NumGoroutine()).Should(Equal(numGoRoutines))
close(done)
})
}, 10)
It("only closes the client once", func() {
client.closed = 1
@ -95,7 +92,6 @@ var _ = Describe("Client", func() {
})
It("creates new sessions with the right parameters", func() {
startUDPConn()
client.session = nil
client.hostname = "hostname"
err := client.createNewSession(nil)
@ -116,61 +112,40 @@ var _ = Describe("Client", func() {
Context("handling packets", func() {
It("errors on too large packets", func() {
err := client.handlePacket(bytes.Repeat([]byte{'f'}, int(protocol.MaxPacketSize+1)))
err := client.handlePacket(nil, bytes.Repeat([]byte{'f'}, int(protocol.MaxPacketSize+1)))
Expect(err).To(MatchError(qerr.PacketTooLarge))
})
It("handles packets", func(done Done) {
startUDPConn()
serverConn, err := net.DialUDP("udp", nil, client.conn.LocalAddr().(*net.UDPAddr))
Expect(err).NotTo(HaveOccurred())
var stoppedListening bool
go func() {
defer GinkgoRecover()
_ = client.Listen()
// it should continue listening when receiving valid packets
stoppedListening = true
}()
Expect(sess.packetCount).To(BeZero())
It("handles packets", func() {
ph := PublicHeader{
PacketNumber: 1,
PacketNumberLen: protocol.PacketNumberLen2,
ConnectionID: 0x1337,
}
b := &bytes.Buffer{}
err = ph.Write(b, protocol.Version36, protocol.PerspectiveServer)
Expect(err).ToNot(HaveOccurred())
_, err = serverConn.Write(b.Bytes())
err := ph.Write(b, protocol.Version36, protocol.PerspectiveServer)
Expect(err).ToNot(HaveOccurred())
packetConn.dataToRead = b.Bytes()
Expect(sess.packetCount).To(BeZero())
var stoppedListening bool
go func() {
_ = client.Listen()
// it should continue listening when receiving valid packets
stoppedListening = true
}()
Eventually(func() int { return sess.packetCount }).Should(Equal(1))
Expect(sess.closed).To(BeFalse())
Eventually(func() bool { return stoppedListening }).Should(BeFalse())
err = client.Close(nil)
Expect(err).ToNot(HaveOccurred())
close(done)
Consistently(func() bool { return stoppedListening }).Should(BeFalse())
})
It("closes the session when encountering an error while handling a packet", func(done Done) {
startUDPConn()
serverConn, err := net.DialUDP("udp", nil, client.conn.LocalAddr().(*net.UDPAddr))
Expect(err).NotTo(HaveOccurred())
var listenErr error
go func() {
defer GinkgoRecover()
_, err = serverConn.Write(bytes.Repeat([]byte{0xff}, 100))
Expect(err).ToNot(HaveOccurred())
}()
listenErr = client.Listen()
It("closes the session when encountering an error while handling a packet", func() {
packetConn.dataToRead = bytes.Repeat([]byte{0xff}, 100)
listenErr := client.Listen()
Expect(listenErr).To(HaveOccurred())
Eventually(sess.closed).Should(BeTrue())
Expect(sess.closed).To(BeTrue())
Expect(sess.closeReason).To(MatchError(listenErr))
close(done)
})
})
@ -200,19 +175,18 @@ var _ = Describe("Client", func() {
b := &bytes.Buffer{}
err := ph.Write(b, protocol.VersionWhatever, protocol.PerspectiveServer)
Expect(err).ToNot(HaveOccurred())
err = client.handlePacket(b.Bytes())
err = client.handlePacket(nil, b.Bytes())
Expect(err).ToNot(HaveOccurred())
Expect(client.versionNegotiated).To(BeTrue())
Expect(versionNegotiateCallbackCalled).To(BeTrue())
})
It("changes the version after receiving a version negotiation packet", func() {
startUDPConn()
newVersion := protocol.Version35
Expect(newVersion).ToNot(Equal(client.version))
Expect(sess.packetCount).To(BeZero())
client.connectionID = 0x1337
err := client.handlePacket(getVersionNegotiation([]protocol.VersionNumber{newVersion}))
err := client.handlePacket(nil, getVersionNegotiation([]protocol.VersionNumber{newVersion}))
Expect(client.version).To(Equal(newVersion))
Expect(client.versionNegotiated).To(BeTrue())
Expect(versionNegotiateCallbackCalled).To(BeTrue())
@ -229,7 +203,7 @@ var _ = Describe("Client", func() {
})
It("errors if no matching version is found", func() {
err := client.handlePacket(getVersionNegotiation([]protocol.VersionNumber{1}))
err := client.handlePacket(nil, getVersionNegotiation([]protocol.VersionNumber{1}))
Expect(err).To(MatchError(qerr.InvalidVersion))
})
@ -237,7 +211,7 @@ var _ = Describe("Client", func() {
// if the version was not yet negotiated, handlePacket would return a VersionNegotiationMismatch error, see above test
client.versionNegotiated = true
Expect(sess.packetCount).To(BeZero())
err := client.handlePacket(getVersionNegotiation([]protocol.VersionNumber{1}))
err := client.handlePacket(nil, getVersionNegotiation([]protocol.VersionNumber{1}))
Expect(err).ToNot(HaveOccurred())
Expect(client.versionNegotiated).To(BeTrue())
Expect(sess.packetCount).To(BeZero())
@ -245,7 +219,7 @@ var _ = Describe("Client", func() {
})
It("errors if the server should have accepted the offered version", func() {
err := client.handlePacket(getVersionNegotiation([]protocol.VersionNumber{client.version}))
err := client.handlePacket(nil, getVersionNegotiation([]protocol.VersionNumber{client.version}))
Expect(err).To(MatchError(qerr.Error(qerr.InvalidVersionNegotiationPacket, "Server already supports client's version and should have accepted the connection.")))
})
})

4
session.go
View file

@ -132,9 +132,9 @@ func newSession(conn connection, v protocol.VersionNumber, connectionID protocol
return s, err
}
func newClientSession(pconn net.PacketConn, addr net.Addr, hostname string, v protocol.VersionNumber, connectionID protocol.ConnectionID, tlsConfig *tls.Config, closeCallback closeCallback, cryptoChangeCallback CryptoChangeCallback, negotiatedVersions []protocol.VersionNumber) (*session, error) {
func newClientSession(conn connection, hostname string, v protocol.VersionNumber, connectionID protocol.ConnectionID, tlsConfig *tls.Config, closeCallback closeCallback, cryptoChangeCallback CryptoChangeCallback, negotiatedVersions []protocol.VersionNumber) (*session, error) {
s := &session{
conn: &conn{pconn: pconn, currentAddr: addr},
conn: conn,
connectionID: connectionID,
perspective: protocol.PerspectiveClient,
version: v,

3
session_test.go
View file

@ -148,8 +148,7 @@ var _ = Describe("Session", func() {
sess.connectionParameters = cpm
clientSess, err = newClientSession(
&net.UDPConn{},
&net.UDPAddr{},
nil,
"hostname",
protocol.Version35,
0,