package/gortsplib
1
0
Fork 0
mirror of https://github.com/aler9/gortsplib synced 2025-10-05 07:06:58 +08:00
Code Issues Packages Projects Releases Wiki Activity

server: add SETUP path tests

Browse Source
This commit is contained in:
aler9
2021-03-14 15:24:44 +01:00
parent 99ef9a9cc0
commit 0706798d48
3 changed files with 242 additions and 8 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
serverconn.go
View File

@@ -435,20 +435,20 @@ func (sc *ServerConn) handleRequest(req *base.Request) (*base.Response, error) {
if err != nil {
return &base.Response{
StatusCode: base.StatusBadRequest,
}, fmt.Errorf("invalid track URL")
}, fmt.Errorf("unable to generate track URL")
}
trackPath, ok := trackURL.RTSPPath()
if !ok {
return &base.Response{
StatusCode: base.StatusBadRequest,
}, fmt.Errorf("invalid track URL")
}, fmt.Errorf("invalid track URL (%v)", trackURL)
}
if !strings.HasPrefix(trackPath, reqPath) {
return &base.Response{
StatusCode: base.StatusBadRequest,
}, fmt.Errorf("invalid track URL: must begin with '%s', but is '%s'",
}, fmt.Errorf("invalid track path: must begin with '%s', but is '%s'",
reqPath, trackPath)
}
}
@@ -528,7 +528,7 @@ func (sc *ServerConn) handleRequest(req *base.Request) (*base.Response, error) {
if th.Mode == nil || *th.Mode == headers.TransportModePlay {
trackID, _, ok := base.PathSplitControlAttribute(pathAndQuery)
if !ok {
return 0, fmt.Errorf("invalid track (%s)", pathAndQuery)
return 0, fmt.Errorf("invalid track path (%s)", pathAndQuery)
}
return trackID, nil
@@ -541,7 +541,7 @@ func (sc *ServerConn) handleRequest(req *base.Request) (*base.Response, error) {
}
}
return 0, fmt.Errorf("invalid track (%s)", pathAndQuery)
return 0, fmt.Errorf("invalid track path (%s)", pathAndQuery)
}()
if err != nil {
return &base.Response{

155
serverconnpublish_test.go
View File

@@ -16,6 +16,153 @@ import (
"github.com/aler9/gortsplib/pkg/headers"
)
func TestServerConnPublishSetupPath(t *testing.T) {
for _, ca := range []struct {
name string
control string
url string
trackID int
}{
{
"normal",
"trackID=0",
"rtsp://localhost:8554/teststream/trackID=0",
0,
},
{
"unordered id",
"trackID=2",
"rtsp://localhost:8554/teststream/trackID=2",
0,
},
{
"custom param name",
"testing=0",
"rtsp://localhost:8554/teststream/testing=0",
0,
},
{
"query",
"?testing=0",
"rtsp://localhost:8554/teststream?testing=0",
0,
},
} {
t.Run(ca.name, func(t *testing.T) {
setupDone := make(chan int)
s, err := Serve("127.0.0.1:8554")
require.NoError(t, err)
defer s.Close()
serverDone := make(chan struct{})
defer func() { <-serverDone }()
go func() {
defer close(serverDone)
conn, err := s.Accept()
require.NoError(t, err)
defer conn.Close()
onAnnounce := func(req *base.Request, tracks Tracks) (*base.Response, error) {
return &base.Response{
StatusCode: base.StatusOK,
}, nil
}
onSetup := func(req *base.Request, th *headers.Transport, trackID int) (*base.Response, error) {
setupDone <- trackID
return &base.Response{
StatusCode: base.StatusOK,
}, nil
}
err = <-conn.Read(ServerConnReadHandlers{
OnAnnounce: onAnnounce,
OnSetup: onSetup,
})
require.Equal(t, io.EOF, err)
}()
conn, err := net.Dial("tcp", "localhost:8554")
require.NoError(t, err)
defer conn.Close()
bconn := bufio.NewReadWriter(bufio.NewReader(conn), bufio.NewWriter(conn))
track, err := NewTrackH264(96, []byte("123456"), []byte("123456"))
require.NoError(t, err)
track.Media.Attributes = append(track.Media.Attributes, psdp.Attribute{
Key: "control",
Value: ca.control,
})
sout := &psdp.SessionDescription{
SessionName: psdp.SessionName("Stream"),
Origin: psdp.Origin{
Username: "-",
NetworkType: "IN",
AddressType: "IP4",
UnicastAddress: "127.0.0.1",
},
TimeDescriptions: []psdp.TimeDescription{
{Timing: psdp.Timing{0, 0}}, //nolint:govet
},
MediaDescriptions: []*psdp.MediaDescription{
track.Media,
},
}
byts, _ := sout.Marshal()
err = base.Request{
Method: base.Announce,
URL: base.MustParseURL("rtsp://localhost:8554/teststream"),
Header: base.Header{
"CSeq": base.HeaderValue{"1"},
"Content-Type": base.HeaderValue{"application/sdp"},
},
Body: byts,
}.Write(bconn.Writer)
require.NoError(t, err)
var res base.Response
err = res.Read(bconn.Reader)
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
th := &headers.Transport{
Protocol: StreamProtocolTCP,
Delivery: func() *base.StreamDelivery {
v := base.StreamDeliveryUnicast
return &v
}(),
Mode: func() *headers.TransportMode {
v := headers.TransportModeRecord
return &v
}(),
InterleavedIds: &[2]int{0, 1},
}
err = base.Request{
Method: base.Setup,
URL: base.MustParseURL(ca.url),
Header: base.Header{
"CSeq": base.HeaderValue{"2"},
"Transport": th.Write(),
},
}.Write(bconn.Writer)
require.NoError(t, err)
trackID := <-setupDone
require.Equal(t, ca.trackID, trackID)
err = res.Read(bconn.Reader)
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
})
}
}
func TestServerConnPublishReceivePackets(t *testing.T) {
for _, proto := range []string{
"udp",
@@ -24,9 +171,11 @@ func TestServerConnPublishReceivePackets(t *testing.T) {
t.Run(proto, func(t *testing.T) {
packetsReceived := make(chan struct{})
conf := ServerConf{
UDPRTPAddress: "127.0.0.1:8000",
UDPRTCPAddress: "127.0.0.1:8001",
conf := ServerConf{}
if proto == "udp" {
conf.UDPRTPAddress = "127.0.0.1:8000"
conf.UDPRTCPAddress = "127.0.0.1:8001"
}
s, err := conf.Serve("127.0.0.1:8554")

85
serverconnread_test.go
View File

@@ -13,6 +13,91 @@ import (
"github.com/aler9/gortsplib/pkg/headers"
)
func TestServerConnReadSetupPath(t *testing.T) {
for _, ca := range []struct {
name string
url string
trackID int
}{
{
"normal",
"rtsp://localhost:8554/teststream/trackID=0",
0,
},
{
"unordered id",
"rtsp://localhost:8554/teststream/trackID=2",
2,
},
} {
t.Run(ca.name, func(t *testing.T) {
setupDone := make(chan int)
s, err := Serve("127.0.0.1:8554")
require.NoError(t, err)
defer s.Close()
serverDone := make(chan struct{})
defer func() { <-serverDone }()
go func() {
defer close(serverDone)
conn, err := s.Accept()
require.NoError(t, err)
defer conn.Close()
onSetup := func(req *base.Request, th *headers.Transport, trackID int) (*base.Response, error) {
setupDone <- trackID
return &base.Response{
StatusCode: base.StatusOK,
}, nil
}
err = <-conn.Read(ServerConnReadHandlers{
OnSetup: onSetup,
})
require.Equal(t, io.EOF, err)
}()
conn, err := net.Dial("tcp", "localhost:8554")
require.NoError(t, err)
defer conn.Close()
bconn := bufio.NewReadWriter(bufio.NewReader(conn), bufio.NewWriter(conn))
th := &headers.Transport{
Protocol: StreamProtocolTCP,
Delivery: func() *base.StreamDelivery {
v := base.StreamDeliveryUnicast
return &v
}(),
Mode: func() *headers.TransportMode {
v := headers.TransportModePlay
return &v
}(),
InterleavedIds: &[2]int{ca.trackID * 2, (ca.trackID * 2) + 1},
}
err = base.Request{
Method: base.Setup,
URL: base.MustParseURL(ca.url),
Header: base.Header{
"CSeq": base.HeaderValue{"1"},
"Transport": th.Write(),
},
}.Write(bconn.Writer)
require.NoError(t, err)
trackID := <-setupDone
require.Equal(t, ca.trackID, trackID)
var res base.Response
err = res.Read(bconn.Reader)
require.NoError(t, err)
require.Equal(t, base.StatusOK, res.StatusCode)
})
}
}
func TestServerConnReadReceivePackets(t *testing.T) {
for _, proto := range []string{
"udp",