handle deadlines; change ConnClient.WriteRequest()

conn-client.go

@@ -4,28 +4,33 @@ import (
 	"bufio"
 	"net"
 	"strconv"
+	"time"
 )
 
 // ConnClient is a client-side RTSP connection.
 type ConnClient struct {
-	nconn    net.Conn
+	nconn        net.Conn
-	br       *bufio.Reader
+	br           *bufio.Reader
-	bw       *bufio.Writer
+	bw           *bufio.Writer
-	session  string
+	readTimeout  time.Duration
-	curCseq  int
+	writeTimeout time.Duration
-	authProv *AuthClient
+	session      string
+	curCSeq      int
+	authProv     *AuthClient
 }
 
 // NewConnClient allocates a ConnClient.
-func NewConnClient(nconn net.Conn) *ConnClient {
+func NewConnClient(nconn net.Conn, readTimeout time.Duration, writeTimeout time.Duration) *ConnClient {
 	return &ConnClient{
-		nconn: nconn,
+		nconn:        nconn,
-		br:    bufio.NewReaderSize(nconn, 4096),
+		br:           bufio.NewReaderSize(nconn, 4096),
-		bw:    bufio.NewWriterSize(nconn, 4096),
+		bw:           bufio.NewWriterSize(nconn, 4096),
+		readTimeout:  readTimeout,
+		writeTimeout: writeTimeout,
 	}
 }
 
-// NetConn returns the underlying new.Conn.
+// NetConn returns the underlying net.Conn.
 func (c *ConnClient) NetConn() net.Conn {
 	return c.nconn
 }
@@ -43,8 +48,8 @@ func (c *ConnClient) SetCredentials(wwwAuthenticateHeader []string, user string,
 	return err
 }
 
-// WriteRequest writes a Request.
+// WriteRequest writes a request and reads a response.
-func (c *ConnClient) WriteRequest(req *Request) error {
+func (c *ConnClient) WriteRequest(req *Request) (*Response, error) {
 	if c.session != "" {
 		if req.Header == nil {
 			req.Header = make(Header)
@@ -59,27 +64,31 @@ func (c *ConnClient) WriteRequest(req *Request) error {
 		req.Header["Authorization"] = c.authProv.GenerateHeader(req.Method, req.Url)
 	}
 
-	// automatically insert cseq into every outgoing request
+	// automatically insert CSeq
 	if req.Header == nil {
 		req.Header = make(Header)
 	}
-	c.curCseq += 1
+	c.curCSeq += 1
-	req.Header["CSeq"] = []string{strconv.FormatInt(int64(c.curCseq), 10)}
+	req.Header["CSeq"] = []string{strconv.FormatInt(int64(c.curCSeq), 10)}
 
-	return req.write(c.bw)
+	c.nconn.SetWriteDeadline(time.Now().Add(c.writeTimeout))
-}
+	err := req.write(c.bw)
+	if err != nil {
+		return nil, err
+	}
 
-// ReadResponse reads a response.
+	c.nconn.SetReadDeadline(time.Now().Add(c.readTimeout))
-func (c *ConnClient) ReadResponse() (*Response, error) {
 	return readResponse(c.br)
 }
 
 // ReadInterleavedFrame reads an InterleavedFrame.
 func (c *ConnClient) ReadInterleavedFrame() (*InterleavedFrame, error) {
+	c.nconn.SetReadDeadline(time.Now().Add(c.readTimeout))
 	return readInterleavedFrame(c.br)
 }
 
 // WriteInterleavedFrame writes an InterleavedFrame.
 func (c *ConnClient) WriteInterleavedFrame(frame *InterleavedFrame) error {
+	c.nconn.SetWriteDeadline(time.Now().Add(c.writeTimeout))
 	return frame.write(c.bw)
 }

conn-server.go

@@ -3,45 +3,54 @@ package gortsplib
 import (
 	"bufio"
 	"net"
+	"time"
 )
 
 // ConnServer is a server-side RTSP connection.
 type ConnServer struct {
-	nconn net.Conn
+	nconn        net.Conn
-	br    *bufio.Reader
+	br           *bufio.Reader
-	bw    *bufio.Writer
+	bw           *bufio.Writer
+	readTimeout  time.Duration
+	writeTimeout time.Duration
 }
 
 // NewConnServer allocates a ConnClient.
-func NewConnServer(nconn net.Conn) *ConnServer {
+func NewConnServer(nconn net.Conn, readTimeout time.Duration, writeTimeout time.Duration) *ConnServer {
 	return &ConnServer{
-		nconn: nconn,
+		nconn:        nconn,
-		br:    bufio.NewReaderSize(nconn, 4096),
+		br:           bufio.NewReaderSize(nconn, 4096),
-		bw:    bufio.NewWriterSize(nconn, 4096),
+		bw:           bufio.NewWriterSize(nconn, 4096),
+		readTimeout:  readTimeout,
+		writeTimeout: writeTimeout,
 	}
 }
 
-// NetConn returns the underlying new.Conn.
+// NetConn returns the underlying net.Conn.
 func (s *ConnServer) NetConn() net.Conn {
 	return s.nconn
 }
 
 // ReadRequest reads a Request.
 func (s *ConnServer) ReadRequest() (*Request, error) {
+	s.nconn.SetReadDeadline(time.Time{}) // disable deadline
 	return readRequest(s.br)
 }
 
 // WriteResponse writes a response.
 func (s *ConnServer) WriteResponse(res *Response) error {
+	s.nconn.SetWriteDeadline(time.Now().Add(s.writeTimeout))
 	return res.write(s.bw)
 }
 
 // ReadInterleavedFrame reads an InterleavedFrame.
 func (s *ConnServer) ReadInterleavedFrame() (*InterleavedFrame, error) {
+	s.nconn.SetReadDeadline(time.Now().Add(s.readTimeout))
 	return readInterleavedFrame(s.br)
 }
 
 // WriteInterleavedFrame writes an InterleavedFrame.
 func (s *ConnServer) WriteInterleavedFrame(frame *InterleavedFrame) error {
+	s.nconn.SetWriteDeadline(time.Now().Add(s.writeTimeout))
 	return frame.write(s.bw)
 }