2020-10-19 20:17:48 +00:00
|
|
|
package client
|
2019-12-31 12:48:17 +00:00
|
|
|
|
|
|
|
import (
|
2020-05-10 20:56:46 +00:00
|
|
|
"errors"
|
2019-12-31 12:48:17 +00:00
|
|
|
"fmt"
|
|
|
|
"io"
|
|
|
|
"net"
|
2020-08-03 15:35:34 +00:00
|
|
|
"strconv"
|
2019-12-31 12:48:17 +00:00
|
|
|
"strings"
|
2020-10-19 20:17:48 +00:00
|
|
|
"sync"
|
2020-09-03 14:24:39 +00:00
|
|
|
"sync/atomic"
|
2020-06-21 09:30:30 +00:00
|
|
|
"time"
|
2019-12-31 12:48:17 +00:00
|
|
|
|
2020-01-20 09:21:05 +00:00
|
|
|
"github.com/aler9/gortsplib"
|
2020-11-15 16:56:54 +00:00
|
|
|
"github.com/aler9/gortsplib/pkg/auth"
|
|
|
|
"github.com/aler9/gortsplib/pkg/base"
|
|
|
|
"github.com/aler9/gortsplib/pkg/headers"
|
|
|
|
"github.com/aler9/gortsplib/pkg/rtcpreceiver"
|
2020-10-13 22:02:55 +00:00
|
|
|
|
2020-11-01 21:56:56 +00:00
|
|
|
"github.com/aler9/rtsp-simple-server/internal/conf"
|
|
|
|
"github.com/aler9/rtsp-simple-server/internal/externalcmd"
|
2020-12-08 11:21:06 +00:00
|
|
|
"github.com/aler9/rtsp-simple-server/internal/logger"
|
2020-11-01 21:56:56 +00:00
|
|
|
"github.com/aler9/rtsp-simple-server/internal/serverudp"
|
|
|
|
"github.com/aler9/rtsp-simple-server/internal/stats"
|
2019-12-31 12:48:17 +00:00
|
|
|
)
|
|
|
|
|
2020-06-21 09:30:30 +00:00
|
|
|
const (
|
2020-10-19 20:17:48 +00:00
|
|
|
checkStreamInterval = 5 * time.Second
|
|
|
|
receiverReportInterval = 10 * time.Second
|
2020-12-05 19:42:59 +00:00
|
|
|
sessionID = "12345678"
|
2020-06-21 09:30:30 +00:00
|
|
|
)
|
|
|
|
|
2020-10-19 20:17:48 +00:00
|
|
|
type streamTrack struct {
|
2020-07-19 15:54:31 +00:00
|
|
|
rtpPort int
|
|
|
|
rtcpPort int
|
|
|
|
}
|
|
|
|
|
2020-10-19 20:17:48 +00:00
|
|
|
type describeData struct {
|
2020-10-27 23:29:53 +00:00
|
|
|
sdp []byte
|
|
|
|
redirect string
|
|
|
|
err error
|
2020-07-12 10:34:35 +00:00
|
|
|
}
|
|
|
|
|
2020-10-19 20:17:48 +00:00
|
|
|
type state int
|
2020-01-20 13:41:04 +00:00
|
|
|
|
|
|
|
const (
|
2020-10-19 20:17:48 +00:00
|
|
|
stateInitial state = iota
|
|
|
|
statePrePlay
|
|
|
|
statePlay
|
|
|
|
statePreRecord
|
|
|
|
stateRecord
|
2020-01-20 13:41:04 +00:00
|
|
|
)
|
|
|
|
|
2020-11-15 16:56:54 +00:00
|
|
|
func (s state) String() string {
|
|
|
|
switch s {
|
2020-10-19 20:17:48 +00:00
|
|
|
case stateInitial:
|
2020-11-15 16:56:54 +00:00
|
|
|
return "initial"
|
2020-10-19 20:17:48 +00:00
|
|
|
case statePrePlay:
|
2020-11-15 16:56:54 +00:00
|
|
|
return "prePlay"
|
2020-10-19 20:17:48 +00:00
|
|
|
case statePlay:
|
2020-11-15 16:56:54 +00:00
|
|
|
return "play"
|
2020-10-19 20:17:48 +00:00
|
|
|
case statePreRecord:
|
2020-11-15 16:56:54 +00:00
|
|
|
return "preRecord"
|
2020-10-19 20:17:48 +00:00
|
|
|
case stateRecord:
|
2020-11-15 16:56:54 +00:00
|
|
|
return "record"
|
2020-05-21 19:46:22 +00:00
|
|
|
}
|
2020-11-15 16:56:54 +00:00
|
|
|
return "invalid"
|
2020-05-21 19:46:22 +00:00
|
|
|
}
|
|
|
|
|
2020-11-05 11:30:25 +00:00
|
|
|
// Path is implemented by path.Path.
|
2020-10-19 20:17:48 +00:00
|
|
|
type Path interface {
|
|
|
|
Name() string
|
|
|
|
SourceTrackCount() int
|
|
|
|
Conf() *conf.PathConf
|
|
|
|
OnClientRemove(*Client)
|
|
|
|
OnClientPlay(*Client)
|
|
|
|
OnClientRecord(*Client)
|
2020-11-07 21:47:10 +00:00
|
|
|
OnClientPause(*Client)
|
2020-10-19 20:17:48 +00:00
|
|
|
OnFrame(int, gortsplib.StreamType, []byte)
|
|
|
|
}
|
|
|
|
|
2020-11-05 11:30:25 +00:00
|
|
|
// Parent is implemented by clientman.ClientMan.
|
2020-10-19 20:17:48 +00:00
|
|
|
type Parent interface {
|
2020-12-08 11:21:06 +00:00
|
|
|
Log(logger.Level, string, ...interface{})
|
2020-10-19 20:17:48 +00:00
|
|
|
OnClientClose(*Client)
|
|
|
|
OnClientDescribe(*Client, string, *base.Request) (Path, error)
|
|
|
|
OnClientAnnounce(*Client, string, gortsplib.Tracks, *base.Request) (Path, error)
|
|
|
|
OnClientSetupPlay(*Client, string, int, *base.Request) (Path, error)
|
|
|
|
}
|
|
|
|
|
2020-11-05 11:30:25 +00:00
|
|
|
// Client is a RTSP client.
|
2020-10-19 20:17:48 +00:00
|
|
|
type Client struct {
|
2020-11-01 16:33:06 +00:00
|
|
|
rtspPort int
|
2020-10-31 15:36:09 +00:00
|
|
|
readTimeout time.Duration
|
|
|
|
runOnConnect string
|
|
|
|
runOnConnectRestart bool
|
|
|
|
protocols map[gortsplib.StreamProtocol]struct{}
|
2020-11-01 16:33:06 +00:00
|
|
|
wg *sync.WaitGroup
|
|
|
|
stats *stats.Stats
|
2020-12-05 19:42:59 +00:00
|
|
|
serverUDPRtp *serverudp.Server
|
|
|
|
serverUDPRtcp *serverudp.Server
|
2020-12-06 17:01:10 +00:00
|
|
|
conn *gortsplib.ServerConn
|
2020-10-31 15:36:09 +00:00
|
|
|
parent Parent
|
2020-10-19 20:17:48 +00:00
|
|
|
|
|
|
|
state state
|
|
|
|
path Path
|
2020-09-18 20:43:39 +00:00
|
|
|
authUser string
|
|
|
|
authPass string
|
2020-10-05 19:07:34 +00:00
|
|
|
authHelper *auth.Server
|
2020-09-18 20:43:39 +00:00
|
|
|
authFailures int
|
|
|
|
streamProtocol gortsplib.StreamProtocol
|
2020-10-19 20:17:48 +00:00
|
|
|
streamTracks map[int]*streamTrack
|
2020-11-28 23:32:30 +00:00
|
|
|
rtcpReceivers map[int]*rtcpreceiver.RtcpReceiver
|
2020-09-18 20:43:39 +00:00
|
|
|
udpLastFrameTimes []*int64
|
2020-12-12 22:37:15 +00:00
|
|
|
writeFrameEnable bool
|
|
|
|
writeFrameMutex sync.Mutex
|
|
|
|
onReadCmd *externalcmd.Cmd
|
|
|
|
onPublishCmd *externalcmd.Cmd
|
2020-07-29 21:30:42 +00:00
|
|
|
|
2020-10-19 20:17:48 +00:00
|
|
|
// in
|
2020-11-21 10:57:38 +00:00
|
|
|
describeData chan describeData // from path
|
2020-10-19 20:17:48 +00:00
|
|
|
terminate chan struct{}
|
2020-12-12 22:37:15 +00:00
|
|
|
|
|
|
|
backgroundRecordTerminate chan struct{}
|
|
|
|
backgroundRecordDone chan struct{}
|
2019-12-31 12:48:17 +00:00
|
|
|
}
|
|
|
|
|
2020-11-05 11:30:25 +00:00
|
|
|
// New allocates a Client.
|
2020-10-19 20:17:48 +00:00
|
|
|
func New(
|
2020-11-01 16:33:06 +00:00
|
|
|
rtspPort int,
|
2020-10-19 20:17:48 +00:00
|
|
|
readTimeout time.Duration,
|
|
|
|
runOnConnect string,
|
2020-10-31 15:36:09 +00:00
|
|
|
runOnConnectRestart bool,
|
2020-10-19 20:17:48 +00:00
|
|
|
protocols map[gortsplib.StreamProtocol]struct{},
|
2020-11-01 16:33:06 +00:00
|
|
|
wg *sync.WaitGroup,
|
|
|
|
stats *stats.Stats,
|
2020-12-05 19:42:59 +00:00
|
|
|
serverUDPRtp *serverudp.Server,
|
|
|
|
serverUDPRtcp *serverudp.Server,
|
2020-12-06 17:01:10 +00:00
|
|
|
conn *gortsplib.ServerConn,
|
2020-10-19 20:17:48 +00:00
|
|
|
parent Parent) *Client {
|
|
|
|
|
|
|
|
c := &Client{
|
2020-11-01 16:33:06 +00:00
|
|
|
rtspPort: rtspPort,
|
2020-10-31 15:36:09 +00:00
|
|
|
readTimeout: readTimeout,
|
|
|
|
runOnConnect: runOnConnect,
|
|
|
|
runOnConnectRestart: runOnConnectRestart,
|
|
|
|
protocols: protocols,
|
2020-11-01 16:33:06 +00:00
|
|
|
wg: wg,
|
|
|
|
stats: stats,
|
2020-12-05 19:42:59 +00:00
|
|
|
serverUDPRtp: serverUDPRtp,
|
|
|
|
serverUDPRtcp: serverUDPRtcp,
|
2020-12-06 17:01:10 +00:00
|
|
|
conn: conn,
|
|
|
|
parent: parent,
|
|
|
|
state: stateInitial,
|
|
|
|
streamTracks: make(map[int]*streamTrack),
|
|
|
|
rtcpReceivers: make(map[int]*rtcpreceiver.RtcpReceiver),
|
|
|
|
terminate: make(chan struct{}),
|
2019-12-31 12:48:17 +00:00
|
|
|
}
|
|
|
|
|
2020-10-19 20:17:48 +00:00
|
|
|
atomic.AddInt64(c.stats.CountClients, 1)
|
2020-12-08 11:21:06 +00:00
|
|
|
c.log(logger.Info, "connected")
|
2020-10-14 17:35:21 +00:00
|
|
|
|
2020-10-19 20:17:48 +00:00
|
|
|
c.wg.Add(1)
|
2020-05-10 14:23:57 +00:00
|
|
|
go c.run()
|
2020-10-19 20:17:48 +00:00
|
|
|
return c
|
2019-12-31 12:48:17 +00:00
|
|
|
}
|
|
|
|
|
2020-11-05 11:30:25 +00:00
|
|
|
// Close closes a Client.
|
2020-10-19 20:17:48 +00:00
|
|
|
func (c *Client) Close() {
|
|
|
|
atomic.AddInt64(c.stats.CountClients, -1)
|
2020-08-31 20:29:30 +00:00
|
|
|
close(c.terminate)
|
|
|
|
}
|
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
// IsSource implements path.source.
|
2020-10-19 20:17:48 +00:00
|
|
|
func (c *Client) IsSource() {}
|
2019-12-31 12:48:17 +00:00
|
|
|
|
2020-12-08 11:21:06 +00:00
|
|
|
func (c *Client) log(level logger.Level, format string, args ...interface{}) {
|
|
|
|
c.parent.Log(level, "[client %s] "+format, append([]interface{}{c.conn.NetConn().RemoteAddr().String()}, args...)...)
|
2020-10-19 20:17:48 +00:00
|
|
|
}
|
2020-07-29 21:30:42 +00:00
|
|
|
|
2020-10-19 20:17:48 +00:00
|
|
|
func (c *Client) ip() net.IP {
|
2020-05-03 21:26:41 +00:00
|
|
|
return c.conn.NetConn().RemoteAddr().(*net.TCPAddr).IP
|
|
|
|
}
|
|
|
|
|
2020-10-19 20:17:48 +00:00
|
|
|
func (c *Client) zone() string {
|
2020-05-03 21:26:41 +00:00
|
|
|
return c.conn.NetConn().RemoteAddr().(*net.TCPAddr).Zone
|
|
|
|
}
|
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
var errTerminated = errors.New("terminated")
|
2020-08-31 13:31:37 +00:00
|
|
|
|
2020-10-19 20:17:48 +00:00
|
|
|
func (c *Client) run() {
|
|
|
|
defer c.wg.Done()
|
2020-12-08 11:21:06 +00:00
|
|
|
defer c.log(logger.Info, "disconnected")
|
2020-10-14 17:35:21 +00:00
|
|
|
|
2020-10-19 20:17:48 +00:00
|
|
|
if c.runOnConnect != "" {
|
2020-11-21 12:34:27 +00:00
|
|
|
onConnectCmd := externalcmd.New(c.runOnConnect, c.runOnConnectRestart, externalcmd.Environment{
|
2020-11-01 16:33:06 +00:00
|
|
|
Path: "",
|
|
|
|
Port: strconv.FormatInt(int64(c.rtspPort), 10),
|
|
|
|
})
|
2020-11-21 12:34:27 +00:00
|
|
|
defer onConnectCmd.Close()
|
2020-02-16 12:04:43 +00:00
|
|
|
}
|
2020-02-15 17:25:29 +00:00
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
readDone := c.conn.Read(c.onRequest, c.onFrame)
|
|
|
|
|
|
|
|
select {
|
|
|
|
case err := <-readDone:
|
|
|
|
c.conn.Close()
|
|
|
|
if err != io.EOF && err != errTerminated {
|
|
|
|
c.log(logger.Info, "ERR: %s", err)
|
2020-01-03 22:05:06 +00:00
|
|
|
}
|
2020-05-10 14:23:57 +00:00
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
switch c.state {
|
|
|
|
case statePlay:
|
|
|
|
c.stopPlay()
|
|
|
|
|
|
|
|
case stateRecord:
|
|
|
|
c.stopRecord()
|
|
|
|
}
|
|
|
|
|
|
|
|
if c.path != nil {
|
|
|
|
c.path.OnClientRemove(c)
|
|
|
|
c.path = nil
|
|
|
|
}
|
|
|
|
|
|
|
|
c.parent.OnClientClose(c)
|
|
|
|
<-c.terminate
|
|
|
|
|
|
|
|
case <-c.terminate:
|
|
|
|
c.conn.Close()
|
|
|
|
<-readDone
|
|
|
|
|
|
|
|
switch c.state {
|
|
|
|
case statePlay:
|
|
|
|
c.stopPlay()
|
|
|
|
|
|
|
|
case stateRecord:
|
|
|
|
c.stopRecord()
|
|
|
|
}
|
|
|
|
|
|
|
|
if c.path != nil {
|
|
|
|
c.path.OnClientRemove(c)
|
|
|
|
c.path = nil
|
|
|
|
}
|
2020-10-25 18:34:54 +00:00
|
|
|
}
|
2019-12-31 12:48:17 +00:00
|
|
|
}
|
|
|
|
|
2020-11-05 11:30:25 +00:00
|
|
|
type errAuthNotCritical struct {
|
2020-10-19 20:17:48 +00:00
|
|
|
*base.Response
|
|
|
|
}
|
2020-05-10 20:56:46 +00:00
|
|
|
|
2020-11-05 11:30:25 +00:00
|
|
|
func (errAuthNotCritical) Error() string {
|
2020-10-19 20:17:48 +00:00
|
|
|
return "auth not critical"
|
|
|
|
}
|
|
|
|
|
2020-11-05 11:30:25 +00:00
|
|
|
type errAuthCritical struct {
|
2020-10-19 20:17:48 +00:00
|
|
|
*base.Response
|
|
|
|
}
|
|
|
|
|
2020-11-05 11:30:25 +00:00
|
|
|
func (errAuthCritical) Error() string {
|
2020-10-19 20:17:48 +00:00
|
|
|
return "auth critical"
|
|
|
|
}
|
2020-05-10 20:56:46 +00:00
|
|
|
|
2020-11-05 11:30:25 +00:00
|
|
|
// Authenticate performs an authentication.
|
2020-10-19 20:17:48 +00:00
|
|
|
func (c *Client) Authenticate(authMethods []headers.AuthMethod, ips []interface{}, user string, pass string, req *base.Request) error {
|
|
|
|
// validate ip
|
|
|
|
if ips != nil {
|
2020-07-10 09:24:57 +00:00
|
|
|
ip := c.ip()
|
2020-10-19 20:17:48 +00:00
|
|
|
|
2020-07-11 14:40:19 +00:00
|
|
|
if !ipEqualOrInRange(ip, ips) {
|
2020-12-08 11:21:06 +00:00
|
|
|
c.log(logger.Info, "ERR: ip '%s' not allowed", ip)
|
2020-06-15 20:41:14 +00:00
|
|
|
|
2020-11-05 11:30:25 +00:00
|
|
|
return errAuthCritical{&base.Response{
|
2020-10-19 20:17:48 +00:00
|
|
|
StatusCode: base.StatusUnauthorized,
|
|
|
|
}}
|
2020-06-15 20:41:14 +00:00
|
|
|
}
|
2020-10-19 20:17:48 +00:00
|
|
|
}
|
2020-05-10 20:56:46 +00:00
|
|
|
|
2020-10-19 20:17:48 +00:00
|
|
|
// validate user
|
|
|
|
if user != "" {
|
2020-07-10 09:24:57 +00:00
|
|
|
// reset authHelper every time the credentials change
|
|
|
|
if c.authHelper == nil || c.authUser != user || c.authPass != pass {
|
|
|
|
c.authUser = user
|
|
|
|
c.authPass = pass
|
2020-10-19 20:17:48 +00:00
|
|
|
c.authHelper = auth.NewServer(user, pass, authMethods)
|
2020-05-10 20:56:46 +00:00
|
|
|
}
|
|
|
|
|
2020-10-31 14:43:08 +00:00
|
|
|
err := c.authHelper.ValidateHeader(req.Header["Authorization"], req.Method, req.URL)
|
2020-06-15 20:41:14 +00:00
|
|
|
if err != nil {
|
2020-12-05 19:42:59 +00:00
|
|
|
c.authFailures++
|
2020-07-10 09:24:57 +00:00
|
|
|
|
|
|
|
// vlc with login prompt sends 4 requests:
|
|
|
|
// 1) without credentials
|
2020-11-28 23:32:30 +00:00
|
|
|
// 2) with password but without username
|
2020-07-10 09:24:57 +00:00
|
|
|
// 3) without credentials
|
|
|
|
// 4) with password and username
|
2020-12-05 19:42:59 +00:00
|
|
|
// therefore we must allow up to 3 failures
|
2020-07-10 09:24:57 +00:00
|
|
|
if c.authFailures > 3 {
|
2020-12-08 11:21:06 +00:00
|
|
|
c.log(logger.Info, "ERR: unauthorized: %s", err)
|
2020-07-10 09:24:57 +00:00
|
|
|
|
2020-11-05 11:30:25 +00:00
|
|
|
return errAuthCritical{&base.Response{
|
2020-10-19 20:17:48 +00:00
|
|
|
StatusCode: base.StatusUnauthorized,
|
|
|
|
Header: base.Header{
|
|
|
|
"WWW-Authenticate": c.authHelper.GenerateHeader(),
|
|
|
|
},
|
|
|
|
}}
|
2020-12-05 19:42:59 +00:00
|
|
|
}
|
2020-07-10 09:24:57 +00:00
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
if c.authFailures > 1 {
|
2020-12-08 11:21:06 +00:00
|
|
|
c.log(logger.Debug, "WARN: unauthorized: %s", err)
|
2020-10-19 20:17:48 +00:00
|
|
|
}
|
2020-12-05 19:42:59 +00:00
|
|
|
|
|
|
|
return errAuthNotCritical{&base.Response{
|
|
|
|
StatusCode: base.StatusUnauthorized,
|
|
|
|
Header: base.Header{
|
|
|
|
"WWW-Authenticate": c.authHelper.GenerateHeader(),
|
|
|
|
},
|
|
|
|
}}
|
2020-06-15 20:41:14 +00:00
|
|
|
}
|
2020-05-10 20:56:46 +00:00
|
|
|
}
|
|
|
|
|
2020-10-19 20:17:48 +00:00
|
|
|
// login successful, reset authFailures
|
|
|
|
c.authFailures = 0
|
|
|
|
|
2020-05-10 20:56:46 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-11-07 21:47:10 +00:00
|
|
|
func (c *Client) checkState(allowed map[state]struct{}) error {
|
|
|
|
if _, ok := allowed[c.state]; ok {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
var allowedList []state
|
|
|
|
for s := range allowed {
|
|
|
|
allowedList = append(allowedList, s)
|
|
|
|
}
|
2020-12-12 22:37:15 +00:00
|
|
|
|
2020-11-07 21:47:10 +00:00
|
|
|
return fmt.Errorf("client must be in state %v, while is in state %v",
|
|
|
|
allowedList, c.state)
|
|
|
|
}
|
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
func (c *Client) onRequest(req *base.Request) (*base.Response, error) {
|
2020-12-08 11:21:06 +00:00
|
|
|
c.log(logger.Debug, "[c->s] %v", req)
|
2020-12-12 22:37:15 +00:00
|
|
|
res, err := c.onRequestInner(req)
|
|
|
|
c.log(logger.Debug, "[s->c] %v", res)
|
|
|
|
return res, err
|
|
|
|
}
|
2020-01-03 22:05:06 +00:00
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
func (c *Client) onRequestInner(req *base.Request) (*base.Response, error) {
|
2019-12-31 12:48:17 +00:00
|
|
|
switch req.Method {
|
2020-12-05 19:42:59 +00:00
|
|
|
case base.Options:
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
2020-10-05 19:07:34 +00:00
|
|
|
StatusCode: base.StatusOK,
|
|
|
|
Header: base.Header{
|
|
|
|
"Public": base.HeaderValue{strings.Join([]string{
|
2020-12-05 19:42:59 +00:00
|
|
|
string(base.GetParameter),
|
|
|
|
string(base.Describe),
|
|
|
|
string(base.Announce),
|
|
|
|
string(base.Setup),
|
|
|
|
string(base.Play),
|
|
|
|
string(base.Record),
|
|
|
|
string(base.Pause),
|
|
|
|
string(base.Teardown),
|
2020-01-26 11:41:26 +00:00
|
|
|
}, ", ")},
|
2019-12-31 12:48:17 +00:00
|
|
|
},
|
2020-12-12 22:37:15 +00:00
|
|
|
}, nil
|
2019-12-31 12:48:17 +00:00
|
|
|
|
2020-10-05 19:07:34 +00:00
|
|
|
// GET_PARAMETER is used like a ping
|
2020-12-05 19:42:59 +00:00
|
|
|
case base.GetParameter:
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
2020-10-05 19:07:34 +00:00
|
|
|
StatusCode: base.StatusOK,
|
|
|
|
Header: base.Header{
|
|
|
|
"Content-Type": base.HeaderValue{"text/parameters"},
|
2020-09-13 14:58:18 +00:00
|
|
|
},
|
|
|
|
Content: []byte("\n"),
|
2020-12-12 22:37:15 +00:00
|
|
|
}, nil
|
2020-09-13 14:58:18 +00:00
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
case base.Describe:
|
2020-11-07 21:47:10 +00:00
|
|
|
err := c.checkState(map[state]struct{}{
|
|
|
|
stateInitial: {},
|
|
|
|
})
|
|
|
|
if err != nil {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, err
|
2019-12-31 12:48:17 +00:00
|
|
|
}
|
|
|
|
|
2020-11-01 18:09:47 +00:00
|
|
|
basePath, ok := req.URL.BasePath()
|
2020-10-31 14:43:08 +00:00
|
|
|
if !ok {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("unable to find base path (%s)", req.URL)
|
2020-10-31 14:43:08 +00:00
|
|
|
}
|
2020-09-05 18:53:56 +00:00
|
|
|
|
2020-11-07 21:47:10 +00:00
|
|
|
c.describeData = make(chan describeData)
|
|
|
|
|
2020-10-31 14:43:08 +00:00
|
|
|
path, err := c.parent.OnClientDescribe(c, basePath, req)
|
2020-09-19 15:13:45 +00:00
|
|
|
if err != nil {
|
2020-10-19 20:17:48 +00:00
|
|
|
switch terr := err.(type) {
|
2020-11-05 11:30:25 +00:00
|
|
|
case errAuthNotCritical:
|
2020-12-12 22:37:15 +00:00
|
|
|
return terr.Response, nil
|
2020-06-27 19:22:50 +00:00
|
|
|
|
2020-11-05 11:30:25 +00:00
|
|
|
case errAuthCritical:
|
2020-12-12 22:37:15 +00:00
|
|
|
return terr.Response, errTerminated
|
2020-10-19 20:17:48 +00:00
|
|
|
|
|
|
|
default:
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, err
|
2020-05-10 20:56:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-10-19 20:17:48 +00:00
|
|
|
c.path = path
|
2020-08-31 13:31:37 +00:00
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
select {
|
|
|
|
case res := <-c.describeData:
|
|
|
|
c.path.OnClientRemove(c)
|
|
|
|
c.path = nil
|
|
|
|
|
|
|
|
if res.err != nil {
|
|
|
|
c.log(logger.Info, "no one is publishing to path '%s'", basePath)
|
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusNotFound,
|
|
|
|
}, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
if res.redirect != "" {
|
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusMovedPermanently,
|
|
|
|
Header: base.Header{
|
|
|
|
"Location": base.HeaderValue{res.redirect},
|
|
|
|
},
|
|
|
|
}, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusOK,
|
|
|
|
Header: base.Header{
|
|
|
|
"Content-Base": base.HeaderValue{req.URL.String() + "/"},
|
|
|
|
"Content-Type": base.HeaderValue{"application/sdp"},
|
|
|
|
},
|
|
|
|
Content: res.sdp,
|
|
|
|
}, nil
|
|
|
|
|
|
|
|
case <-c.terminate:
|
|
|
|
ch := c.describeData
|
|
|
|
go func() {
|
|
|
|
for range ch {
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
c.path.OnClientRemove(c)
|
|
|
|
c.path = nil
|
|
|
|
|
|
|
|
close(c.describeData)
|
|
|
|
|
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, errTerminated
|
|
|
|
}
|
2019-12-31 12:48:17 +00:00
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
case base.Announce:
|
2020-11-07 21:47:10 +00:00
|
|
|
err := c.checkState(map[state]struct{}{
|
|
|
|
stateInitial: {},
|
|
|
|
})
|
|
|
|
if err != nil {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, err
|
2019-12-31 12:48:17 +00:00
|
|
|
}
|
|
|
|
|
2020-11-28 23:32:30 +00:00
|
|
|
basePath, ok := req.URL.BasePath()
|
|
|
|
if !ok {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("unable to find base path (%s)", req.URL)
|
2020-11-28 23:32:30 +00:00
|
|
|
}
|
|
|
|
|
2020-01-26 11:41:26 +00:00
|
|
|
ct, ok := req.Header["Content-Type"]
|
|
|
|
if !ok || len(ct) != 1 {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("Content-Type header missing")
|
2019-12-31 12:48:17 +00:00
|
|
|
}
|
|
|
|
|
2020-01-26 11:41:26 +00:00
|
|
|
if ct[0] != "application/sdp" {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("unsupported Content-Type '%s'", ct)
|
2019-12-31 12:48:17 +00:00
|
|
|
}
|
|
|
|
|
2020-09-05 12:51:36 +00:00
|
|
|
tracks, err := gortsplib.ReadTracks(req.Content)
|
2019-12-31 12:48:17 +00:00
|
|
|
if err != nil {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("invalid SDP: %s", err)
|
2019-12-31 12:48:17 +00:00
|
|
|
}
|
2020-01-21 09:08:53 +00:00
|
|
|
|
2020-09-05 12:51:36 +00:00
|
|
|
if len(tracks) == 0 {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("no tracks defined")
|
2020-10-31 14:43:08 +00:00
|
|
|
}
|
2020-07-18 11:48:09 +00:00
|
|
|
|
2020-10-31 14:43:08 +00:00
|
|
|
path, err := c.parent.OnClientAnnounce(c, basePath, tracks, req)
|
2019-12-31 12:48:17 +00:00
|
|
|
if err != nil {
|
2020-10-19 20:17:48 +00:00
|
|
|
switch terr := err.(type) {
|
2020-11-05 11:30:25 +00:00
|
|
|
case errAuthNotCritical:
|
2020-12-12 22:37:15 +00:00
|
|
|
return terr.Response, nil
|
2020-10-19 20:17:48 +00:00
|
|
|
|
2020-11-05 11:30:25 +00:00
|
|
|
case errAuthCritical:
|
2020-12-12 22:37:15 +00:00
|
|
|
return terr.Response, errTerminated
|
2020-10-19 20:17:48 +00:00
|
|
|
|
|
|
|
default:
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, err
|
2020-10-19 20:17:48 +00:00
|
|
|
}
|
2019-12-31 12:48:17 +00:00
|
|
|
}
|
2020-10-24 17:55:47 +00:00
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
for trackID, t := range tracks {
|
2020-11-28 23:32:30 +00:00
|
|
|
clockRate, _ := t.ClockRate()
|
2020-12-05 19:42:59 +00:00
|
|
|
c.rtcpReceivers[trackID] = rtcpreceiver.New(nil, clockRate)
|
2020-11-28 23:32:30 +00:00
|
|
|
}
|
|
|
|
|
2020-10-19 20:17:48 +00:00
|
|
|
c.path = path
|
|
|
|
c.state = statePreRecord
|
2019-12-31 12:48:17 +00:00
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
2020-10-05 19:07:34 +00:00
|
|
|
StatusCode: base.StatusOK,
|
2020-12-12 22:37:15 +00:00
|
|
|
}, nil
|
2019-12-31 12:48:17 +00:00
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
case base.Setup:
|
2020-10-05 19:07:34 +00:00
|
|
|
th, err := headers.ReadTransport(req.Header["Transport"])
|
2020-07-18 11:48:09 +00:00
|
|
|
if err != nil {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("transport header: %s", err)
|
2019-12-31 12:48:17 +00:00
|
|
|
}
|
|
|
|
|
2020-11-07 21:47:10 +00:00
|
|
|
if th.Delivery != nil && *th.Delivery == base.StreamDeliveryMulticast {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("multicast is not supported")
|
2019-12-31 12:48:17 +00:00
|
|
|
}
|
|
|
|
|
2020-11-03 11:08:24 +00:00
|
|
|
basePath, controlPath, ok := req.URL.BasePathControlAttr()
|
2020-10-31 14:43:08 +00:00
|
|
|
if !ok {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("unable to find control attribute (%s)", req.URL)
|
2020-08-03 14:56:45 +00:00
|
|
|
}
|
|
|
|
|
2019-12-31 12:48:17 +00:00
|
|
|
switch c.state {
|
|
|
|
// play
|
2020-10-19 20:17:48 +00:00
|
|
|
case stateInitial, statePrePlay:
|
2020-11-07 21:47:10 +00:00
|
|
|
if th.Mode != nil && *th.Mode != headers.TransportModePlay {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("transport header must contain mode=play or not contain a mode")
|
2020-09-27 11:02:36 +00:00
|
|
|
}
|
|
|
|
|
2020-10-19 20:17:48 +00:00
|
|
|
if c.path != nil && basePath != c.path.Name() {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("path has changed, was '%s', now is '%s'", c.path.Name(), basePath)
|
2020-08-03 15:35:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if !strings.HasPrefix(controlPath, "trackID=") {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("invalid control attribute (%s)", controlPath)
|
2020-08-03 15:35:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
tmp, err := strconv.ParseInt(controlPath[len("trackID="):], 10, 64)
|
|
|
|
if err != nil || tmp < 0 {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("invalid track id (%s)", controlPath)
|
2020-08-03 15:35:34 +00:00
|
|
|
}
|
2020-12-05 19:42:59 +00:00
|
|
|
trackID := int(tmp)
|
2020-08-03 15:35:34 +00:00
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
if _, ok := c.streamTracks[trackID]; ok {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("track %d has already been setup", trackID)
|
2020-08-03 15:35:34 +00:00
|
|
|
}
|
|
|
|
|
2020-09-27 13:52:48 +00:00
|
|
|
// play with UDP
|
2020-09-05 20:56:54 +00:00
|
|
|
if th.Protocol == gortsplib.StreamProtocolUDP {
|
2020-10-19 20:17:48 +00:00
|
|
|
if _, ok := c.protocols[gortsplib.StreamProtocolUDP]; !ok {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusUnsupportedTransport,
|
|
|
|
}, nil
|
2020-01-15 21:48:51 +00:00
|
|
|
}
|
|
|
|
|
2020-09-05 11:19:55 +00:00
|
|
|
if len(c.streamTracks) > 0 && c.streamProtocol != gortsplib.StreamProtocolUDP {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("can't receive tracks with different protocols")
|
2019-12-31 13:55:46 +00:00
|
|
|
}
|
|
|
|
|
2020-09-05 20:56:54 +00:00
|
|
|
if th.ClientPorts == nil {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("transport header does not have valid client ports (%v)", req.Header["Transport"])
|
2020-06-27 11:38:35 +00:00
|
|
|
}
|
2019-12-31 12:48:17 +00:00
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
path, err := c.parent.OnClientSetupPlay(c, basePath, trackID, req)
|
2019-12-31 12:48:17 +00:00
|
|
|
if err != nil {
|
2020-10-19 20:17:48 +00:00
|
|
|
switch terr := err.(type) {
|
2020-11-05 11:30:25 +00:00
|
|
|
case errAuthNotCritical:
|
2020-12-12 22:37:15 +00:00
|
|
|
return terr.Response, nil
|
2020-10-19 20:17:48 +00:00
|
|
|
|
2020-11-05 11:30:25 +00:00
|
|
|
case errAuthCritical:
|
2020-12-12 22:37:15 +00:00
|
|
|
return terr.Response, errTerminated
|
2020-10-19 20:17:48 +00:00
|
|
|
|
|
|
|
default:
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, err
|
2020-10-19 20:17:48 +00:00
|
|
|
}
|
2019-12-31 12:48:17 +00:00
|
|
|
}
|
|
|
|
|
2020-10-19 20:17:48 +00:00
|
|
|
c.path = path
|
|
|
|
c.state = statePrePlay
|
|
|
|
|
2020-09-05 11:19:55 +00:00
|
|
|
c.streamProtocol = gortsplib.StreamProtocolUDP
|
2020-12-05 19:42:59 +00:00
|
|
|
c.streamTracks[trackID] = &streamTrack{
|
2020-09-05 20:56:54 +00:00
|
|
|
rtpPort: (*th.ClientPorts)[0],
|
|
|
|
rtcpPort: (*th.ClientPorts)[1],
|
|
|
|
}
|
|
|
|
|
2020-10-05 19:07:34 +00:00
|
|
|
th := &headers.Transport{
|
2020-09-05 20:56:54 +00:00
|
|
|
Protocol: gortsplib.StreamProtocolUDP,
|
2020-11-07 21:47:10 +00:00
|
|
|
Delivery: func() *base.StreamDelivery {
|
|
|
|
v := base.StreamDeliveryUnicast
|
2020-09-05 20:56:54 +00:00
|
|
|
return &v
|
|
|
|
}(),
|
|
|
|
ClientPorts: th.ClientPorts,
|
2020-12-05 19:42:59 +00:00
|
|
|
ServerPorts: &[2]int{c.serverUDPRtp.Port(), c.serverUDPRtcp.Port()},
|
2020-08-03 15:35:34 +00:00
|
|
|
}
|
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
2020-10-05 19:07:34 +00:00
|
|
|
StatusCode: base.StatusOK,
|
|
|
|
Header: base.Header{
|
2020-09-05 20:56:54 +00:00
|
|
|
"Transport": th.Write(),
|
2020-12-05 19:42:59 +00:00
|
|
|
"Session": base.HeaderValue{sessionID},
|
2019-12-31 12:48:17 +00:00
|
|
|
},
|
2020-12-12 22:37:15 +00:00
|
|
|
}, nil
|
2020-12-05 19:42:59 +00:00
|
|
|
}
|
2019-12-31 12:48:17 +00:00
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
// play with TCP
|
2020-12-12 22:37:15 +00:00
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
if _, ok := c.protocols[gortsplib.StreamProtocolTCP]; !ok {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusUnsupportedTransport,
|
|
|
|
}, nil
|
2020-12-05 19:42:59 +00:00
|
|
|
}
|
2020-01-15 21:48:51 +00:00
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
if len(c.streamTracks) > 0 && c.streamProtocol != gortsplib.StreamProtocolTCP {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("can't receive tracks with different protocols")
|
2020-12-05 19:42:59 +00:00
|
|
|
}
|
2019-12-31 12:48:17 +00:00
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
path, err := c.parent.OnClientSetupPlay(c, basePath, trackID, req)
|
|
|
|
if err != nil {
|
|
|
|
switch terr := err.(type) {
|
|
|
|
case errAuthNotCritical:
|
2020-12-12 22:37:15 +00:00
|
|
|
return terr.Response, nil
|
2020-10-19 20:17:48 +00:00
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
case errAuthCritical:
|
2020-12-12 22:37:15 +00:00
|
|
|
return terr.Response, errTerminated
|
2020-10-19 20:17:48 +00:00
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
default:
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, err
|
2019-12-31 12:48:17 +00:00
|
|
|
}
|
2020-12-05 19:42:59 +00:00
|
|
|
}
|
2019-12-31 12:48:17 +00:00
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
c.path = path
|
|
|
|
c.state = statePrePlay
|
2020-08-03 15:35:34 +00:00
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
c.streamProtocol = gortsplib.StreamProtocolTCP
|
|
|
|
c.streamTracks[trackID] = &streamTrack{
|
|
|
|
rtpPort: 0,
|
|
|
|
rtcpPort: 0,
|
|
|
|
}
|
2020-09-05 20:56:54 +00:00
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
interleavedIds := [2]int{trackID * 2, (trackID * 2) + 1}
|
2019-12-31 12:48:17 +00:00
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
th := &headers.Transport{
|
|
|
|
Protocol: gortsplib.StreamProtocolTCP,
|
|
|
|
InterleavedIds: &interleavedIds,
|
2019-12-31 12:48:17 +00:00
|
|
|
}
|
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
2020-12-05 19:42:59 +00:00
|
|
|
StatusCode: base.StatusOK,
|
|
|
|
Header: base.Header{
|
|
|
|
"Transport": th.Write(),
|
|
|
|
"Session": base.HeaderValue{sessionID},
|
|
|
|
},
|
2020-12-12 22:37:15 +00:00
|
|
|
}, nil
|
2020-12-05 19:42:59 +00:00
|
|
|
|
2019-12-31 12:48:17 +00:00
|
|
|
// record
|
2020-10-19 20:17:48 +00:00
|
|
|
case statePreRecord:
|
2020-11-07 21:47:10 +00:00
|
|
|
if th.Mode == nil || *th.Mode != headers.TransportModeRecord {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("transport header does not contain mode=record")
|
2019-12-31 12:48:17 +00:00
|
|
|
}
|
|
|
|
|
2020-08-30 13:51:28 +00:00
|
|
|
// after ANNOUNCE, c.path is already set
|
2020-10-19 20:17:48 +00:00
|
|
|
if basePath != c.path.Name() {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("path has changed, was '%s', now is '%s'", c.path.Name(), basePath)
|
2019-12-31 13:55:46 +00:00
|
|
|
}
|
|
|
|
|
2020-09-27 13:52:48 +00:00
|
|
|
// record with UDP
|
2020-09-05 20:56:54 +00:00
|
|
|
if th.Protocol == gortsplib.StreamProtocolUDP {
|
2020-10-19 20:17:48 +00:00
|
|
|
if _, ok := c.protocols[gortsplib.StreamProtocolUDP]; !ok {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusUnsupportedTransport,
|
|
|
|
}, nil
|
2020-01-15 21:48:51 +00:00
|
|
|
}
|
|
|
|
|
2020-09-05 11:19:55 +00:00
|
|
|
if len(c.streamTracks) > 0 && c.streamProtocol != gortsplib.StreamProtocolUDP {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("can't publish tracks with different protocols")
|
2019-12-31 12:48:17 +00:00
|
|
|
}
|
|
|
|
|
2020-09-05 20:56:54 +00:00
|
|
|
if th.ClientPorts == nil {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("transport header does not have valid client ports (%s)", req.Header["Transport"])
|
2020-06-27 11:38:35 +00:00
|
|
|
}
|
2019-12-31 12:48:17 +00:00
|
|
|
|
2020-10-19 20:17:48 +00:00
|
|
|
if len(c.streamTracks) >= c.path.SourceTrackCount() {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("all the tracks have already been setup")
|
2019-12-31 12:48:17 +00:00
|
|
|
}
|
|
|
|
|
2020-09-05 11:19:55 +00:00
|
|
|
c.streamProtocol = gortsplib.StreamProtocolUDP
|
2020-12-05 19:42:59 +00:00
|
|
|
trackID := len(c.streamTracks)
|
|
|
|
c.streamTracks[trackID] = &streamTrack{
|
2020-09-05 20:56:54 +00:00
|
|
|
rtpPort: (*th.ClientPorts)[0],
|
|
|
|
rtcpPort: (*th.ClientPorts)[1],
|
|
|
|
}
|
|
|
|
|
2020-10-05 19:07:34 +00:00
|
|
|
th := &headers.Transport{
|
2020-09-05 20:56:54 +00:00
|
|
|
Protocol: gortsplib.StreamProtocolUDP,
|
2020-11-07 21:47:10 +00:00
|
|
|
Delivery: func() *base.StreamDelivery {
|
|
|
|
v := base.StreamDeliveryUnicast
|
2020-09-05 20:56:54 +00:00
|
|
|
return &v
|
|
|
|
}(),
|
|
|
|
ClientPorts: th.ClientPorts,
|
2020-12-05 19:42:59 +00:00
|
|
|
ServerPorts: &[2]int{c.serverUDPRtp.Port(), c.serverUDPRtcp.Port()},
|
2020-08-03 15:35:34 +00:00
|
|
|
}
|
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
2020-10-05 19:07:34 +00:00
|
|
|
StatusCode: base.StatusOK,
|
|
|
|
Header: base.Header{
|
2020-09-05 20:56:54 +00:00
|
|
|
"Transport": th.Write(),
|
2020-12-05 19:42:59 +00:00
|
|
|
"Session": base.HeaderValue{sessionID},
|
2019-12-31 12:48:17 +00:00
|
|
|
},
|
2020-12-12 22:37:15 +00:00
|
|
|
}, nil
|
2020-12-05 19:42:59 +00:00
|
|
|
}
|
2019-12-31 12:48:17 +00:00
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
// record with TCP
|
|
|
|
if _, ok := c.protocols[gortsplib.StreamProtocolTCP]; !ok {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusUnsupportedTransport,
|
|
|
|
}, nil
|
2020-12-05 19:42:59 +00:00
|
|
|
}
|
2019-12-31 12:48:17 +00:00
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
if len(c.streamTracks) > 0 && c.streamProtocol != gortsplib.StreamProtocolTCP {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("can't publish tracks with different protocols")
|
2020-12-05 19:42:59 +00:00
|
|
|
}
|
2020-09-05 20:56:54 +00:00
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
interleavedIds := [2]int{len(c.streamTracks) * 2, 1 + len(c.streamTracks)*2}
|
2019-12-31 12:48:17 +00:00
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
if th.InterleavedIds == nil {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("transport header does not contain the interleaved field")
|
2020-12-05 19:42:59 +00:00
|
|
|
}
|
2019-12-31 12:48:17 +00:00
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
if (*th.InterleavedIds)[0] != interleavedIds[0] || (*th.InterleavedIds)[1] != interleavedIds[1] {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("wrong interleaved ids, expected %v, got %v", interleavedIds, *th.InterleavedIds)
|
2020-12-05 19:42:59 +00:00
|
|
|
}
|
2019-12-31 12:48:17 +00:00
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
if len(c.streamTracks) >= c.path.SourceTrackCount() {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("all the tracks have already been setup")
|
2020-12-05 19:42:59 +00:00
|
|
|
}
|
2020-08-03 15:35:34 +00:00
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
c.streamProtocol = gortsplib.StreamProtocolTCP
|
|
|
|
trackID := len(c.streamTracks)
|
|
|
|
c.streamTracks[trackID] = &streamTrack{
|
|
|
|
rtpPort: 0,
|
|
|
|
rtcpPort: 0,
|
|
|
|
}
|
2020-09-05 20:56:54 +00:00
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
ht := &headers.Transport{
|
|
|
|
Protocol: gortsplib.StreamProtocolTCP,
|
|
|
|
InterleavedIds: &interleavedIds,
|
2019-12-31 12:48:17 +00:00
|
|
|
}
|
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
2020-12-05 19:42:59 +00:00
|
|
|
StatusCode: base.StatusOK,
|
|
|
|
Header: base.Header{
|
|
|
|
"Transport": ht.Write(),
|
|
|
|
"Session": base.HeaderValue{sessionID},
|
|
|
|
},
|
2020-12-12 22:37:15 +00:00
|
|
|
}, nil
|
2020-12-05 19:42:59 +00:00
|
|
|
|
2019-12-31 12:48:17 +00:00
|
|
|
default:
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("client is in state '%s'", c.state)
|
2019-12-31 12:48:17 +00:00
|
|
|
}
|
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
case base.Play:
|
2020-11-24 22:39:09 +00:00
|
|
|
// play can be sent twice, allow calling it even if we're already playing
|
2020-11-07 21:47:10 +00:00
|
|
|
err := c.checkState(map[state]struct{}{
|
|
|
|
statePrePlay: {},
|
2020-11-24 22:39:09 +00:00
|
|
|
statePlay: {},
|
2020-11-07 21:47:10 +00:00
|
|
|
})
|
|
|
|
if err != nil {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, err
|
2019-12-31 12:48:17 +00:00
|
|
|
}
|
|
|
|
|
2020-11-24 22:39:09 +00:00
|
|
|
if c.state == statePrePlay {
|
|
|
|
basePath, ok := req.URL.BasePath()
|
|
|
|
if !ok {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("unable to find base path (%s)", req.URL)
|
2020-11-24 22:39:09 +00:00
|
|
|
}
|
2020-09-05 18:53:56 +00:00
|
|
|
|
2020-11-24 22:39:09 +00:00
|
|
|
// path can end with a slash, remove it
|
|
|
|
basePath = strings.TrimSuffix(basePath, "/")
|
2020-08-03 14:56:45 +00:00
|
|
|
|
2020-11-24 22:39:09 +00:00
|
|
|
if basePath != c.path.Name() {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("path has changed, was '%s', now is '%s'", c.path.Name(), basePath)
|
2020-11-24 22:39:09 +00:00
|
|
|
}
|
2019-12-31 13:55:46 +00:00
|
|
|
|
2020-11-24 22:39:09 +00:00
|
|
|
if len(c.streamTracks) == 0 {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("no tracks have been setup")
|
2020-11-24 22:39:09 +00:00
|
|
|
}
|
2019-12-31 12:48:17 +00:00
|
|
|
}
|
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
c.startPlay()
|
|
|
|
|
|
|
|
return &base.Response{
|
2020-10-05 19:07:34 +00:00
|
|
|
StatusCode: base.StatusOK,
|
|
|
|
Header: base.Header{
|
2020-12-05 19:42:59 +00:00
|
|
|
"Session": base.HeaderValue{sessionID},
|
2019-12-31 12:48:17 +00:00
|
|
|
},
|
2020-12-12 22:37:15 +00:00
|
|
|
}, nil
|
2019-12-31 12:48:17 +00:00
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
case base.Record:
|
2020-11-07 21:47:10 +00:00
|
|
|
err := c.checkState(map[state]struct{}{
|
|
|
|
statePreRecord: {},
|
|
|
|
})
|
|
|
|
if err != nil {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, err
|
2019-12-31 12:48:17 +00:00
|
|
|
}
|
|
|
|
|
2020-11-01 18:09:47 +00:00
|
|
|
basePath, ok := req.URL.BasePath()
|
2020-10-31 14:43:08 +00:00
|
|
|
if !ok {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("unable to find base path (%s)", req.URL)
|
2020-10-31 14:43:08 +00:00
|
|
|
}
|
2020-09-05 18:53:56 +00:00
|
|
|
|
2020-08-03 14:56:45 +00:00
|
|
|
// path can end with a slash, remove it
|
2020-10-31 14:43:08 +00:00
|
|
|
basePath = strings.TrimSuffix(basePath, "/")
|
2020-08-03 14:56:45 +00:00
|
|
|
|
2020-10-31 14:43:08 +00:00
|
|
|
if basePath != c.path.Name() {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("path has changed, was '%s', now is '%s'", c.path.Name(), basePath)
|
2019-12-31 13:55:46 +00:00
|
|
|
}
|
|
|
|
|
2020-10-19 20:17:48 +00:00
|
|
|
if len(c.streamTracks) != c.path.SourceTrackCount() {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("not all tracks have been setup")
|
2019-12-31 12:48:17 +00:00
|
|
|
}
|
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
c.startRecord()
|
|
|
|
|
|
|
|
return &base.Response{
|
2020-10-05 19:07:34 +00:00
|
|
|
StatusCode: base.StatusOK,
|
|
|
|
Header: base.Header{
|
2020-12-05 19:42:59 +00:00
|
|
|
"Session": base.HeaderValue{sessionID},
|
2019-12-31 12:48:17 +00:00
|
|
|
},
|
2020-12-12 22:37:15 +00:00
|
|
|
}, nil
|
2020-01-03 22:05:06 +00:00
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
case base.Pause:
|
2020-11-07 21:47:10 +00:00
|
|
|
err := c.checkState(map[state]struct{}{
|
2020-11-11 22:10:25 +00:00
|
|
|
statePrePlay: {},
|
|
|
|
statePlay: {},
|
|
|
|
statePreRecord: {},
|
|
|
|
stateRecord: {},
|
2020-11-07 21:47:10 +00:00
|
|
|
})
|
|
|
|
if err != nil {
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, err
|
|
|
|
}
|
|
|
|
|
|
|
|
switch c.state {
|
|
|
|
case statePlay:
|
|
|
|
c.stopPlay()
|
|
|
|
c.state = statePrePlay
|
|
|
|
|
|
|
|
case stateRecord:
|
|
|
|
c.stopRecord()
|
|
|
|
c.state = statePreRecord
|
2020-11-07 21:47:10 +00:00
|
|
|
}
|
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
2020-11-07 21:47:10 +00:00
|
|
|
StatusCode: base.StatusOK,
|
|
|
|
Header: base.Header{
|
2020-12-05 19:42:59 +00:00
|
|
|
"Session": base.HeaderValue{sessionID},
|
2020-11-07 21:47:10 +00:00
|
|
|
},
|
2020-12-12 22:37:15 +00:00
|
|
|
}, nil
|
2020-07-13 09:12:20 +00:00
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
case base.Teardown:
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusOK,
|
|
|
|
}, errTerminated
|
2020-07-13 09:12:20 +00:00
|
|
|
|
|
|
|
default:
|
2020-12-12 22:37:15 +00:00
|
|
|
return &base.Response{
|
|
|
|
StatusCode: base.StatusBadRequest,
|
|
|
|
}, fmt.Errorf("unhandled method '%s'", req.Method)
|
2020-07-13 09:12:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
func (c *Client) onFrame(trackID int, streamType gortsplib.StreamType, content []byte) {
|
|
|
|
if c.state == stateRecord {
|
|
|
|
if trackID >= len(c.streamTracks) {
|
|
|
|
return
|
2020-08-31 13:31:37 +00:00
|
|
|
}
|
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
c.rtcpReceivers[trackID].ProcessFrame(time.Now(), streamType, content)
|
|
|
|
c.path.OnFrame(trackID, streamType, content)
|
2020-07-13 09:12:20 +00:00
|
|
|
}
|
2020-08-31 13:31:37 +00:00
|
|
|
}
|
2020-07-13 09:12:20 +00:00
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
func (c *Client) startPlay() {
|
2020-11-07 21:47:10 +00:00
|
|
|
if c.streamProtocol == gortsplib.StreamProtocolTCP {
|
2020-12-12 22:37:15 +00:00
|
|
|
c.writeFrameEnable = true
|
2020-11-07 21:47:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
c.state = statePlay
|
2020-10-19 20:17:48 +00:00
|
|
|
c.path.OnClientPlay(c)
|
2020-07-13 09:12:20 +00:00
|
|
|
|
2020-12-08 11:21:06 +00:00
|
|
|
c.log(logger.Info, "is reading from path '%s', %d %s with %s", c.path.Name(), len(c.streamTracks), func() string {
|
2020-07-13 09:12:20 +00:00
|
|
|
if len(c.streamTracks) == 1 {
|
|
|
|
return "track"
|
2020-07-12 10:34:35 +00:00
|
|
|
}
|
2020-07-13 09:12:20 +00:00
|
|
|
return "tracks"
|
|
|
|
}(), c.streamProtocol)
|
2020-07-12 10:34:35 +00:00
|
|
|
|
2020-10-19 20:17:48 +00:00
|
|
|
if c.path.Conf().RunOnRead != "" {
|
2020-12-12 22:37:15 +00:00
|
|
|
c.onReadCmd = externalcmd.New(c.path.Conf().RunOnRead, c.path.Conf().RunOnReadRestart, externalcmd.Environment{
|
2020-11-01 16:33:06 +00:00
|
|
|
Path: c.path.Name(),
|
|
|
|
Port: strconv.FormatInt(int64(c.rtspPort), 10),
|
|
|
|
})
|
2020-08-31 13:31:37 +00:00
|
|
|
}
|
2020-11-21 10:57:38 +00:00
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
if c.streamProtocol == gortsplib.StreamProtocolTCP {
|
|
|
|
c.writeFrameMutex.Lock()
|
|
|
|
c.writeFrameEnable = true
|
|
|
|
c.writeFrameMutex.Unlock()
|
2020-11-21 10:57:38 +00:00
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
c.conn.EnableReadFrames(true)
|
|
|
|
c.conn.EnableReadTimeout(false)
|
2020-11-21 10:57:38 +00:00
|
|
|
}
|
2020-08-31 13:31:37 +00:00
|
|
|
}
|
2020-08-29 13:21:56 +00:00
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
func (c *Client) stopPlay() {
|
|
|
|
if c.streamProtocol == gortsplib.StreamProtocolTCP {
|
|
|
|
c.conn.EnableReadFrames(false)
|
|
|
|
c.conn.EnableReadTimeout(false)
|
2020-11-07 21:47:10 +00:00
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
c.writeFrameMutex.Lock()
|
|
|
|
c.writeFrameEnable = false
|
|
|
|
c.writeFrameMutex.Unlock()
|
2020-11-21 10:57:38 +00:00
|
|
|
}
|
2020-10-19 20:17:48 +00:00
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
if c.path.Conf().RunOnRead != "" {
|
|
|
|
c.onReadCmd.Close()
|
2020-07-13 09:51:17 +00:00
|
|
|
}
|
2020-07-13 09:12:20 +00:00
|
|
|
}
|
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
func (c *Client) startRecord() {
|
2020-11-07 21:47:10 +00:00
|
|
|
c.state = stateRecord
|
2020-10-24 17:55:47 +00:00
|
|
|
c.path.OnClientRecord(c)
|
|
|
|
|
2020-12-08 11:21:06 +00:00
|
|
|
c.log(logger.Info, "is publishing to path '%s', %d %s with %s", c.path.Name(), len(c.streamTracks), func() string {
|
2020-10-24 17:55:47 +00:00
|
|
|
if len(c.streamTracks) == 1 {
|
|
|
|
return "track"
|
|
|
|
}
|
|
|
|
return "tracks"
|
|
|
|
}(), c.streamProtocol)
|
|
|
|
|
2020-09-18 20:43:39 +00:00
|
|
|
if c.streamProtocol == gortsplib.StreamProtocolUDP {
|
|
|
|
c.udpLastFrameTimes = make([]*int64, len(c.streamTracks))
|
2020-12-05 19:42:59 +00:00
|
|
|
for trackID := range c.streamTracks {
|
2020-09-18 20:43:39 +00:00
|
|
|
v := time.Now().Unix()
|
2020-12-05 19:42:59 +00:00
|
|
|
c.udpLastFrameTimes[trackID] = &v
|
2020-09-18 20:43:39 +00:00
|
|
|
}
|
2020-07-13 09:12:20 +00:00
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
for trackID, track := range c.streamTracks {
|
|
|
|
c.serverUDPRtp.AddPublisher(c.ip(), track.rtpPort, c, trackID)
|
|
|
|
c.serverUDPRtcp.AddPublisher(c.ip(), track.rtcpPort, c, trackID)
|
2020-10-19 20:17:48 +00:00
|
|
|
}
|
2020-10-24 17:55:47 +00:00
|
|
|
|
|
|
|
// open the firewall by sending packets to the counterpart
|
|
|
|
for _, track := range c.streamTracks {
|
2020-12-05 19:42:59 +00:00
|
|
|
c.serverUDPRtp.Write(
|
2020-10-24 17:55:47 +00:00
|
|
|
[]byte{0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
|
|
|
|
&net.UDPAddr{
|
|
|
|
IP: c.ip(),
|
|
|
|
Zone: c.zone(),
|
|
|
|
Port: track.rtpPort,
|
|
|
|
})
|
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
c.serverUDPRtcp.Write(
|
2020-10-24 17:55:47 +00:00
|
|
|
[]byte{0x80, 0xc9, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00},
|
|
|
|
&net.UDPAddr{
|
|
|
|
IP: c.ip(),
|
|
|
|
Zone: c.zone(),
|
|
|
|
Port: track.rtcpPort,
|
|
|
|
})
|
|
|
|
}
|
2020-10-19 20:17:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if c.path.Conf().RunOnPublish != "" {
|
2020-12-12 22:37:15 +00:00
|
|
|
c.onPublishCmd = externalcmd.New(c.path.Conf().RunOnPublish, c.path.Conf().RunOnPublishRestart, externalcmd.Environment{
|
2020-11-01 16:33:06 +00:00
|
|
|
Path: c.path.Name(),
|
|
|
|
Port: strconv.FormatInt(int64(c.rtspPort), 10),
|
|
|
|
})
|
2020-07-13 09:51:17 +00:00
|
|
|
}
|
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
c.backgroundRecordTerminate = make(chan struct{})
|
|
|
|
c.backgroundRecordDone = make(chan struct{})
|
|
|
|
|
2020-09-05 11:19:55 +00:00
|
|
|
if c.streamProtocol == gortsplib.StreamProtocolUDP {
|
2020-12-12 22:37:15 +00:00
|
|
|
go c.backgroundRecordUDP()
|
|
|
|
} else {
|
|
|
|
c.conn.EnableReadFrames(true)
|
|
|
|
c.conn.EnableReadTimeout(true)
|
|
|
|
go c.backgroundRecordTCP()
|
2020-08-31 13:31:37 +00:00
|
|
|
}
|
|
|
|
}
|
2020-07-13 09:12:20 +00:00
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
func (c *Client) stopRecord() {
|
|
|
|
close(c.backgroundRecordTerminate)
|
|
|
|
<-c.backgroundRecordDone
|
2020-11-07 21:47:10 +00:00
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
if c.streamProtocol == gortsplib.StreamProtocolUDP {
|
2020-11-21 10:57:38 +00:00
|
|
|
for _, track := range c.streamTracks {
|
2020-12-05 19:42:59 +00:00
|
|
|
c.serverUDPRtp.RemovePublisher(c.ip(), track.rtpPort, c)
|
|
|
|
c.serverUDPRtcp.RemovePublisher(c.ip(), track.rtcpPort, c)
|
2020-11-21 10:57:38 +00:00
|
|
|
}
|
2020-11-07 21:47:10 +00:00
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
} else {
|
|
|
|
c.conn.EnableReadFrames(false)
|
|
|
|
c.conn.EnableReadTimeout(false)
|
|
|
|
}
|
2020-11-07 21:47:10 +00:00
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
if c.path.Conf().RunOnPublish != "" {
|
|
|
|
c.onPublishCmd.Close()
|
2020-11-21 10:57:38 +00:00
|
|
|
}
|
2020-12-12 22:37:15 +00:00
|
|
|
}
|
2020-11-07 21:47:10 +00:00
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
func (c *Client) backgroundRecordUDP() {
|
|
|
|
defer close(c.backgroundRecordDone)
|
2020-11-21 10:57:38 +00:00
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
checkStreamTicker := time.NewTicker(checkStreamInterval)
|
|
|
|
defer checkStreamTicker.Stop()
|
2020-08-31 13:31:37 +00:00
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
receiverReportTicker := time.NewTicker(receiverReportInterval)
|
|
|
|
defer receiverReportTicker.Stop()
|
|
|
|
|
|
|
|
for {
|
|
|
|
select {
|
2020-08-31 13:31:37 +00:00
|
|
|
case <-checkStreamTicker.C:
|
2020-09-18 20:43:39 +00:00
|
|
|
now := time.Now()
|
|
|
|
|
|
|
|
for _, lastUnix := range c.udpLastFrameTimes {
|
|
|
|
last := time.Unix(atomic.LoadInt64(lastUnix), 0)
|
|
|
|
|
2020-10-19 20:17:48 +00:00
|
|
|
if now.Sub(last) >= c.readTimeout {
|
2020-12-12 22:37:15 +00:00
|
|
|
c.log(logger.Info, "ERR: no UDP packets received recently (maybe there's a firewall/NAT in between)")
|
2020-08-31 13:31:37 +00:00
|
|
|
c.conn.Close()
|
2020-12-12 22:37:15 +00:00
|
|
|
return
|
2020-07-13 09:12:20 +00:00
|
|
|
}
|
2020-08-31 13:31:37 +00:00
|
|
|
}
|
2020-07-13 09:12:20 +00:00
|
|
|
|
2020-08-31 13:31:37 +00:00
|
|
|
case <-receiverReportTicker.C:
|
2020-11-28 23:32:30 +00:00
|
|
|
now := time.Now()
|
2020-12-05 19:42:59 +00:00
|
|
|
for trackID := range c.streamTracks {
|
|
|
|
r := c.rtcpReceivers[trackID].Report(now)
|
|
|
|
c.serverUDPRtcp.Write(r, &net.UDPAddr{
|
2020-09-02 08:59:02 +00:00
|
|
|
IP: c.ip(),
|
|
|
|
Zone: c.zone(),
|
2020-12-05 19:42:59 +00:00
|
|
|
Port: c.streamTracks[trackID].rtcpPort,
|
2020-09-02 08:59:02 +00:00
|
|
|
})
|
2020-07-13 09:12:20 +00:00
|
|
|
}
|
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
case <-c.backgroundRecordTerminate:
|
|
|
|
return
|
2020-08-31 13:31:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-07-13 09:12:20 +00:00
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
func (c *Client) backgroundRecordTCP() {
|
|
|
|
defer close(c.backgroundRecordDone)
|
2020-07-13 09:12:20 +00:00
|
|
|
|
2020-10-19 20:17:48 +00:00
|
|
|
receiverReportTicker := time.NewTicker(receiverReportInterval)
|
2020-08-31 13:31:37 +00:00
|
|
|
defer receiverReportTicker.Stop()
|
2020-07-13 09:12:20 +00:00
|
|
|
|
2020-11-21 10:57:38 +00:00
|
|
|
for {
|
|
|
|
select {
|
2020-08-31 13:31:37 +00:00
|
|
|
case <-receiverReportTicker.C:
|
2020-11-28 23:32:30 +00:00
|
|
|
now := time.Now()
|
2020-12-05 19:42:59 +00:00
|
|
|
for trackID := range c.streamTracks {
|
|
|
|
r := c.rtcpReceivers[trackID].Report(now)
|
2020-12-12 22:37:15 +00:00
|
|
|
c.conn.WriteFrame(trackID, gortsplib.StreamTypeRtcp, r)
|
2020-08-31 13:31:37 +00:00
|
|
|
}
|
2020-07-13 09:51:17 +00:00
|
|
|
|
2020-12-12 22:37:15 +00:00
|
|
|
case <-c.backgroundRecordTerminate:
|
|
|
|
return
|
2020-08-31 13:31:37 +00:00
|
|
|
}
|
2020-07-13 09:51:17 +00:00
|
|
|
}
|
2019-12-31 12:48:17 +00:00
|
|
|
}
|
2020-10-19 20:17:48 +00:00
|
|
|
|
2020-12-05 19:42:59 +00:00
|
|
|
// OnUDPPublisherFrame implements serverudp.Publisher.
|
|
|
|
func (c *Client) OnUDPPublisherFrame(trackID int, streamType base.StreamType, buf []byte) {
|
2020-11-28 23:32:30 +00:00
|
|
|
now := time.Now()
|
2020-12-05 19:42:59 +00:00
|
|
|
atomic.StoreInt64(c.udpLastFrameTimes[trackID], now.Unix())
|
|
|
|
c.rtcpReceivers[trackID].ProcessFrame(now, streamType, buf)
|
|
|
|
c.path.OnFrame(trackID, streamType, buf)
|
2020-10-19 20:17:48 +00:00
|
|
|
}
|
|
|
|
|
2020-11-05 11:30:25 +00:00
|
|
|
// OnReaderFrame implements path.Reader.
|
2020-12-05 19:42:59 +00:00
|
|
|
func (c *Client) OnReaderFrame(trackID int, streamType base.StreamType, buf []byte) {
|
|
|
|
track, ok := c.streamTracks[trackID]
|
2020-10-19 20:17:48 +00:00
|
|
|
if !ok {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if c.streamProtocol == gortsplib.StreamProtocolUDP {
|
|
|
|
if streamType == gortsplib.StreamTypeRtp {
|
2020-12-05 19:42:59 +00:00
|
|
|
c.serverUDPRtp.Write(buf, &net.UDPAddr{
|
2020-10-19 20:17:48 +00:00
|
|
|
IP: c.ip(),
|
|
|
|
Zone: c.zone(),
|
|
|
|
Port: track.rtpPort,
|
|
|
|
})
|
|
|
|
|
|
|
|
} else {
|
2020-12-05 19:42:59 +00:00
|
|
|
c.serverUDPRtcp.Write(buf, &net.UDPAddr{
|
2020-10-19 20:17:48 +00:00
|
|
|
IP: c.ip(),
|
|
|
|
Zone: c.zone(),
|
|
|
|
Port: track.rtcpPort,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
2020-12-12 22:37:15 +00:00
|
|
|
c.writeFrameMutex.Lock()
|
|
|
|
if c.writeFrameEnable {
|
|
|
|
c.conn.WriteFrame(trackID, streamType, buf)
|
2020-10-19 20:17:48 +00:00
|
|
|
}
|
2020-12-12 22:37:15 +00:00
|
|
|
c.writeFrameMutex.Unlock()
|
2020-10-19 20:17:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-05 11:30:25 +00:00
|
|
|
// OnPathDescribeData is called by path.Path.
|
2020-10-27 23:29:53 +00:00
|
|
|
func (c *Client) OnPathDescribeData(sdp []byte, redirect string, err error) {
|
|
|
|
c.describeData <- describeData{sdp, redirect, err}
|
2020-10-19 20:17:48 +00:00
|
|
|
}
|