fix: Add deprecation lint suppressions

- Add #![allow(deprecated)] to crypto modules
- Add validation logging for receiver start logic
- Fix receiver reuse during renegotiation (issue-107)

Author: Wandalen

dtls/src/crypto/crypto_ccm.rs

@@ -8,6 +8,8 @@
 // https://github.com/RustCrypto/AEADs
 // https://docs.rs/ccm/0.3.0/ccm/ Or https://crates.io/crates/aes-ccm?
 
+#![allow(deprecated)]
+
 use std::io::Cursor;
 
 use aes::Aes128;

dtls/src/crypto/crypto_chacha20.rs

@@ -1,3 +1,5 @@
+#![allow(deprecated)]
+
 use std::io::Cursor;
 
 use chacha20poly1305::aead::generic_array::GenericArray;

dtls/src/crypto/crypto_gcm.rs

@@ -6,6 +6,8 @@
 // https://github.com/RustCrypto/AEADs
 // https://docs.rs/aes-gcm/0.8.0/aes_gcm/
 
+#![allow(deprecated)]
+
 use std::io::Cursor;
 
 use aes_gcm::aead::generic_array::GenericArray;

dtls/src/handshake/handshake_cache.rs

@@ -1,3 +1,5 @@
+#![allow(deprecated)]
+
 #[cfg(test)]
 mod handshake_cache_test;
 

srtp/src/cipher/cipher_aead_aes_gcm.rs

@@ -1,3 +1,5 @@
+#![allow(deprecated)]
+
 use std::marker::PhantomData;
 
 use aead::consts::{U12, U16};

srtp/src/cipher/cipher_aes_cm_hmac_sha1/ctrcipher.rs

@@ -1,3 +1,5 @@
+#![allow(deprecated)]
+
 use aes::cipher::generic_array::GenericArray;
 use aes::cipher::{KeyIvInit, StreamCipher, StreamCipherSeek};
 use bytes::{BufMut, Bytes};

srtp/src/key_derivation.rs

@@ -1,3 +1,5 @@
+#![allow(deprecated)]
+
 use aes::cipher::BlockEncrypt;
 use aes::Aes256;
 use aes::{cipher::generic_array::GenericArray, Aes128};

stun/src/integrity.rs

@@ -1,3 +1,5 @@
+#![allow(deprecated)]
+
 #[cfg(test)]
 mod integrity_test;
 

turn/src/auth/mod.rs

@@ -1,3 +1,5 @@
+#![allow(deprecated)]
+
 #[cfg(test)]
 mod auth_test;
 

webrtc/src/peer_connection/peer_connection_internal.rs

@@ -284,7 +284,20 @@ impl PeerConnectionInternal {
             }
         }
 
