av/protocol/rtsp/rtsp.go

/*
NAME
  rtsp.go

DESCRIPTION
  rtsp.go provides functionality for forming and sending RTSP requests for
	methods, DESCRIBE, OPTIONS, SETUP and PLAY.

AUTHORS
  Saxon A. Nelson-Milton <saxon@ausocean.org>

LICENSE
 	This is Copyright (C) 2019 the Australian Ocean Lab (AusOcean).

  It is free software: you can redistribute it and/or modify them
  under the terms of the GNU General Public License as published by the
  Free Software Foundation, either version 3 of the License, or (at your
  option) any later version.

  It is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
 	for more details.

  You should have received a copy of the GNU General Public License
  in gpl.txt.  If not, see http://www.gnu.org/licenses.

	Copyright (c) 2015, T. Jameson Little <t.jameson.little@gmail.com>
	All rights reserved.

	Redistribution and use in source and binary forms, with or without modification,
	are permitted provided that the following conditions are met:

	1. Redistributions of source code must retain the above copyright notice, this
	list of conditions and the following disclaimer.

	2. Redistributions in binary form must reproduce the above copyright notice,
	this list of conditions and the following disclaimer in the documentation
	and/or other materials provided with the distribution.

	3. Neither the name of the copyright holder nor the names of its contributors
	may be used to endorse or promote products derived from this software without
	specific prior written permission.

	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
	ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
	WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
	FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
	CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package rtsp

import (
	"bufio"
	"fmt"
	"io"
	"io/ioutil"
	"net"
	"net/http"
	"net/url"
	"strconv"
	"strings"
)

// rtsp protocol described by:
// https://tools.ietf.org/html/rfc7826

// RTSP methods.
const (
	describe = "DESCRIBE"
	options  = "OPTIONS"
	play     = "PLAY"
	setup    = "SETUP"
)

// session describes an RTSP session.
type session struct {
	cSeq    int
	url     *url.URL
	conn    net.Conn
	session string
}

// NewSession returns a pointer to a new session. The URL u will be parsed and
// a connection to the RTSP server will be made.
func NewSession(u string) (*session, error) {
	s := &session{}
	var err error
	s.url, err = url.Parse(u)
	if err != nil {
		return nil, err
	}
	s.conn, err = net.Dial("tcp", s.url.Host)
	if err != nil {
		return nil, err
	}
	return s, nil
}

// Describe forms and sends an RTSP request of method DESCRIBE to the RTSP server.
func (s *session) Describe() (*Response, error) {
	return s.writeRequest(describe, func(req *Request) { req.Header.Add("Accept", "application/sdp") }, nil)
}

// Options forms and sends an RTSP request of method OPTIONS to the RTSP server.
func (s *session) Options(urlStr string) (*Response, error) {
	return s.writeRequest(options, nil, nil)
}

// Setup forms and sends an RTSP request of method SETUP to the RTSP server.
func (s *session) Setup(transport string) (*Response, error) {
	return s.writeRequest(
		setup,
		func(req *Request) {
			req.Header.Add("Transport", transport)
		},
		func(resp *Response) {
			s.session = resp.Header.Get("session")
		},
	)
}

// Play forms and sends an RTSP request of method PLAY to the RTSP server
func (s *session) Play() (*Response, error) {
	return s.writeRequest(play, func(req *Request) { req.Header.Add("session", s.session) }, nil)
}

// writeRequest creates an RTSP request of the method given and writes it to the
// the session connection.
//
//headerOp and respOp define any operation that needs
// to occur to the request or response for the given method.
func (s *session) writeRequest(method string, headerOp func(*Request), respOp func(*Response)) (*Response, error) {
	req, err := NewRequest(method, s.nextCSeq(), s.url, nil)
	if err != nil {
		return nil, err
	}

	if headerOp != nil {
		headerOp(req)
	}

	_, err = io.WriteString(s.conn, req.String())
	if err != nil {
		return nil, err
	}

	res, err := ReadResponse(bufio.NewReader(s.conn))
	if err != nil {
		return nil, err
	}

	if respOp != nil {
		respOp(res)
	}
	return res, nil
}

func (s *session) nextCSeq() string {
	s.cSeq++
	return strconv.Itoa(s.cSeq)
}

// Request describes an RTSP request.
type Request struct {
	Method        string
	URL           *url.URL
	Proto         string
	ProtoMajor    int
	ProtoMinor    int
	Header        http.Header
	ContentLength int
	Body          io.ReadCloser
}

// String returns a formatted string of the Request.
func (r Request) String() string {
	s := fmt.Sprintf("%s %s %s/%d.%d\r\n", r.Method, r.URL, r.Proto, r.ProtoMajor, r.ProtoMinor)
	for k, v := range r.Header {
		for _, v := range v {
			s += fmt.Sprintf("%s: %s\r\n", k, v)
		}
	}
	s += "\r\n"
	if r.Body != nil {
		str, _ := ioutil.ReadAll(r.Body)
		s += string(str)
	}
	return s
}

// NewRequest returns a pointer to a new Request.
func NewRequest(method, cSeq string, u *url.URL, body io.ReadCloser) (*Request, error) {
	req := &Request{
		Method:     method,
		URL:        u,
		Proto:      "RTSP",
		ProtoMajor: 1,
		ProtoMinor: 0,
		Header:     map[string][]string{"CSeq": []string{cSeq}},
		Body:       body,
	}
	return req, nil
}

// Response describes an RTSP response.
type Response struct {
	Proto         string
	ProtoMajor    int
	ProtoMinor    int
	StatusCode    int
	Status        string
	ContentLength int64
	Header        http.Header
	Body          io.ReadCloser
}

// String returns a formatted string of the Response.
func (r Response) String() string {
	s := fmt.Sprintf("%s/%d.%d %d %s\n", r.Proto, r.ProtoMajor, r.ProtoMinor, r.StatusCode, r.Status)
	for k, v := range r.Header {
		for _, v := range v {
			s += fmt.Sprintf("%s: %s\n", k, v)
		}
	}
	return s
}

// ReadResponse will read the response of the RTSP request from the connection,
// and return a pointer to a new Response.
func ReadResponse(b *bufio.Reader) (*Response, error) {
	res := &Response{}
	res.Header = make(map[string][]string)

	// TODO: allow CR, LF, or CRLF
	s, err := b.ReadString('\n')
	if err != nil {
		return nil, err
	}

	parts := strings.SplitN(s, " ", 3)
	res.Proto, res.ProtoMajor, res.ProtoMinor, err = parseVersion(parts[0])
	if err != nil {
		return nil, err
	}

	res.StatusCode, err = strconv.Atoi(parts[1])
	if err != nil {
		return nil, err
	}

	res.Status = strings.TrimSpace(parts[2])

	for {
		s, err = b.ReadString('\n')
		if err != nil {
			return nil, err
		}

		s = strings.TrimRight(s, "\r\n")
		if s == "" {
			break
		}

		parts = strings.SplitN(s, ":", 2)
		res.Header.Add(strings.TrimSpace(parts[0]), strings.TrimSpace(parts[1]))
	}

	res.ContentLength, err = strconv.ParseInt(res.Header.Get("Content-Length"), 10, 64)
	if err != nil {
		return nil, err
	}

	res.Body = closer{b}
	return res, nil
}

type closer struct {
	*bufio.Reader
}

func (c closer) Close() error {
	if c.Reader == nil {
		return nil
	}
	c.Reader = nil
	return nil
}

// parseVersion returns the protocol type, major version and minor version.
func parseVersion(s string) (proto string, maj, min int, err error) {
	parts := strings.SplitN(s, "/", 2)
	proto = parts[0]
	parts = strings.SplitN(parts[1], ".", 2)

	maj, err = strconv.Atoi(parts[0])
	if err != nil {
		return
	}

	min, err = strconv.Atoi(parts[0])
	if err != nil {
		return
	}
	return
}