res_rtp_asterisk.c: Disable packet flood detection for video streams.

We should not do flood detection on video RTP streams.  Video RTP streams
are very bursty by nature.  They send out a burst of packets to update the
video frame then wait for the next video frame update.  Really only audio
streams can be checked for flooding.  The others are either bursty or
don't have a set rate.

* Added code to selectively disable packet flood detection for video RTP
streams.

ASTERISK-27440

Change-Id: I78031491a6e75c2d4b1e9c2462dc498fe9880a70

diff --git a/configs/samples/rtp.conf.sample b/configs/samples/rtp.conf.sample
index 9bc3de3cf8ad6218ed8d36b5d820655f04f01983..de9d59007c7e219c596c0fbb39ecca20f64475ed 100644 (file)
--- a/configs/samples/rtp.conf.sample
+++ b/configs/samples/rtp.conf.sample
@@ -21,9 +21,17 @@ rtpend=20000
 ; rtcpinterval = 5000  ; Milliseconds between rtcp reports
                        ;(min 500, max 60000, default 5000)
 ;
-; Enable strict RTP protection. This will drop RTP packets that
-; do not come from the source of the RTP stream. This option is
-; enabled by default.
+; Enable strict RTP protection.  This will drop RTP packets that do not come
+; from the recoginized source of the RTP stream.  Strict RTP qualifies RTP
+; packet stream sources before accepting them upon initial connection and
+; when the connection is renegotiated (e.g., transfers and direct media).
+; Initial connection and renegotiation starts a learning mode to qualify
+; stream source addresses.  Once Asterisk has recognized a stream it will
+; allow other streams to qualify and replace the current stream for 5
+; seconds after starting learning mode.  Once learning mode completes the
+; current stream is locked in and cannot change until the next
+; renegotiation.
+; This option is enabled by default.
 ; strictrtp=yes
 ;
 ; Number of packets containing consecutive sequence values needed

diff --git a/include/asterisk/rtp_engine.h b/include/asterisk/rtp_engine.h
index 0b29f3485719503d8d6f2493d652f3341148e633..7daff6738a3d5d343bb391e6836e7abe8a4e9088 100644 (file)
--- a/include/asterisk/rtp_engine.h
+++ b/include/asterisk/rtp_engine.h
@@ -1347,6 +1347,16 @@ int ast_rtp_codecs_payloads_set_rtpmap_type_rate(struct ast_rtp_codecs *codecs,
  */
 void ast_rtp_codecs_payloads_unset(struct ast_rtp_codecs *codecs, struct ast_rtp_instance *instance, int payload);
 
+/*!
+ * \brief Determine the type of RTP stream media from the codecs mapped.
+ * \since 13.19.0
+ *
+ * \param codecs Codecs structure to look in
+ *
+ * \return Media type or AST_MEDIA_TYPE_UNKNOWN if no codecs mapped.
+ */
+enum ast_media_type ast_rtp_codecs_get_stream_type(struct ast_rtp_codecs *codecs);
+
 /*!
  * \brief Retrieve payload information by payload
  *

diff --git a/main/rtp_engine.c b/main/rtp_engine.c
index e7032724b1e8a4ebf5124f22834f34c0057c6337..b12761bc4c2da093439a16a4873d243017560cf6 100644 (file)
--- a/main/rtp_engine.c
+++ b/main/rtp_engine.c
@@ -887,6 +887,25 @@ void ast_rtp_codecs_payloads_unset(struct ast_rtp_codecs *codecs, struct ast_rtp
        ast_rwlock_unlock(&codecs->codecs_lock);
 }
 
+enum ast_media_type ast_rtp_codecs_get_stream_type(struct ast_rtp_codecs *codecs)
+{
+       enum ast_media_type stream_type = AST_MEDIA_TYPE_UNKNOWN;
+       int payload;
+       struct ast_rtp_payload_type *type;
+
+       ast_rwlock_rdlock(&codecs->codecs_lock);
+       for (payload = 0; payload < AST_VECTOR_SIZE(&codecs->payloads); ++payload) {
+               type = AST_VECTOR_GET(&codecs->payloads, payload);
+               if (type && type->asterisk_format) {
+                       stream_type = ast_format_get_type(type->format);
+                       break;
+               }
+       }
+       ast_rwlock_unlock(&codecs->codecs_lock);
+
+       return stream_type;
+}
+
 struct ast_rtp_payload_type *ast_rtp_codecs_get_payload(struct ast_rtp_codecs *codecs, int payload)
 {
        struct ast_rtp_payload_type *type = NULL;

diff --git a/res/res_rtp_asterisk.c b/res/res_rtp_asterisk.c
index cf793a663ff0a40b40926fab7d183054f6366498..230d147be3f32e2dd46cbb1ee4993453cc14af3f 100644 (file)
--- a/res/res_rtp_asterisk.c
+++ b/res/res_rtp_asterisk.c
@@ -255,6 +255,8 @@ struct rtp_learning_info {
        struct timeval received; /*!< The time of the first received packet */
        int max_seq;    /*!< The highest sequence number received */
        int packets;    /*!< The number of remaining packets before the source is accepted */
+       /*! Type of media stream carried by the RTP instance */
+       enum ast_media_type stream_type;
 };
 
 #ifdef HAVE_OPENSSL_SRTP
