Persist credentials on source redirections (#124)

* add client opt to persist credentials on source redirections

* Remove PersistCredentialsOnRedirect flag, persist creds (if any) by default on redirects

* remove useless check

Co-authored-by: aler9 <46489434+aler9@users.noreply.github.com>

client.go

@@ -1211,15 +1211,19 @@ func (c *Client) doDescribe(u *base.URL) (Tracks, *base.URL, *base.Response, err
 			len(res.Header["Location"]) == 1 {
 			c.reset()
 
-			u, err := base.ParseURL(res.Header["Location"][0])
+			ru, err := base.ParseURL(res.Header["Location"][0])
 			if err != nil {
 				return nil, nil, nil, err
 			}
 
-			c.scheme = u.Scheme
+			if u.User != nil {
-			c.host = u.Host
+				ru.User = u.User
+			}
 
-			return c.doDescribe(u)
+			c.scheme = ru.Scheme
+			c.host = ru.Host
+
+			return c.doDescribe(ru)
 		}
 
 		return nil, nil, res, liberrors.ErrClientBadStatusCode{Code: res.StatusCode, Message: res.StatusMessage}

client_read_test.go

@@ -1573,154 +1573,200 @@ func TestClientReadDifferentInterleavedIDs(t *testing.T) {
 }
 
 func TestClientReadRedirect(t *testing.T) {
-	l, err := net.Listen("tcp", "localhost:8554")
+	for _, withCredentials := range []bool{false, true} {
-	require.NoError(t, err)
+		runName := "WithoutCredentials"
-	defer l.Close()
+		if withCredentials {
+			runName = "WithCredentials"
+		}
+		t.Run(runName, func(t *testing.T) {
+			packetRecv := make(chan struct{})
 
-	serverDone := make(chan struct{})
+			c := Client{
-	defer func() { <-serverDone }()
+				OnPacketRTP: func(ctx *ClientOnPacketRTPCtx) {
-	go func() {
+					close(packetRecv)
-		defer close(serverDone)
+				},
+			}
 
-		conn, err := l.Accept()
+			l, err := net.Listen("tcp", "localhost:8554")
-		require.NoError(t, err)
+			require.NoError(t, err)
-		br := bufio.NewReader(conn)
+			defer l.Close()
 
-		req, err := readRequest(br)
+			serverDone := make(chan struct{})
-		require.NoError(t, err)
+			defer func() { <-serverDone }()
-		require.Equal(t, base.Options, req.Method)
+			go func() {
+				defer close(serverDone)
 
-		byts, _ := base.Response{
+				conn, err := l.Accept()
-			StatusCode: base.StatusOK,
+				require.NoError(t, err)
-			Header: base.Header{
+				br := bufio.NewReader(conn)
-				"Public": base.HeaderValue{strings.Join([]string{
-					string(base.Describe),
-					string(base.Setup),
-					string(base.Play),
-				}, ", ")},
-			},
-		}.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.Describe, req.Method)
+				require.Equal(t, base.Options, req.Method)
 
-		byts, _ = base.Response{
+				byts, _ := base.Response{
-			StatusCode: base.StatusMovedPermanently,
+					StatusCode: base.StatusOK,
-			Header: base.Header{
+					Header: base.Header{
-				"Location": base.HeaderValue{"rtsp://localhost:8554/test"},
+						"Public": base.HeaderValue{strings.Join([]string{
-			},
+							string(base.Describe),
-		}.Write()
+							string(base.Setup),
-		_, err = conn.Write(byts)
+							string(base.Play),
-		require.NoError(t, err)
+						}, ", ")},
+					},
+				}.Write()
+				_, err = conn.Write(byts)
+				require.NoError(t, err)
 
-		conn.Close()
+				req, err = readRequest(br)
+				require.NoError(t, err)
+				require.Equal(t, base.Describe, req.Method)
 
-		conn, err = l.Accept()
+				byts, _ = base.Response{
-		require.NoError(t, err)
+					StatusCode: base.StatusMovedPermanently,
-		defer conn.Close()
+					Header: base.Header{
-		br = bufio.NewReader(conn)
+						"Location": base.HeaderValue{"rtsp://localhost:8554/test"},
+					},
+				}.Write()
+				_, err = conn.Write(byts)
+				require.NoError(t, err)
 
-		req, err = readRequest(br)
+				conn.Close()
-		require.NoError(t, err)
-		require.Equal(t, base.Options, req.Method)
 
-		byts, _ = base.Response{
+				conn, err = l.Accept()
-			StatusCode: base.StatusOK,
+				require.NoError(t, err)
-			Header: base.Header{
+				defer conn.Close()
-				"Public": base.HeaderValue{strings.Join([]string{
+				br = bufio.NewReader(conn)
-					string(base.Describe),
-					string(base.Setup),
-					string(base.Play),
-				}, ", ")},
-			},
-		}.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.Describe, req.Method)
+				require.Equal(t, base.Options, req.Method)
 
-		track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
+				byts, _ = base.Response{
-		require.NoError(t, err)
+					StatusCode: base.StatusOK,
+					Header: base.Header{
+						"Public": base.HeaderValue{strings.Join([]string{
+							string(base.Describe),
+							string(base.Setup),
+							string(base.Play),
+						}, ", ")},
+					},
+				}.Write()
 
-		tracks := Tracks{track}
+				_, err = conn.Write(byts)
-		tracks.setControls()
+				require.NoError(t, err)
 
-		byts, _ = base.Response{
+				req, err = readRequest(br)
-			StatusCode: base.StatusOK,
+				require.NoError(t, err)
-			Header: base.Header{
+				require.Equal(t, base.Describe, req.Method)
-				"Content-Type": base.HeaderValue{"application/sdp"},
-				"Content-Base": base.HeaderValue{"rtsp://localhost:8554/teststream/"},
-			},
-			Body: tracks.Write(false),
-		}.Write()
-		_, err = conn.Write(byts)
-		require.NoError(t, err)
 
-		req, err = readRequest(br)
+				if withCredentials {
-		require.NoError(t, err)
+					if _, exists := req.Header["Authorization"]; !exists {
-		require.Equal(t, base.Setup, req.Method)
+						authRealm := "example@localhost"
+						authNonce := "exampleNonce"
+						authOpaque := "exampleOpaque"
+						authStale := "FALSE"
+						authAlg := "MD5"
+						byts, _ = base.Response{
+							Header: base.Header{
+								"WWW-Authenticate": headers.Authenticate{
+									Method:    headers.AuthDigest,
+									Realm:     &authRealm,
+									Nonce:     &authNonce,
+									Opaque:    &authOpaque,
+									Stale:     &authStale,
+									Algorithm: &authAlg,
+								}.Write(),
+							},
+							StatusCode: base.StatusUnauthorized,
+						}.Write()
+						_, err = conn.Write(byts)
+						require.NoError(t, err)
+					}
+					req, err = readRequest(br)
+					require.NoError(t, err)
+					authHeaderVal, exists := req.Header["Authorization"]
+					require.True(t, exists)
+					var authHeader headers.Authenticate
+					require.NoError(t, authHeader.Read(authHeaderVal))
+					require.Equal(t, *authHeader.Username, "testusr")
+					require.Equal(t, base.Describe, req.Method)
+				}
 
-		var th headers.Transport
+				track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
-		err = th.Read(req.Header["Transport"])
+				require.NoError(t, err)
-		require.NoError(t, err)
 
-		byts, _ = base.Response{
+				tracks := Tracks{track}
-			StatusCode: base.StatusOK,
+				tracks.setControls()
-			Header: base.Header{
-				"Transport": headers.Transport{
-					Protocol: headers.TransportProtocolUDP,
-					Delivery: func() *headers.TransportDelivery {
-						v := headers.TransportDeliveryUnicast
-						return &v
-					}(),
-					ClientPorts: th.ClientPorts,
-					ServerPorts: &[2]int{34556, 34557},
-				}.Write(),
-			},
-		}.Write()
-		_, err = conn.Write(byts)
-		require.NoError(t, err)
 
-		req, err = readRequest(br)
+				byts, _ = base.Response{
-		require.NoError(t, err)
+					StatusCode: base.StatusOK,
-		require.Equal(t, base.Play, req.Method)
+					Header: base.Header{
+						"Content-Type": base.HeaderValue{"application/sdp"},
+						"Content-Base": base.HeaderValue{"rtsp://localhost:8554/teststream/"},
+					},
+					Body: tracks.Write(false),
+				}.Write()
+				_, err = conn.Write(byts)
+				require.NoError(t, err)
 
-		byts, _ = base.Response{
+				req, err = readRequest(br)
-			StatusCode: base.StatusOK,
+				require.NoError(t, err)
-		}.Write()
+				require.Equal(t, base.Setup, req.Method)
-		_, err = conn.Write(byts)
-		require.NoError(t, err)
 
-		time.Sleep(500 * time.Millisecond)
+				var th headers.Transport
+				err = th.Read(req.Header["Transport"])
+				require.NoError(t, err)
 
-		l1, err := net.ListenPacket("udp", "localhost:34556")
+				byts, _ = base.Response{
-		require.NoError(t, err)
+					StatusCode: base.StatusOK,
-		defer l1.Close()
+					Header: base.Header{
+						"Transport": headers.Transport{
+							Protocol: headers.TransportProtocolUDP,
+							Delivery: func() *headers.TransportDelivery {
+								v := headers.TransportDeliveryUnicast
+								return &v
+							}(),
+							ClientPorts: th.ClientPorts,
+							ServerPorts: &[2]int{34556, 34557},
+						}.Write(),
+					},
+				}.Write()
+				_, err = conn.Write(byts)
+				require.NoError(t, err)
 
-		l1.WriteTo(testRTPPacketMarshaled, &net.UDPAddr{
+				req, err = readRequest(br)
-			IP:   net.ParseIP("127.0.0.1"),
+				require.NoError(t, err)
-			Port: th.ClientPorts[0],
+				require.Equal(t, base.Play, req.Method)
+
+				byts, _ = base.Response{
+					StatusCode: base.StatusOK,
+				}.Write()
+				_, err = conn.Write(byts)
+				require.NoError(t, err)
+
+				time.Sleep(500 * time.Millisecond)
+
+				l1, err := net.ListenPacket("udp", "localhost:34556")
+				require.NoError(t, err)
+				defer l1.Close()
+
+				l1.WriteTo(testRTPPacketMarshaled, &net.UDPAddr{
+					IP:   net.ParseIP("127.0.0.1"),
+					Port: th.ClientPorts[0],
+				})
+			}()
+
+			ru := "rtsp://localhost:8554/path1"
+			if withCredentials {
+				ru = "rtsp://testusr:testpwd@localhost:8554/path1"
+			}
+			err = c.StartReading(ru)
+			require.NoError(t, err)
+			defer c.Close()
+
+			<-packetRecv
 		})
-	}()
-
-	packetRecv := make(chan struct{})
-
-	c := Client{
-		OnPacketRTP: func(ctx *ClientOnPacketRTPCtx) {
-			close(packetRecv)
-		},
 	}
-
-	err = c.StartReading("rtsp://localhost:8554/path1")
-	require.NoError(t, err)
-	defer c.Close()
-
-	<-packetRecv
 }
 
 func TestClientReadPause(t *testing.T) {