client: support cameras that provide base URL inside control attribute (https://github.com/aler9/rtsp-simple-server/issues/683)

client.go

@@ -1237,7 +1237,25 @@ func (c *Client) doDescribe(u *base.URL) (Tracks, *base.URL, *base.Response, err
 		return nil, nil, nil, liberrors.ErrClientContentTypeUnsupported{CT: ct}
 	}
 
+	tracks, sd, err := ReadTracks(res.Body, true)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
 	baseURL, err := func() (*base.URL, error) {
+		// use global control attribute
+		if control, ok := sd.Attribute("control"); ok && control != "*" {
+			ret, err := base.ParseURL(control)
+			if err != nil {
+				return nil, fmt.Errorf("invalid control attribute: '%v'", control)
+			}
+
+			// add credentials
+			ret.User = u.User
+
+			return ret, nil
+		}
+
 		// use Content-Base
 		if cb, ok := res.Header["Content-Base"]; ok {
 			if len(cb) != 1 {
@@ -1249,24 +1267,19 @@ func (c *Client) doDescribe(u *base.URL) (Tracks, *base.URL, *base.Response, err
 				return nil, fmt.Errorf("invalid Content-Base: '%v'", cb)
 			}
 
-			// add credentials from URL of request
+			// add credentials
 			ret.User = u.User
 
 			return ret, nil
 		}
 
-		// if not provided, use URL of request
+		// use URL of request
 		return u, nil
 	}()
 	if err != nil {
 		return nil, nil, nil, err
 	}
 
-	tracks, err := ReadTracks(res.Body, true)
-	if err != nil {
-		return nil, nil, nil, err
-	}
-
 	c.lastDescribeURL = u
 
 	return tracks, baseURL, res, nil

client_read_test.go

@@ -768,115 +768,140 @@ func TestClientReadPartial(t *testing.T) {
 	<-packetRecv
 }
 
-func TestClientReadNoContentBase(t *testing.T) {
+func TestClientReadContentBase(t *testing.T) {
-	l, err := net.Listen("tcp", "localhost:8554")
+	for _, ca := range []string{
-	require.NoError(t, err)
+		"absent",
-	defer l.Close()
+		"inside control attribute",
+	} {
+		t.Run(ca, func(t *testing.T) {
+			l, err := net.Listen("tcp", "localhost:8554")
+			require.NoError(t, err)
+			defer l.Close()
 
-	serverDone := make(chan struct{})
+			serverDone := make(chan struct{})
-	defer func() { <-serverDone }()
+			defer func() { <-serverDone }()
-	go func() {
+			go func() {
-		defer close(serverDone)
+				defer close(serverDone)
 
-		conn, err := l.Accept()
+				conn, err := l.Accept()
-		require.NoError(t, err)
+				require.NoError(t, err)
-		defer conn.Close()
+				defer conn.Close()
-		br := bufio.NewReader(conn)
+				br := bufio.NewReader(conn)
 
-		req, err := readRequest(br)
+				req, err := readRequest(br)
-		require.NoError(t, err)
+				require.NoError(t, err)
-		require.Equal(t, base.Options, req.Method)
+				require.Equal(t, base.Options, req.Method)
 
-		byts, _ := base.Response{
+				byts, _ := base.Response{
-			StatusCode: base.StatusOK,
+					StatusCode: base.StatusOK,
-			Header: base.Header{
+					Header: base.Header{
-				"Public": base.HeaderValue{strings.Join([]string{
+						"Public": base.HeaderValue{strings.Join([]string{
-					string(base.Describe),
+							string(base.Describe),
-					string(base.Setup),
+							string(base.Setup),
-					string(base.Play),
+							string(base.Play),
-				}, ", ")},
+						}, ", ")},
-			},
+					},
-		}.Write()
+				}.Write()
-		_, err = conn.Write(byts)
+				_, err = conn.Write(byts)
-		require.NoError(t, err)
+				require.NoError(t, err)
 
-		req, err = readRequest(br)
+				req, err = readRequest(br)
-		require.NoError(t, err)
+				require.NoError(t, err)
-		require.Equal(t, base.Describe, req.Method)
+				require.Equal(t, base.Describe, req.Method)
-		require.Equal(t, mustParseURL("rtsp://localhost:8554/teststream"), req.URL)
+				require.Equal(t, mustParseURL("rtsp://localhost:8554/teststream"), req.URL)
 
-		track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
+				track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
-		require.NoError(t, err)
+				require.NoError(t, err)
 
-		tracks := Tracks{track}
+				tracks := Tracks{track}
-		tracks.setControls()
+				tracks.setControls()
 
-		byts, _ = base.Response{
+				switch ca {
-			StatusCode: base.StatusOK,
+				case "absent":
-			Header: base.Header{
+					byts, _ = base.Response{
-				"Content-Type": base.HeaderValue{"application/sdp"},
+						StatusCode: base.StatusOK,
-			},
+						Header: base.Header{
-			Body: tracks.Write(false),
+							"Content-Type": base.HeaderValue{"application/sdp"},
-		}.Write()
+						},
-		_, err = conn.Write(byts)
+						Body: tracks.Write(false),
-		require.NoError(t, err)
+					}.Write()
+					_, err = conn.Write(byts)
+					require.NoError(t, err)
 
-		req, err = readRequest(br)
+				case "inside control attribute":
-		require.NoError(t, err)
+					body := string(tracks.Write(false))
-		require.Equal(t, base.Setup, req.Method)
+					body = strings.Replace(body, "t=0 0", "t=0 0\r\na=control:rtsp://localhost:8554/teststream", 1)
-		require.Equal(t, mustParseURL("rtsp://localhost:8554/teststream/trackID=0"), req.URL)
 
-		var inTH headers.Transport
+					byts, _ = base.Response{
-		err = inTH.Read(req.Header["Transport"])
+						StatusCode: base.StatusOK,
-		require.NoError(t, err)
+						Header: base.Header{
+							"Content-Type": base.HeaderValue{"application/sdp"},
+							"Content-Base": base.HeaderValue{"rtsp://localhost:8554/teststream2/"},
+						},
+						Body: []byte(body),
+					}.Write()
+					_, err = conn.Write(byts)
+					require.NoError(t, err)
+				}
 
-		th := headers.Transport{
+				req, err = readRequest(br)
-			Delivery: func() *headers.TransportDelivery {
+				require.NoError(t, err)
-				v := headers.TransportDeliveryUnicast
+				require.Equal(t, base.Setup, req.Method)
-				return &v
+				require.Equal(t, mustParseURL("rtsp://localhost:8554/teststream/trackID=0"), req.URL)
-			}(),
-			Protocol:    headers.TransportProtocolUDP,
-			ClientPorts: inTH.ClientPorts,
-			ServerPorts: &[2]int{34556, 34557},
-		}
 
-		byts, _ = base.Response{
+				var inTH headers.Transport
-			StatusCode: base.StatusOK,
+				err = inTH.Read(req.Header["Transport"])
-			Header: base.Header{
+				require.NoError(t, err)
-				"Transport": th.Write(),
-			},
-		}.Write()
-		_, err = conn.Write(byts)
-		require.NoError(t, err)
 
-		req, err = readRequest(br)
+				th := headers.Transport{
-		require.NoError(t, err)
+					Delivery: func() *headers.TransportDelivery {
-		require.Equal(t, base.Play, req.Method)
+						v := headers.TransportDeliveryUnicast
-		require.Equal(t, mustParseURL("rtsp://localhost:8554/teststream"), req.URL)
+						return &v
+					}(),
+					Protocol:    headers.TransportProtocolUDP,
+					ClientPorts: inTH.ClientPorts,
+					ServerPorts: &[2]int{34556, 34557},
+				}
 
-		byts, _ = base.Response{
+				byts, _ = base.Response{
-			StatusCode: base.StatusOK,
+					StatusCode: base.StatusOK,
-		}.Write()
+					Header: base.Header{
-		_, err = conn.Write(byts)
+						"Transport": th.Write(),
-		require.NoError(t, err)
+					},
+				}.Write()
+				_, err = conn.Write(byts)
+				require.NoError(t, err)
 
-		req, err = readRequest(br)
+				req, err = readRequest(br)
-		require.NoError(t, err)
+				require.NoError(t, err)
-		require.Equal(t, base.Teardown, req.Method)
+				require.Equal(t, base.Play, req.Method)
-		require.Equal(t, mustParseURL("rtsp://localhost:8554/teststream"), req.URL)
+				require.Equal(t, mustParseURL("rtsp://localhost:8554/teststream"), req.URL)
 
-		byts, _ = base.Response{
+				byts, _ = base.Response{
-			StatusCode: base.StatusOK,
+					StatusCode: base.StatusOK,
-		}.Write()
+				}.Write()
-		_, err = conn.Write(byts)
+				_, err = conn.Write(byts)
-		require.NoError(t, err)
+				require.NoError(t, err)
-	}()
 
-	c := Client{}
+				req, err = readRequest(br)
+				require.NoError(t, err)
+				require.Equal(t, base.Teardown, req.Method)
+				require.Equal(t, mustParseURL("rtsp://localhost:8554/teststream"), req.URL)
 
-	err = c.StartReading("rtsp://localhost:8554/teststream")
+				byts, _ = base.Response{
-	require.NoError(t, err)
+					StatusCode: base.StatusOK,
-	c.Close()
+				}.Write()
+				_, err = conn.Write(byts)
+				require.NoError(t, err)
+			}()
+
+			c := Client{}
+
+			err = c.StartReading("rtsp://localhost:8554/teststream")
+			require.NoError(t, err)
+			c.Close()
+		})
+	}
 }
 
 func TestClientReadAnyPort(t *testing.T) {

pkg/sdp/sdp.go

@@ -14,6 +14,11 @@ import (
 // SessionDescription is a SDP session description.
 type SessionDescription psdp.SessionDescription
 
+// Attribute returns the value of an attribute and if it exists
+func (s *SessionDescription) Attribute(key string) (string, bool) {
+	return (*psdp.SessionDescription)(s).Attribute(key)
+}
+
 // Marshal encodes a SessionDescription.
 func (s *SessionDescription) Marshal() ([]byte, error) {
 	return (*psdp.SessionDescription)(s).Marshal()

serversession.go

@@ -503,7 +503,7 @@ func (ss *ServerSession) handleRequest(sc *ServerConn, req *base.Request) (*base
 			}, liberrors.ErrServerContentTypeUnsupported{CT: ct}
 		}
 
-		tracks, err := ReadTracks(req.Body, false)
+		tracks, _, err := ReadTracks(req.Body, false)
 		if err != nil {
 			return &base.Response{
 				StatusCode: base.StatusBadRequest,

track_test.go

@@ -760,7 +760,7 @@ func TestTrackURL(t *testing.T) {
 		},
 	} {
 		t.Run(ca.name, func(t *testing.T) {
-			tracks, err := ReadTracks(ca.sdp, false)
+			tracks, _, err := ReadTracks(ca.sdp, false)
 			require.NoError(t, err)
 			ur, err := tracks[0].url(ca.baseURL)
 			require.NoError(t, err)

tracks.go

@@ -14,11 +14,12 @@ import (
 type Tracks []Track
 
 // ReadTracks decodes tracks from the SDP format.
-func ReadTracks(byts []byte, skipGenericTracksWithoutClockRate bool) (Tracks, error) {
+// It returns the tracks and the decoded SDP.
+func ReadTracks(byts []byte, skipGenericTracksWithoutClockRate bool) (Tracks, *sdp.SessionDescription, error) {
 	var sd sdp.SessionDescription
 	err := sd.Unmarshal(byts)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	var tracks Tracks //nolint:prealloc
@@ -30,17 +31,17 @@ func ReadTracks(byts []byte, skipGenericTracksWithoutClockRate bool) (Tracks, er
 				strings.HasPrefix(err.Error(), "unable to get clock rate") {
 				continue
 			}
-			return nil, fmt.Errorf("unable to parse track %d: %s", i+1, err)
+			return nil, nil, fmt.Errorf("unable to parse track %d: %s", i+1, err)
 		}
 
 		tracks = append(tracks, t)
 	}
 
 	if len(tracks) == 0 {
-		return nil, fmt.Errorf("no valid tracks found")
+		return nil, nil, fmt.Errorf("no valid tracks found")
 	}
 
-	return tracks, nil
+	return tracks, &sd, nil
 }
 
 func (ts Tracks) clone() Tracks {

tracks_test.go

@@ -35,7 +35,7 @@ func TestTracksReadErrors(t *testing.T) {
 		},
 	} {
 		t.Run(ca.name, func(t *testing.T) {
-			_, err := ReadTracks(ca.sdp, false)
+			_, _, err := ReadTracks(ca.sdp, false)
 			require.EqualError(t, err, ca.err)
 		})
 	}
@@ -67,7 +67,7 @@ func TestTracksReadSkipGenericTracksWithoutClockRate(t *testing.T) {
 		"m=application 42508 RTP/AVP 107\r\n" +
 		"b=AS:8\r\n")
 
-	tracks, err := ReadTracks(sdp, true)
+	tracks, _, err := ReadTracks(sdp, true)
 	require.NoError(t, err)
 	require.Equal(t, Tracks{
 		&TrackH264{