@@ -2812,18 +2814,29 @@ static int rtp_learning_rtp_seq_update(struct rtp_learning_info *info, uint16_t
                info->received = ast_tvnow();
        }
 
-       /*
-        * Protect against packet floods by checking that we
-        * received the packet sequence in at least the minimum
-        * allowed time.
-        */
-       if (ast_tvzero(info->received)) {
-               info->received = ast_tvnow();
-       } else if (!info->packets && (ast_tvdiff_ms(ast_tvnow(), info->received) < learning_min_duration )) {
-               /* Packet flood; reset */
-               info->packets = learning_min_sequential - 1;
-               info->received = ast_tvnow();
+       switch (info->stream_type) {
+       case AST_MEDIA_TYPE_UNKNOWN:
+       case AST_MEDIA_TYPE_AUDIO:
+               /*
+                * Protect against packet floods by checking that we
+                * received the packet sequence in at least the minimum
+                * allowed time.
+                */
+               if (ast_tvzero(info->received)) {
+                       info->received = ast_tvnow();
+               } else if (!info->packets
+                       && ast_tvdiff_ms(ast_tvnow(), info->received) < learning_min_duration) {
+                       /* Packet flood; reset */
+                       info->packets = learning_min_sequential - 1;
+                       info->received = ast_tvnow();
+               }
+               break;
+       case AST_MEDIA_TYPE_VIDEO:
+       case AST_MEDIA_TYPE_IMAGE:
+       case AST_MEDIA_TYPE_TEXT:
+               break;
        }
+
        info->max_seq = seq;
 
        return info->packets;
@@ -5430,6 +5443,15 @@ static struct ast_frame *ast_rtp_read(struct ast_rtp_instance *instance, int rtc
                         * source and we should switch to it.
                         */
                        if (!ast_sockaddr_cmp(&rtp->rtp_source_learn.proposed_address, &addr)) {
+                               if (rtp->rtp_source_learn.stream_type == AST_MEDIA_TYPE_UNKNOWN) {
+                                       struct ast_rtp_codecs *codecs;
+
+                                       codecs = ast_rtp_instance_get_codecs(instance);
+                                       rtp->rtp_source_learn.stream_type =
+                                               ast_rtp_codecs_get_stream_type(codecs);
+                                       ast_verb(4, "%p -- Strict RTP qualifying stream type: %s\n",
+                                               rtp, ast_codec_media_type2str(rtp->rtp_source_learn.stream_type));
+                               }
                                if (!rtp_learning_rtp_seq_update(&rtp->rtp_source_learn, seqno)) {
                                        /* Accept the new RTP stream */
                                        ast_verb(4, "%p -- Strict RTP switching source address to %s\n",