MEDIA-4254: Add private-port flag for ICE endpoints (#407)

RicardoMDomingues · web-flow · commit 063b85bcf177 · 2025-10-17T10:37:42.000+01:00
diff --git a/api/AllocateEndpoint.h b/api/AllocateEndpoint.h
@@ -14,13 +14,14 @@ struct AllocateEndpoint
 {
     struct Transport
     {
-        Transport() : ice(false), dtls(false), sdes(false) {}
+        Transport() : ice(false), dtls(false), sdes(false), privatePort(false) {}
 
         bool ice;
         utils::Optional<bool> iceControlling;
 
         bool dtls;
         bool sdes;
+        bool privatePort;
     };
 
     struct Audio
diff --git a/api/Parser.cpp b/api/Parser.cpp
@@ -144,6 +144,7 @@ api::AllocateEndpoint::Transport parseAllocateEndpointTransport(const nlohmann::
 
     setIfExists(transport.dtls, data, "dtls");
     setIfExists(transport.sdes, data, "sdes");
+    setIfExists(transport.privatePort, data, "private-port");
 
     return transport;
 }
diff --git a/bridge/LegacyApiRequestHandler.cpp b/bridge/LegacyApiRequestHandler.cpp
@@ -971,7 +971,7 @@ bool LegacyApiRequestHandler::allocateChannel(const std::string& contentName,
 
     if (useBundling)
     {
-        mixer.addBundleTransportIfNeeded(endpointId, iceRole.get(), true);
+        mixer.addBundleTransportIfNeeded(endpointId, iceRole.get(), true, false);
         if (contentType == ContentType::Audio)
         {
             if (!mixer.addBundledAudioStream(channelId, endpointId, channel.getMediaMode()))
@@ -993,15 +993,15 @@ bool LegacyApiRequestHandler::allocateChannel(const std::string& contentName,
     {
         if (contentType == ContentType::Audio)
         {
-            if (!mixer.addAudioStream(channelId, endpointId, iceRole, channel.getMediaMode()))
+            if (!mixer.addAudioStream(channelId, endpointId, iceRole, channel.getMediaMode(), false))
             {
                 outStatus = httpd::StatusCode::BAD_REQUEST;
                 return false;
             }
         }
         else if (contentType == ContentType::Video)
         {
-            if (!mixer.addVideoStream(channelId, endpointId, iceRole, channel.isRelayTypeRewrite()))
+            if (!mixer.addVideoStream(channelId, endpointId, iceRole, channel.isRelayTypeRewrite(), false))
             {
                 outStatus = httpd::StatusCode::BAD_REQUEST;
                 return false;
@@ -1075,7 +1075,7 @@ bool LegacyApiRequestHandler::allocateSctpConnection(const std::string& conferen
     {
         iceRole.set(ice::IceRole::CONTROLLING);
     }
-    mixer.addBundleTransportIfNeeded(endpointId, iceRole.get(), true);
+    mixer.addBundleTransportIfNeeded(endpointId, iceRole.get(), true, false);
     mixer.addBundledDataStream(streamId, endpointId);
 
     uint32_t totalSleepTimeMs = 0;
diff --git a/bridge/Mixer.cpp b/bridge/Mixer.cpp
@@ -272,15 +272,17 @@ bool Mixer::hasPendingTransportJobs()
 
 bool Mixer::addBundleTransportIfNeeded(const std::string& endpointId,
     const ice::IceRole iceRole,
-    const bool hasVideoEnabled)
+    const bool hasVideoEnabled,
+    const bool usePrivatePort)
 {
     std::lock_guard<std::mutex> locker(_configurationLock);
     if (_bundleTransports.find(endpointId) != _bundleTransports.end())
     {
         return true;
     }
 
-    if (!_useGlobalPort && _rtpPorts.empty())
+    const bool needToOpenConferencePorts = !usePrivatePort && !_useGlobalPort && _rtpPorts.empty();
+    if (needToOpenConferencePorts)
     {
         if (!_transportFactory.openRtpMuxPorts(_rtpPorts, 1024))
         {
@@ -304,7 +306,8 @@ bool Mixer::addBundleTransportIfNeeded(const std::string& endpointId,
                                           expectedOutboundStreamCount,
                                           jobQueueSize,
                                           enableUplinkEstimation,
-                                          true)
+                                          true,
+                                          usePrivatePort)
                                     : _transportFactory.createOnPorts(iceRole,
                                           endpointIdHash,
                                           _rtpPorts,
@@ -342,6 +345,7 @@ bool Mixer::addAudioStream(std::string& outId,
     const std::string& endpointId,
     const utils::Optional<ice::IceRole>& iceRole,
     const MediaMode mediaMode,
+    const bool usePrivatePort,
     utils::Optional<uint32_t> idleTimeoutSeconds)
 {
     std::lock_guard<std::mutex> locker(_configurationLock);
@@ -352,8 +356,9 @@ bool Mixer::addAudioStream(std::string& outId,
     }
 
     outId = std::to_string(_idGenerator.next());
-    auto transport = iceRole.isSet() ? _transportFactory.create(iceRole.get(), utils::hash<std::string>{}(endpointId))
-                                     : _transportFactory.create(utils::hash<std::string>{}(endpointId));
+    auto transport = iceRole.isSet()
+        ? _transportFactory.create(iceRole.get(), utils::hash<std::string>{}(endpointId), usePrivatePort)
+        : _transportFactory.create(utils::hash<std::string>{}(endpointId));
 
     if (!transport)
     {
@@ -390,6 +395,7 @@ bool Mixer::addVideoStream(std::string& outId,
     const std::string& endpointId,
     const utils::Optional<ice::IceRole>& iceRole,
     bool rewriteSsrcs,
+    const bool usePrivatePort,
     utils::Optional<uint32_t> idleTimeoutSeconds)
 {
     std::lock_guard<std::mutex> locker(_configurationLock);
@@ -409,8 +415,9 @@ bool Mixer::addVideoStream(std::string& outId,
     }
 
     outId = std::to_string(_idGenerator.next());
-    auto transport = iceRole.isSet() ? _transportFactory.create(iceRole.get(), utils::hash<std::string>{}(endpointId))
-                                     : _transportFactory.create(utils::hash<std::string>{}(endpointId));
+    auto transport = iceRole.isSet()
+        ? _transportFactory.create(iceRole.get(), utils::hash<std::string>{}(endpointId), usePrivatePort)
+        : _transportFactory.create(utils::hash<std::string>{}(endpointId));
 
     if (!transport)
     {
diff --git a/bridge/Mixer.h b/bridge/Mixer.h
@@ -107,17 +107,20 @@ class Mixer
 
     bool addBundleTransportIfNeeded(const std::string& endpointId,
         const ice::IceRole iceRole,
-        const bool hasVideoEnabled);
+        const bool hasVideoEnabled,
+        const bool usePrivatePort);
 
     bool addAudioStream(std::string& outId,
         const std::string& endpointId,
         const utils::Optional<ice::IceRole>& iceRole,
         MediaMode mediaMode,
+        const bool usePrivatePort,
         utils::Optional<uint32_t> idleTimeoutSeconds = utils::Optional<uint32_t>());
     bool addVideoStream(std::string& outId,
         const std::string& endpointId,
         const utils::Optional<ice::IceRole>& iceRole,
         bool rewriteSsrcs,
+        const bool usePrivatePort,
         utils::Optional<uint32_t> idleTimeoutSeconds = utils::Optional<uint32_t>());
 
     bool addBundledAudioStream(std::string& outId,
diff --git a/bridge/endpointActions/ConferenceActions.cpp b/bridge/endpointActions/ConferenceActions.cpp
@@ -316,7 +316,7 @@ httpd::Response allocateEndpoint(ActionContext* context,
 
         const bool hasVideoEnabled = allocateChannel.video.isSet();
 
-        mixer->addBundleTransportIfNeeded(endpointId, iceRole, hasVideoEnabled);
+        mixer->addBundleTransportIfNeeded(endpointId, iceRole, hasVideoEnabled, bundleTransport.privatePort);
 
         if (allocateChannel.audio.isSet())
         {
@@ -388,6 +388,7 @@ httpd::Response allocateEndpoint(ActionContext* context,
                     endpointId,
                     iceRole,
                     audio.getMediaMode(),
+                    transport.privatePort,
                     allocateChannel.idleTimeoutSeconds))
             {
                 throw httpd::RequestErrorException(httpd::StatusCode::INTERNAL_SERVER_ERROR,
@@ -421,6 +422,7 @@ httpd::Response allocateEndpoint(ActionContext* context,
                     endpointId,
                     iceRole,
                     ssrcRewrite,
+                    transport.privatePort,
                     allocateChannel.idleTimeoutSeconds))
             {
                 videoChannelId.set(outChannelId);
diff --git a/test/bridge/ApiRequestHandlerTest.cpp b/test/bridge/ApiRequestHandlerTest.cpp
@@ -1,6 +1,7 @@
 
 #include "bridge/ApiRequestHandler.h"
 #include "bridge/Mixer.h"
+#include "bridge/TransportDescription.h"
 #include "mocks/EngineMixerSpy.h"
 #include "mocks/MixerManagerSpy.h"
 #include "mocks/RtcTransportMock.h"
@@ -384,3 +385,104 @@ TEST_F(ApiRequestHandlerTest, allocateEndpointWithVideoFieldWhenVideoIsEnableSho
     EXPECT_NE(responseJson.end(), responseJson.find("video"));
     EXPECT_NE(responseJson.end(), responseJson.find("data"));
 }
+
+TEST_F(ApiRequestHandlerTest, allocateEndpointWithPrivateShouldPassFlagToFactory)
+{
+    auto requestHandler = createApiRequestHandler();
+
+    const auto conferenceId = createConference(requestHandler, R"({
+     "last-n": 9,
+     "enable-video": true
+     })");
+
+    const char* body = R"({
+        "action": "allocate",
+        "bundle-transport": {
+            "ice": true,
+            "dtls": true,
+            "private-port": true
+        },
+        "audio": {
+            "relay-type": "ssrc-rewrite"
+        }
+    })";
+
+    const auto urlPath = std::string("/conferences/").append(conferenceId).append("/session0");
+
+    httpd::Request request("POST", urlPath.c_str());
+    request.body.append(body, strlen(body));
+
+    EXPECT_CALL(*_mixerManagerSpyResources->transportFactoryMock, create(_, _, _, _, _, _, _, true)).Times(1);
+
+    const auto response = requestHandler.onRequest(request);
+
+    EXPECT_EQ(httpd::StatusCode::OK, response.statusCode);
+    EXPECT_EQ(false, response.body.empty());
+
+    Mixer* mixer = nullptr;
+
+    auto lock = _mixerManagerSpy->getMixer(conferenceId, mixer);
+
+    ASSERT_NE(nullptr, mixer);
+
+    bridge::TransportDescription transportDescription;
+    ASSERT_TRUE(mixer->getTransportBundleDescription("session0", transportDescription));
+}
+
+TEST_F(ApiRequestHandlerTest, allocateEndpointWithoutPrivateShouldPassFlagToFactory)
+{
+    auto requestHandler = createApiRequestHandler();
+
+    const auto conferenceId = createConference(requestHandler, R"({
+     "last-n": 9,
+     "enable-video": true
+     })");
+
+    const char* body0 = R"({
+        "action": "allocate",
+        "bundle-transport": {
+            "ice": true,
+            "dtls": true,
+            "private-port": false
+        },
+        "audio": {
+            "relay-type": "ssrc-rewrite"
+        }
+    })";
+
+    const char* body1 = R"({
+        "action": "allocate",
+        "bundle-transport": {
+            "ice": true,
+            "dtls": true
+        },
+        "audio": {
+            "relay-type": "ssrc-rewrite"
+        }
+    })";
+
+    EXPECT_CALL(*_mixerManagerSpyResources->transportFactoryMock,
+        create(_, utils::hash<std::string>{}("session2"), _, _, _, _, _, false))
+        .Times(1);
+
+    const auto urlPath0 = std::string("/conferences/").append(conferenceId).append("/session2");
+    const auto urlPath1 = std::string("/conferences/").append(conferenceId).append("/session3");
+
+    httpd::Request request0("POST", urlPath0.c_str());
+    request0.body.append(body0, strlen(body0));
+
+    const auto response0 = requestHandler.onRequest(request0);
+    EXPECT_EQ(httpd::StatusCode::OK, response0.statusCode);
+    EXPECT_EQ(false, response0.body.empty());
+
+    EXPECT_CALL(*_mixerManagerSpyResources->transportFactoryMock,
+        create(_, utils::hash<std::string>{}("session3"), _, _, _, _, _, false))
+        .Times(1);
+
+    httpd::Request request1("POST", urlPath1.c_str());
+    request1.body.append(body1, strlen(body1));
+
+    const auto response1 = requestHandler.onRequest(request1);
+    EXPECT_EQ(httpd::StatusCode::OK, response1.statusCode);
+    EXPECT_EQ(false, response1.body.empty());
+}
diff --git a/test/bridge/MixerTest.cpp b/test/bridge/MixerTest.cpp
@@ -236,7 +236,7 @@ class MixerTest : public ::testing::Test
         bool useData)
     {
         std::string outId;
-        CHECK(mixer.addBundleTransportIfNeeded(endpointId, ice::IceRole::CONTROLLING, true));
+        CHECK(mixer.addBundleTransportIfNeeded(endpointId, ice::IceRole::CONTROLLING, true, false));
         CHECK(mixer.addBundledAudioStream(outId, endpointId, MediaMode::SSRC_REWRITE));
         CHECK(mixer.addBundledVideoStream(outId, endpointId, true));
         CHECK(mixer.addBundledDataStream(outId, endpointId));
diff --git a/test/include/mocks/TransportFactoryMock.h b/test/include/mocks/TransportFactoryMock.h
@@ -18,11 +18,12 @@ class TransportFactoryMock : public transport::TransportFactory
             size_t expectedOutboundStreamCount,
             size_t jobQueueSize,
             bool enableUplinkEstimation,
-            bool enableDownlinkEstimation),
+            bool enableDownlinkEstimation,
+            bool privatePort),
         (override));
     MOCK_METHOD(std::shared_ptr<transport::RtcTransport>,
         create,
-        (const ice::IceRole iceRole, const size_t endpointId),
+        (const ice::IceRole iceRole, const size_t endpointId, bool privatePort),
         (override));
 
     MOCK_METHOD(std::shared_ptr<transport::RtcTransport>, create, (const size_t endpointIdHash), (override));
@@ -100,8 +101,8 @@ class TransportFactoryMock : public transport::TransportFactory
         using namespace ::testing;
 
         ON_CALL(*this, create(_)).WillByDefault(Return(rtcTransport));
-        ON_CALL(*this, create(_, _)).WillByDefault(Return(rtcTransport));
-        ON_CALL(*this, create(_, _, _, _, _, _, _)).WillByDefault(Return(rtcTransport));
+        ON_CALL(*this, create(_, _, _)).WillByDefault(Return(rtcTransport));
+        ON_CALL(*this, create(_, _, _, _, _, _, _, _)).WillByDefault(Return(rtcTransport));
         ON_CALL(*this, createOnSharedPort(_, _)).WillByDefault(Return(rtcTransport));
         ON_CALL(*this, createOnSharedPort(_, _, _, _, _, _, _)).WillByDefault(Return(rtcTransport));
         ON_CALL(*this, createOnPrivatePort(_, _)).WillByDefault(Return(rtcTransport));
@@ -112,26 +113,17 @@ class TransportFactoryMock : public transport::TransportFactory
     {
         using namespace ::testing;
 
-        const auto callback1Args = [=](const auto&) {
-            return rtcTransport.lock();
-        };
-
-        const auto callback2Args = [=](const auto&, const auto&) {
+        const auto callbackNArgs = [=](const auto&... args) {
             return rtcTransport.lock();
         };
 
-        const auto callback7Args =
-            [=](const auto&, const auto&, const auto&, const auto&, const auto&, const auto&, const auto&) {
-                return rtcTransport.lock();
-            };
-
-        ON_CALL(*this, create(_)).WillByDefault(callback1Args);
-        ON_CALL(*this, create(_, _)).WillByDefault(callback2Args);
-        ON_CALL(*this, create(_, _, _, _, _, _, _)).WillByDefault(callback7Args);
-        ON_CALL(*this, createOnSharedPort(_, _)).WillByDefault(callback2Args);
-        ON_CALL(*this, createOnSharedPort(_, _, _, _, _, _, _)).WillByDefault(callback7Args);
-        ON_CALL(*this, createOnPrivatePort(_, _)).WillByDefault(callback2Args);
-        ON_CALL(*this, createOnPrivatePort(_, _, _, _, _, _, _)).WillByDefault(callback7Args);
+        ON_CALL(*this, create(_)).WillByDefault(callbackNArgs);
+        ON_CALL(*this, create(_, _, _)).WillByDefault(callbackNArgs);
+        ON_CALL(*this, create(_, _, _, _, _, _, _, _)).WillByDefault(callbackNArgs);
+        ON_CALL(*this, createOnSharedPort(_, _)).WillByDefault(callbackNArgs);
+        ON_CALL(*this, createOnSharedPort(_, _, _, _, _, _, _)).WillByDefault(callbackNArgs);
+        ON_CALL(*this, createOnPrivatePort(_, _)).WillByDefault(callbackNArgs);
+        ON_CALL(*this, createOnPrivatePort(_, _, _, _, _, _, _)).WillByDefault(callbackNArgs);
     }
 };
 
diff --git a/transport/TransportFactory.cpp b/transport/TransportFactory.cpp
@@ -340,11 +340,12 @@ class TransportFactoryImpl final : public TransportFactory,
         size_t expectedOutboundStreamCount,
         size_t jobQueueSize,
         bool enableUplinkEstimation,
-        bool enableDownlinkEstimation) override
+        bool enableDownlinkEstimation,
+        bool privatePort) override
     {
-        if (!_sharedEndpoints.empty())
+        if (privatePort || _sharedEndpoints.empty())
         {
-            return createOnSharedPort(iceRole,
+            return createOnPrivatePort(iceRole,
                 endpointId,
                 expectedInboundStreamCount,
                 expectedOutboundStreamCount,
@@ -353,7 +354,7 @@ class TransportFactoryImpl final : public TransportFactory,
                 enableDownlinkEstimation);
         }
 
-        return createOnPrivatePort(iceRole,
+        return createOnSharedPort(iceRole,
             endpointId,
             expectedInboundStreamCount,
             expectedOutboundStreamCount,
@@ -362,9 +363,11 @@ class TransportFactoryImpl final : public TransportFactory,
             enableDownlinkEstimation);
     }
 
-    std::shared_ptr<RtcTransport> create(const ice::IceRole iceRole, const size_t endpointId) override
+    std::shared_ptr<RtcTransport> create(const ice::IceRole iceRole,
+        const size_t endpointId,
+        const bool privatePort) override
     {
-        return create(iceRole, endpointId, 16, 256, 4096, true, true);
+        return create(iceRole, endpointId, 16, 256, 4096, true, true, privatePort);
     }
 
     std::shared_ptr<RtcTransport> createOnPrivatePort(const ice::IceRole iceRole, const size_t endpointId) override
diff --git a/transport/TransportFactory.h b/transport/TransportFactory.h

Original file line number	Diff line number	Diff line change
`@@ -14,13 +14,14 @@ struct AllocateEndpoint`
`14`	`14`	`{`
`15`	`15`	`struct Transport`
`16`	`16`	`{`
`17`		`- Transport() : ice(false), dtls(false), sdes(false) {}`
	`17`	`+ Transport() : ice(false), dtls(false), sdes(false), privatePort(false) {}`
`18`	`18`
`19`	`19`	`bool ice;`
`20`	`20`	`utils::Optional<bool> iceControlling;`
`21`	`21`
`22`	`22`	`bool dtls;`
`23`	`23`	`bool sdes;`
	`24`	`+ bool privatePort;`
`24`	`25`	`};`
`25`	`26`
`26`	`27`	`struct Audio`
Original file line number	Diff line number	Diff line change
`@@ -144,6 +144,7 @@ api::AllocateEndpoint::Transport parseAllocateEndpointTransport(const nlohmann::`
`144`	`144`
`145`	`145`	`setIfExists(transport.dtls, data, "dtls");`
`146`	`146`	`setIfExists(transport.sdes, data, "sdes");`
	`147`	`+ setIfExists(transport.privatePort, data, "private-port");`
`147`	`148`
`148`	`149`	`return transport;`
`149`	`150`	`}`
Original file line number	Diff line number	Diff line change
`@@ -971,7 +971,7 @@ bool LegacyApiRequestHandler::allocateChannel(const std::string& contentName,`
`971`	`971`
`972`	`972`	`if (useBundling)`
`973`	`973`	`{`
`974`		`- mixer.addBundleTransportIfNeeded(endpointId, iceRole.get(), true);`
	`974`	`+ mixer.addBundleTransportIfNeeded(endpointId, iceRole.get(), true, false);`
`975`	`975`	`if (contentType == ContentType::Audio)`
`976`	`976`	`{`
`977`	`977`	`if (!mixer.addBundledAudioStream(channelId, endpointId, channel.getMediaMode()))`
`@@ -993,15 +993,15 @@ bool LegacyApiRequestHandler::allocateChannel(const std::string& contentName,`
`993`	`993`	`{`
`994`	`994`	`if (contentType == ContentType::Audio)`
`995`	`995`	`{`
`996`		`- if (!mixer.addAudioStream(channelId, endpointId, iceRole, channel.getMediaMode()))`
	`996`	`+ if (!mixer.addAudioStream(channelId, endpointId, iceRole, channel.getMediaMode(), false))`
`997`	`997`	`{`
`998`	`998`	`outStatus = httpd::StatusCode::BAD_REQUEST;`
`999`	`999`	`return false;`
`1000`	`1000`	`}`
`1001`	`1001`	`}`
`1002`	`1002`	`else if (contentType == ContentType::Video)`
`1003`	`1003`	`{`
`1004`		`- if (!mixer.addVideoStream(channelId, endpointId, iceRole, channel.isRelayTypeRewrite()))`
	`1004`	`+ if (!mixer.addVideoStream(channelId, endpointId, iceRole, channel.isRelayTypeRewrite(), false))`
`1005`	`1005`	`{`
`1006`	`1006`	`outStatus = httpd::StatusCode::BAD_REQUEST;`
`1007`	`1007`	`return false;`
`@@ -1075,7 +1075,7 @@ bool LegacyApiRequestHandler::allocateSctpConnection(const std::string& conferen`
`1075`	`1075`	`{`
`1076`	`1076`	`iceRole.set(ice::IceRole::CONTROLLING);`
`1077`	`1077`	`}`
`1078`		`- mixer.addBundleTransportIfNeeded(endpointId, iceRole.get(), true);`
	`1078`	`+ mixer.addBundleTransportIfNeeded(endpointId, iceRole.get(), true, false);`
`1079`	`1079`	`mixer.addBundledDataStream(streamId, endpointId);`
`1080`	`1080`
`1081`	`1081`	`uint32_t totalSleepTimeMs = 0;`
Original file line number	Diff line number	Diff line change
`@@ -272,15 +272,17 @@ bool Mixer::hasPendingTransportJobs()`
`272`	`272`
`273`	`273`	`bool Mixer::addBundleTransportIfNeeded(const std::string& endpointId,`
`274`	`274`	`const ice::IceRole iceRole,`
`275`		`- const bool hasVideoEnabled)`
	`275`	`+ const bool hasVideoEnabled,`
	`276`	`+ const bool usePrivatePort)`
`276`	`277`	`{`
`277`	`278`	`std::lock_guard<std::mutex> locker(_configurationLock);`
`278`	`279`	`if (_bundleTransports.find(endpointId) != _bundleTransports.end())`
`279`	`280`	`{`
`280`	`281`	`return true;`
`281`	`282`	`}`
`282`	`283`
`283`		`- if (!_useGlobalPort && _rtpPorts.empty())`
	`284`	`+ const bool needToOpenConferencePorts = !usePrivatePort && !_useGlobalPort && _rtpPorts.empty();`
	`285`	`+ if (needToOpenConferencePorts)`
`284`	`286`	`{`
`285`	`287`	`if (!_transportFactory.openRtpMuxPorts(_rtpPorts, 1024))`
`286`	`288`	`{`
`@@ -304,7 +306,8 @@ bool Mixer::addBundleTransportIfNeeded(const std::string& endpointId,`
`304`	`306`	`expectedOutboundStreamCount,`
`305`	`307`	`jobQueueSize,`
`306`	`308`	`enableUplinkEstimation,`
`307`		`- true)`
	`309`	`+ true,`
	`310`	`+ usePrivatePort)`
`308`	`311`	`: _transportFactory.createOnPorts(iceRole,`
`309`	`312`	`endpointIdHash,`
`310`	`313`	`_rtpPorts,`
`@@ -342,6 +345,7 @@ bool Mixer::addAudioStream(std::string& outId,`
`342`	`345`	`const std::string& endpointId,`
`343`	`346`	`const utils::Optional<ice::IceRole>& iceRole,`
`344`	`347`	`const MediaMode mediaMode,`
	`348`	`+ const bool usePrivatePort,`
`345`	`349`	`utils::Optional<uint32_t> idleTimeoutSeconds)`
`346`	`350`	`{`
`347`	`351`	`std::lock_guard<std::mutex> locker(_configurationLock);`
`@@ -352,8 +356,9 @@ bool Mixer::addAudioStream(std::string& outId,`
`352`	`356`	`}`
`353`	`357`
`354`	`358`	`outId = std::to_string(_idGenerator.next());`
`355`		`- auto transport = iceRole.isSet() ? _transportFactory.create(iceRole.get(), utils::hash<std::string>{}(endpointId))`
`356`		`- : _transportFactory.create(utils::hash<std::string>{}(endpointId));`
	`359`	`+ auto transport = iceRole.isSet()`
	`360`	`+ ? _transportFactory.create(iceRole.get(), utils::hash<std::string>{}(endpointId), usePrivatePort)`
	`361`	`+ : _transportFactory.create(utils::hash<std::string>{}(endpointId));`
`357`	`362`
`358`	`363`	`if (!transport)`
`359`	`364`	`{`
`@@ -390,6 +395,7 @@ bool Mixer::addVideoStream(std::string& outId,`
`390`	`395`	`const std::string& endpointId,`
`391`	`396`	`const utils::Optional<ice::IceRole>& iceRole,`
`392`	`397`	`bool rewriteSsrcs,`
	`398`	`+ const bool usePrivatePort,`
`393`	`399`	`utils::Optional<uint32_t> idleTimeoutSeconds)`
`394`	`400`	`{`
`395`	`401`	`std::lock_guard<std::mutex> locker(_configurationLock);`
`@@ -409,8 +415,9 @@ bool Mixer::addVideoStream(std::string& outId,`
`409`	`415`	`}`
`410`	`416`
`411`	`417`	`outId = std::to_string(_idGenerator.next());`
`412`		`- auto transport = iceRole.isSet() ? _transportFactory.create(iceRole.get(), utils::hash<std::string>{}(endpointId))`
`413`		`- : _transportFactory.create(utils::hash<std::string>{}(endpointId));`
	`418`	`+ auto transport = iceRole.isSet()`
	`419`	`+ ? _transportFactory.create(iceRole.get(), utils::hash<std::string>{}(endpointId), usePrivatePort)`
	`420`	`+ : _transportFactory.create(utils::hash<std::string>{}(endpointId));`
`414`	`421`
`415`	`422`	`if (!transport)`
`416`	`423`	`{`
Original file line number	Diff line number	Diff line change
`@@ -236,7 +236,7 @@ class MixerTest : public ::testing::Test`
`236`	`236`	`bool useData)`
`237`	`237`	`{`
`238`	`238`	`std::string outId;`
`239`		`- CHECK(mixer.addBundleTransportIfNeeded(endpointId, ice::IceRole::CONTROLLING, true));`
	`239`	`+ CHECK(mixer.addBundleTransportIfNeeded(endpointId, ice::IceRole::CONTROLLING, true, false));`
`240`	`240`	`CHECK(mixer.addBundledAudioStream(outId, endpointId, MediaMode::SSRC_REWRITE));`
`241`	`241`	`CHECK(mixer.addBundledVideoStream(outId, endpointId, true));`
`242`	`242`	`CHECK(mixer.addBundledDataStream(outId, endpointId));`
Original file line number	Diff line number	Diff line change
`@@ -340,11 +340,12 @@ class TransportFactoryImpl final : public TransportFactory,`
`340`	`340`	`size_t expectedOutboundStreamCount,`
`341`	`341`	`size_t jobQueueSize,`
`342`	`342`	`bool enableUplinkEstimation,`
`343`		`- bool enableDownlinkEstimation) override`
	`343`	`+ bool enableDownlinkEstimation,`
	`344`	`+ bool privatePort) override`
`344`	`345`	`{`
`345`		`- if (!_sharedEndpoints.empty())`
	`346`	`+ if (privatePort \|\| _sharedEndpoints.empty())`
`346`	`347`	`{`
`347`		`- return createOnSharedPort(iceRole,`
	`348`	`+ return createOnPrivatePort(iceRole,`
`348`	`349`	`endpointId,`
`349`	`350`	`expectedInboundStreamCount,`
`350`	`351`	`expectedOutboundStreamCount,`
`@@ -353,7 +354,7 @@ class TransportFactoryImpl final : public TransportFactory,`
`353`	`354`	`enableDownlinkEstimation);`
`354`	`355`	`}`
`355`	`356`
`356`		`- return createOnPrivatePort(iceRole,`
	`357`	`+ return createOnSharedPort(iceRole,`
`357`	`358`	`endpointId,`
`358`	`359`	`expectedInboundStreamCount,`
`359`	`360`	`expectedOutboundStreamCount,`
`@@ -362,9 +363,11 @@ class TransportFactoryImpl final : public TransportFactory,`
`362`	`363`	`enableDownlinkEstimation);`
`363`	`364`	`}`
`364`	`365`
`365`		`- std::shared_ptr<RtcTransport> create(const ice::IceRole iceRole, const size_t endpointId) override`
	`366`	`+ std::shared_ptr<RtcTransport> create(const ice::IceRole iceRole,`
	`367`	`+ const size_t endpointId,`
	`368`	`+ const bool privatePort) override`
`366`	`369`	`{`
`367`		`- return create(iceRole, endpointId, 16, 256, 4096, true, true);`
	`370`	`+ return create(iceRole, endpointId, 16, 256, 4096, true, true, privatePort);`
`368`	`371`	`}`
`369`	`372`
`370`	`373`	`std::shared_ptr<RtcTransport> createOnPrivatePort(const ice::IceRole iceRole, const size_t endpointId) override`