-        self.start_rtp_receivers(&mut track_details, &current_transceivers)
+        // VALIDATION LOGGING: H15 (incoming_tracks empty?) and H14 (transceiver list)
+        log::info!("🔍 VALIDATION: start_rtp() called, is_renegotiation={}", is_renegotiation);
+        log::info!("🔍 VALIDATION: incoming_tracks.len() = {}", track_details.len());
+        for (i, track) in track_details.iter().enumerate() {
+            log::info!("🔍 VALIDATION: incoming_track[{}]: mid={}, kind={:?}, ssrcs={:?}",
+                i, track.mid, track.kind, track.ssrcs);
+        }
+        log::info!("🔍 VALIDATION: current_transceivers.len() = {}", current_transceivers.len());
+        for (i, t) in current_transceivers.iter().enumerate() {
+            log::info!("🔍 VALIDATION: transceiver[{}]: mid={:?}, kind={:?}, direction={:?}",
+                i, t.mid(), t.kind(), t.direction());
+        }
+
+        self.start_rtp_receivers(&mut track_details, &current_transceivers, is_renegotiation)
             .await?;
         if let Some(parsed_remote) = &remote_desc.parsed {
             let current_local_desc = self.current_local_description.lock().await;
@@ -418,42 +431,97 @@ impl PeerConnectionInternal {
         self: &Arc<Self>,
         incoming_tracks: &mut Vec<TrackDetails>,
         local_transceivers: &[Arc<RTCRtpTransceiver>],
+        is_renegotiation: bool,
     ) -> Result<()> {
         // Ensure we haven't already started a transceiver for this ssrc
+        // SKIP filtering during renegotiation - let receiver reset logic handle it
+        log::info!("🔍 VALIDATION: start_rtp_receivers() - incoming_tracks.len()={}, is_renegotiation={}", incoming_tracks.len(), is_renegotiation);
         let mut filtered_tracks = incoming_tracks.clone();
-        for incoming_track in incoming_tracks {
-            // If we already have a TrackRemote for a given SSRC don't handle it again
-            for t in local_transceivers {
-                let receiver = t.receiver().await;
-                for track in receiver.tracks().await {
-                    for ssrc in &incoming_track.ssrcs {
-                        if *ssrc == track.ssrc() {
-                            filter_track_with_ssrc(&mut filtered_tracks, track.ssrc());
+
+        if !is_renegotiation {
+            log::info!("🔍 VALIDATION: Filtering tracks (initial negotiation)");
+            for incoming_track in incoming_tracks {
+                // If we already have a TrackRemote for a given SSRC don't handle it again
+                for t in local_transceivers {
+                    let receiver = t.receiver().await;
+                    let existing_tracks = receiver.tracks().await;
+                    log::info!("🔍 VALIDATION:   Receiver has {} existing tracks", existing_tracks.len());
+                    for track in existing_tracks {
+                        log::info!("🔍 VALIDATION:     Existing track ssrc={}", track.ssrc());
+                        for ssrc in &incoming_track.ssrcs {
+                            log::info!("🔍 VALIDATION:       Comparing with incoming ssrc={}", ssrc);
+                            if *ssrc == track.ssrc() {
+                                log::warn!("🔍 VALIDATION:       ❌ FILTERING OUT track with ssrc={} (already exists)", ssrc);
+                                filter_track_with_ssrc(&mut filtered_tracks, track.ssrc());
+                            }
                         }
                     }
                 }
             }
+        } else {
+            log::info!("🔍 VALIDATION: Skipping filtering (renegotiation - receiver reset logic will handle duplicates)");
+        }
+
+        log::info!("🔍 VALIDATION: After filtering - filtered_tracks.len()={}", filtered_tracks.len());
+        for (i, track) in filtered_tracks.iter().enumerate() {
+            log::info!("🔍 VALIDATION:   filtered_track[{}]: mid={}, ssrcs={:?}", i, track.mid, track.ssrcs);
         }
 
         let mut unhandled_tracks = vec![]; // filtered_tracks[:0]
         for incoming_track in filtered_tracks.iter() {
+            log::info!("🔍 VALIDATION: Processing incoming_track mid={}", incoming_track.mid);
             let mut track_handled = false;
-            for t in local_transceivers {
-                if t.mid().as_ref() != Some(&incoming_track.mid) {
+            for (t_idx, t) in local_transceivers.iter().enumerate() {
+                log::info!("🔍 VALIDATION:   Checking transceiver[{}]", t_idx);
+
+                // Check 1: MID match
+                let mid_match = t.mid().as_ref() == Some(&incoming_track.mid);
+                log::info!("🔍 VALIDATION:     MID check: t.mid={:?}, track.mid={}, MATCH={}",
+                    t.mid(), incoming_track.mid, mid_match);
+                if !mid_match {
+                    log::info!("🔍 VALIDATION:     ❌ SKIPPED: MID mismatch");
                     continue;
                 }
 
-                if (incoming_track.kind != t.kind())
-                    || (t.direction() != RTCRtpTransceiverDirection::Recvonly
-                        && t.direction() != RTCRtpTransceiverDirection::Sendrecv)
-                {
+                // Check 2: Kind match
+                let kind_match = incoming_track.kind == t.kind();
+                log::info!("🔍 VALIDATION:     KIND check: track.kind={:?}, t.kind={:?}, MATCH={}",
+                    incoming_track.kind, t.kind(), kind_match);
+
+                // Check 3: Direction check
+                let direction = t.direction();
+                let direction_ok = direction == RTCRtpTransceiverDirection::Recvonly
+                    || direction == RTCRtpTransceiverDirection::Sendrecv;
+                log::info!("🔍 VALIDATION:     DIRECTION check: t.direction={:?}, OK={}",
+                    direction, direction_ok);
+
+                if !kind_match || !direction_ok {
+                    log::info!("🔍 VALIDATION:     ❌ SKIPPED: kind or direction mismatch");
                     continue;
                 }
 
+                // Check 4: have_received check (handle renegotiation)
+                // Fix(issue-107): During renegotiation, allow reusing transceivers that are already receiving.
+                // The same SSRC appears in multiple negotiation rounds in mesh topology. Instead of marking
+                // these tracks as "NOT HANDLED", we recognize the receiver is already active and mark as handled.
                 let receiver = t.receiver().await;
-                if receiver.have_received().await {
-                    continue;
+                let already_receiving = receiver.have_received().await;
+                log::info!("🔍 VALIDATION:     HAVE_RECEIVED check: {}", already_receiving);
+
+                if already_receiving {
+                    if !is_renegotiation {
+                        log::info!("🔍 VALIDATION:     ❌ SKIPPED: already receiving (initial negotiation)");
+                        continue;
+                    } else {
+                        // During renegotiation, receiver already active - just mark as handled
+                        log::info!("🔍 VALIDATION:     ✅ Renegotiation: receiver already active, marking as handled (no restart needed)");
+                        track_handled = true;
+                        break;
+                    }
                 }
+
+                // All checks passed - start receiver (only if not already receiving)
+                log::info!("🔍 VALIDATION:     ✅ ALL CHECKS PASSED - Starting receiver");
                 PeerConnectionInternal::start_receiver(
                     self.setting_engine.get_receive_mtu(),
                     incoming_track,
@@ -463,10 +531,15 @@ impl PeerConnectionInternal {
                 )
                 .await;
                 track_handled = true;
+                log::info!("🔍 VALIDATION:     ✅ Receiver started successfully");
             }
 
             if !track_handled {
+                log::warn!("🔍 VALIDATION: ⚠️ Track NOT HANDLED: mid={}, kind={:?}, ssrcs={:?}",
+                    incoming_track.mid, incoming_track.kind, incoming_track.ssrcs);
                 unhandled_tracks.push(incoming_track);
+            } else {
+                log::info!("🔍 VALIDATION: ✅ Track HANDLED: mid={}", incoming_track.mid);
             }
         }