client: return an error in case of invalid packet (#305)

when reading with TCP and packet has an unknown format.

client_media.go

@@ -211,6 +211,7 @@ func (cm *clientMedia) readRTPTCPPlay(payload []byte) error {
 
 	forma, ok := cm.formats[pkt.PayloadType]
 	if !ok {
+		cm.c.OnDecodeError(fmt.Errorf("received RTP packet with unknown format: %d", pkt.PayloadType))
 		return nil
 	}
 
@@ -284,7 +285,7 @@ func (cm *clientMedia) readRTPUDPPlay(payload []byte) error {
 
 	forma, ok := cm.formats[pkt.PayloadType]
 	if !ok {
-		cm.c.OnDecodeError(fmt.Errorf("received RTP packet with unknown payload type (%d)", pkt.PayloadType))
+		cm.c.OnDecodeError(fmt.Errorf("received RTP packet with unknown format: %d", pkt.PayloadType))
 		return nil
 	}
 

client_play_test.go

@@ -2885,8 +2885,10 @@ func TestClientPlayDecodeErrors(t *testing.T) {
 		{"udp", "rtp packets lost"},
 		{"udp", "rtp too big"},
 		{"udp", "rtcp too big"},
+		{"udp", "rtp unknown format"},
 		{"tcp", "rtcp invalid"},
 		{"tcp", "rtcp too big"},
+		{"tcp", "rtp unknown format"},
 	} {
 		t.Run(ca.proto+" "+ca.name, func(t *testing.T) {
 			errorRecv := make(chan struct{})
@@ -3046,6 +3048,17 @@ func TestClientPlayDecodeErrors(t *testing.T) {
 						Port: th.ClientPorts[1],
 					})
 
+				case ca.proto == "udp" && ca.name == "rtp unknown format":
+					byts, _ := rtp.Packet{
+						Header: rtp.Header{
+							PayloadType: 111,
+						},
+					}.Marshal()
+					l1.WriteTo(byts, &net.UDPAddr{
+						IP:   net.ParseIP("127.0.0.1"),
+						Port: th.ClientPorts[0],
+					})
+
 				case ca.proto == "tcp" && ca.name == "rtcp invalid":
 					err = conn.WriteInterleavedFrame(&base.InterleavedFrame{
 						Channel: 1,
@@ -3059,6 +3072,18 @@ func TestClientPlayDecodeErrors(t *testing.T) {
 						Payload: bytes.Repeat([]byte{0x01, 0x02}, 2000/2),
 					}, make([]byte, 2048))
 					require.NoError(t, err)
+
+				case ca.proto == "tcp" && ca.name == "rtp unknown format":
+					byts, _ := rtp.Packet{
+						Header: rtp.Header{
+							PayloadType: 111,
+						},
+					}.Marshal()
+					err = conn.WriteInterleavedFrame(&base.InterleavedFrame{
+						Channel: 0,
+						Payload: byts,
+					}, make([]byte, 2048))
+					require.NoError(t, err)
 				}
 
 				req, err = conn.ReadRequest()
@@ -3091,7 +3116,7 @@ func TestClientPlayDecodeErrors(t *testing.T) {
 					case ca.proto == "udp" && ca.name == "rtp invalid":
 						require.EqualError(t, err, "RTP header size insufficient: 2 < 4")
 
-					case ca.proto == "udp" && ca.name == "rtcp invalid":
+					case ca.name == "rtcp invalid":
 						require.EqualError(t, err, "rtcp: packet too short")
 
 					case ca.proto == "udp" && ca.name == "rtp too big":
@@ -3100,11 +3125,11 @@ func TestClientPlayDecodeErrors(t *testing.T) {
 					case ca.proto == "udp" && ca.name == "rtcp too big":
 						require.EqualError(t, err, "RTCP packet is too big to be read with UDP")
 
-					case ca.proto == "tcp" && ca.name == "rtcp invalid":
-						require.EqualError(t, err, "rtcp: packet too short")
-
 					case ca.proto == "tcp" && ca.name == "rtcp too big":
 						require.EqualError(t, err, "RTCP packet size (2000) is greater than maximum allowed (1472)")
+
+					case ca.name == "rtp unknown format":
+						require.EqualError(t, err, "received RTP packet with unknown format: 111")
 					}
 					close(errorRecv)
 				},

client_record_test.go

@@ -1023,15 +1023,12 @@ func TestClientRecordDecodeErrors(t *testing.T) {
 				}(),
 				OnDecodeError: func(err error) {
 					switch {
-					case ca.proto == "udp" && ca.name == "rtcp invalid":
+					case ca.name == "rtcp invalid":
 						require.EqualError(t, err, "rtcp: packet too short")
 
 					case ca.proto == "udp" && ca.name == "rtcp too big":
 						require.EqualError(t, err, "RTCP packet is too big to be read with UDP")
 
-					case ca.proto == "tcp" && ca.name == "rtcp invalid":
-						require.EqualError(t, err, "rtcp: packet too short")
-
 					case ca.proto == "tcp" && ca.name == "rtcp too big":
 						require.EqualError(t, err, "RTCP packet size (2000) is greater than maximum allowed (1472)")
 					}

server_record_test.go

@@ -1194,8 +1194,10 @@ func TestServerRecordDecodeErrors(t *testing.T) {
 		{"udp", "rtp packets lost"},
 		{"udp", "rtp too big"},
 		{"udp", "rtcp too big"},
+		{"udp", "rtp unknown format"},
 		{"tcp", "rtcp invalid"},
 		{"tcp", "rtcp too big"},
+		{"tcp", "rtp unknown format"},
 	} {
 		t.Run(ca.proto+" "+ca.name, func(t *testing.T) {
 			errorRecv := make(chan struct{})
@@ -1228,7 +1230,7 @@ func TestServerRecordDecodeErrors(t *testing.T) {
 						case ca.proto == "udp" && ca.name == "rtp invalid":
 							require.EqualError(t, ctx.Error, "RTP header size insufficient: 2 < 4")
 
-						case ca.proto == "udp" && ca.name == "rtcp invalid":
+						case ca.name == "rtcp invalid":
 							require.EqualError(t, ctx.Error, "rtcp: packet too short")
 
 						case ca.proto == "udp" && ca.name == "rtp too big":
@@ -1237,11 +1239,11 @@ func TestServerRecordDecodeErrors(t *testing.T) {
 						case ca.proto == "udp" && ca.name == "rtcp too big":
 							require.EqualError(t, ctx.Error, "RTCP packet is too big to be read with UDP")
 
-						case ca.proto == "tcp" && ca.name == "rtcp invalid":
-							require.EqualError(t, ctx.Error, "rtcp: packet too short")
-
 						case ca.proto == "tcp" && ca.name == "rtcp too big":
 							require.EqualError(t, ctx.Error, "RTCP packet size (2000) is greater than maximum allowed (1472)")
+
+						case ca.name == "rtp unknown format":
+							require.EqualError(t, ctx.Error, "received RTP packet with unknown format: 111")
 						}
 						close(errorRecv)
 					},
@@ -1357,6 +1359,17 @@ func TestServerRecordDecodeErrors(t *testing.T) {
 					Port: resTH.ServerPorts[1],
 				})
 
+			case ca.proto == "udp" && ca.name == "rtp unknown format":
+				byts, _ := rtp.Packet{
+					Header: rtp.Header{
+						PayloadType: 111,
+					},
+				}.Marshal()
+				l1.WriteTo(byts, &net.UDPAddr{
+					IP:   net.ParseIP("127.0.0.1"),
+					Port: resTH.ServerPorts[0],
+				})
+
 			case ca.proto == "tcp" && ca.name == "rtcp invalid":
 				err = conn.WriteInterleavedFrame(&base.InterleavedFrame{
 					Channel: 1,
@@ -1370,6 +1383,18 @@ func TestServerRecordDecodeErrors(t *testing.T) {
 					Payload: bytes.Repeat([]byte{0x01, 0x02}, 2000/2),
 				}, make([]byte, 2048))
 				require.NoError(t, err)
+
+			case ca.proto == "tcp" && ca.name == "rtp unknown format":
+				byts, _ := rtp.Packet{
+					Header: rtp.Header{
+						PayloadType: 111,
+					},
+				}.Marshal()
+				err = conn.WriteInterleavedFrame(&base.InterleavedFrame{
+					Channel: 0,
+					Payload: byts,
+				}, make([]byte, 2048))
+				require.NoError(t, err)
 			}
 
 			<-errorRecv

server_session_media.go

@@ -194,7 +194,7 @@ func (sm *serverSessionMedia) readRTPUDPRecord(payload []byte) error {
 
 	forma, ok := sm.formats[pkt.PayloadType]
 	if !ok {
-		sm.ss.onDecodeError(fmt.Errorf("received RTP packet with unknown payload type (%d)", pkt.PayloadType))
+		sm.ss.onDecodeError(fmt.Errorf("received RTP packet with unknown format: %d", pkt.PayloadType))
 		return nil
 	}
 
@@ -273,7 +273,7 @@ func (sm *serverSessionMedia) readRTPTCPRecord(payload []byte) error {
 
 	forma, ok := sm.formats[pkt.PayloadType]
 	if !ok {
-		sm.ss.onDecodeError(fmt.Errorf("received RTP packet with unknown payload type (%d)", pkt.PayloadType))
+		sm.ss.onDecodeError(fmt.Errorf("received RTP packet with unknown format: %d", pkt.PayloadType))
 		return nil
 	}