Harmonized MTU with fragment size and set default MTU to 1280

include/rtc/nalunit.hpp

@@ -144,7 +144,7 @@ protected:
 
 class RTC_CPP_EXPORT NalUnits : public std::vector<std::shared_ptr<NalUnit>> {
 public:
-	static const uint16_t defaultMaximumFragmentSize = 1400;
+	static const uint16_t defaultMaximumFragmentSize;
 	std::vector<std::shared_ptr<binary>> generateFragments(uint16_t maximumFragmentSize);
 };
 

include/rtc/rtc.h

@@ -40,7 +40,7 @@ extern "C" {
 #endif
 
 #if RTC_ENABLE_MEDIA
-#define RTC_DEFAULT_MAXIMUM_FRAGMENT_SIZE ((uint16_t)1400)
+#define RTC_DEFAULT_MAXIMUM_FRAGMENT_SIZE ((uint16_t)(1280 - 12 - 8 - 40)) // SRTP/UDP/IPv6
 #define RTC_DEFAULT_MAXIMUM_PACKET_COUNT_FOR_NACK_CACHE ((unsigned)512)
 #endif
 

src/globals.hpp

@@ -34,7 +34,7 @@ const size_t RECV_QUEUE_LIMIT = 1024 * 1024; // Max per-channel queue size
 
 const int THREADPOOL_SIZE = 4; // Number of threads in the global thread pool (>= 2)
 
-const size_t DEFAULT_IPV4_MTU = 1200; // IPv4 safe MTU value recommended by RFC 8261
+const size_t DEFAULT_MTU = 1280; // IPv6 minimum guaranteed MTU
 
 } // namespace rtc
 

src/impl/datachannel.cpp

@@ -255,13 +255,13 @@ void DataChannel::incoming(message_ptr message) {
 	}
 }
 
-NegotiatedDataChannel::NegotiatedDataChannel(std::weak_ptr<impl::PeerConnection> pc,
+NegotiatedDataChannel::NegotiatedDataChannel(std::weak_ptr<PeerConnection> pc,
                                              uint16_t stream, string label, string protocol,
                                              Reliability reliability)
     : DataChannel(pc, stream, std::move(label), std::move(protocol), std::move(reliability)) {}
 
-NegotiatedDataChannel::NegotiatedDataChannel(std::weak_ptr<impl::PeerConnection> pc,
-                                             std::weak_ptr<impl::SctpTransport> transport,
+NegotiatedDataChannel::NegotiatedDataChannel(std::weak_ptr<PeerConnection> pc,
+                                             std::weak_ptr<SctpTransport> transport,
                                              uint16_t stream)
     : DataChannel(pc, stream, "", "", {}) {
 	mSctpTransport = transport;
@@ -269,7 +269,7 @@ NegotiatedDataChannel::NegotiatedDataChannel(std::weak_ptr<impl::PeerConnection>
 
 NegotiatedDataChannel::~NegotiatedDataChannel() {}
 
-void NegotiatedDataChannel::open(shared_ptr<impl::SctpTransport> transport) {
+void NegotiatedDataChannel::open(shared_ptr<SctpTransport> transport) {
 	std::unique_lock lock(mMutex);
 	mSctpTransport = transport;
 

src/impl/datachannel.hpp

@@ -34,7 +34,7 @@ namespace rtc::impl {
 struct PeerConnection;
 
 struct DataChannel : Channel, std::enable_shared_from_this<DataChannel> {
-	DataChannel(weak_ptr<impl::PeerConnection> pc, uint16_t stream, string label, string protocol,
+	DataChannel(weak_ptr<PeerConnection> pc, uint16_t stream, string label, string protocol,
 	            Reliability reliability);
 	~DataChannel();
 
@@ -79,13 +79,13 @@ protected:
 };
 
 struct NegotiatedDataChannel final : public DataChannel {
-	NegotiatedDataChannel(weak_ptr<impl::PeerConnection> pc, uint16_t stream, string label,
+	NegotiatedDataChannel(weak_ptr<PeerConnection> pc, uint16_t stream, string label,
 	                      string protocol, Reliability reliability);
-	NegotiatedDataChannel(weak_ptr<impl::PeerConnection> pc,
-	                      weak_ptr<impl::SctpTransport> transport, uint16_t stream);
+	NegotiatedDataChannel(weak_ptr<PeerConnection> pc,
+	                      weak_ptr<SctpTransport> transport, uint16_t stream);
 	~NegotiatedDataChannel();
 
-	void open(impl_ptr<impl::SctpTransport> transport) override;
+	void open(impl_ptr<SctpTransport> transport) override;
 	void processOpenMessage(message_ptr message) override;
 };
 

src/impl/dtlstransport.cpp

@@ -159,7 +159,7 @@ void DtlsTransport::runRecvLoop() {
 	try {
 		changeState(State::Connecting);
 
-		size_t mtu = mMtu.value_or(DEFAULT_IPV4_MTU + 20) - 8 - 40; // UDP/IPv6
+		size_t mtu = mMtu.value_or(DEFAULT_MTU) - 8 - 40; // UDP/IPv6
 		gnutls_dtls_set_mtu(mSession, static_cast<unsigned int>(mtu));
 		PLOG_VERBOSE << "SSL MTU set to " << mtu;
 
@@ -445,7 +445,7 @@ void DtlsTransport::runRecvLoop() {
 	try {
 		changeState(State::Connecting);
 
-		size_t mtu = mMtu.value_or(DEFAULT_IPV4_MTU + 20) - 8 - 40; // UDP/IPv6
+		size_t mtu = mMtu.value_or(DEFAULT_MTU) - 8 - 40; // UDP/IPv6
 		SSL_set_mtu(mSsl, static_cast<unsigned int>(mtu));
 		PLOG_VERBOSE << "SSL MTU set to " << mtu;
 

src/impl/peerconnection.cpp

@@ -19,10 +19,10 @@
 
 #include "peerconnection.hpp"
 #include "certificate.hpp"
+#include "common.hpp"
 #include "dtlstransport.hpp"
 #include "globals.hpp"
 #include "icetransport.hpp"
-#include "common.hpp"
 #include "logcounter.hpp"
 #include "peerconnection.hpp"
 #include "processor.hpp"
@@ -647,7 +647,7 @@ shared_ptr<Track> PeerConnection::emplaceTrack(Description::Media description) {
 			track->setDescription(std::move(description));
 
 	if (!track) {
-		track = std::make_shared<Track>(std::move(description));
+		track = std::make_shared<Track>(shared_from_this(), std::move(description));
 		mTracks.emplace(std::make_pair(track->mid(), track));
 		mTrackLines.emplace_back(track);
 	}
@@ -663,7 +663,7 @@ void PeerConnection::incomingTrack(Description::Media description) {
 	}
 #endif
 	if (mTracks.find(description.mid()) == mTracks.end()) {
-		auto track = std::make_shared<Track>(std::move(description));
+		auto track = std::make_shared<Track>(shared_from_this(), std::move(description));
 		mTracks.emplace(std::make_pair(track->mid(), track));
 		mTrackLines.emplace_back(track);
 		triggerTrack(track);

src/impl/sctptransport.cpp

@@ -193,7 +193,7 @@ SctpTransport::SctpTransport(std::shared_ptr<Transport> lower, uint16_t port,
 		spp.spp_flags |= SPP_PMTUD_DISABLE;
 		// The MTU value provided specifies the space available for chunks in the
 		// packet, so we also subtract the SCTP header size.
-		size_t pmtu = mtu.value_or(DEFAULT_IPV4_MTU + 20) - 12 - 37 - 8 - 40; // SCTP/DTLS/UDP/IPv6
+		size_t pmtu = mtu.value_or(DEFAULT_MTU) - 12 - 37 - 8 - 40; // SCTP/DTLS/UDP/IPv6
 		spp.spp_pathmtu = uint32_t(pmtu);
 		PLOG_VERBOSE << "Path MTU discovery disabled, SCTP MTU set to " << pmtu;
 	}

src/impl/track.cpp

@@ -19,6 +19,7 @@
 #include "track.hpp"
 #include "globals.hpp"
 #include "logcounter.hpp"
+#include "peerconnection.hpp"
 
 namespace rtc::impl {
 
@@ -27,8 +28,9 @@ static LogCounter COUNTER_MEDIA_BAD_DIRECTION(plog::warning,
 static LogCounter COUNTER_QUEUE_FULL(plog::warning,
                                      "Number of media packets dropped due to a full queue");
 
-Track::Track(Description::Media description)
-    : mMediaDescription(std::move(description)), mRecvQueue(RECV_QUEUE_LIMIT, message_size_func) {}
+Track::Track(weak_ptr<PeerConnection> pc, Description::Media description)
+    : mPeerConnection(pc), mMediaDescription(std::move(description)),
+      mRecvQueue(RECV_QUEUE_LIMIT, message_size_func) {}
 
 string Track::mid() const {
 	std::shared_lock lock(mMutex);
@@ -74,6 +76,8 @@ std::optional<message_variant> Track::peek() {
 	return nullopt;
 }
 
+size_t Track::availableAmount() const { return mRecvQueue.amount(); }
+
 bool Track::isOpen(void) const {
 #if RTC_ENABLE_MEDIA
 	std::shared_lock lock(mMutex);
@@ -85,7 +89,13 @@ bool Track::isOpen(void) const {
 
 bool Track::isClosed(void) const { return mIsClosed; }
 
-size_t Track::availableAmount() const { return mRecvQueue.amount(); }
+size_t Track::maxMessageSize() const {
+	std::optional<size_t> mtu;
+	if (auto pc = mPeerConnection.lock())
+		mtu = pc->config.mtu;
+
+	return mtu.value_or(DEFAULT_MTU) - 12 - 8 - 40; // SRTP/UDP/IPv6
+}
 
 #if RTC_ENABLE_MEDIA
 void Track::open(shared_ptr<DtlsSrtpTransport> transport) {

src/impl/track.hpp

@@ -35,9 +35,11 @@
 
 namespace rtc::impl {
 
+struct PeerConnection;
+
 class Track final : public std::enable_shared_from_this<Track>, public Channel {
 public:
-	Track(Description::Media description);
+	Track(weak_ptr<PeerConnection> pc, Description::Media description);
 	~Track() = default;
 
 	void close();
@@ -50,6 +52,7 @@ public:
 
 	bool isOpen() const;
 	bool isClosed() const;
+	size_t maxMessageSize() const;
 
 	string mid() const;
 	Description::Direction direction() const;
@@ -66,6 +69,7 @@ public:
 private:
 	bool transportSend(message_ptr message);
 
+	const weak_ptr<PeerConnection> mPeerConnection;
 #if RTC_ENABLE_MEDIA
 	weak_ptr<DtlsSrtpTransport> mDtlsSrtpTransport;
 #endif

src/nalunit.cpp

@@ -19,6 +19,8 @@
 #if RTC_ENABLE_MEDIA
 
 #include "nalunit.hpp"
+#include "globals.hpp"
+
 #include <cmath>
 
 namespace rtc {
@@ -90,6 +92,8 @@ void NalUnitFragmentA::setFragmentType(FragmentType type) {
 	}
 }
 
+const uint16_t NalUnits::defaultMaximumFragmentSize = DEFAULT_MTU - 12 - 8 - 40; // SRTP/UDP/IPv6
+
 std::vector<std::shared_ptr<binary>> NalUnits::generateFragments(uint16_t maximumFragmentSize) {
 	vector<std::shared_ptr<binary>> result{};
 	for (auto nalu : *this) {

src/track.cpp

@@ -47,7 +47,7 @@ bool Track::isOpen(void) const { return impl()->isOpen(); }
 bool Track::isClosed(void) const { return impl()->isClosed(); }
 
 size_t Track::maxMessageSize() const {
-	return DEFAULT_IPV4_MTU - 12 - 8 - 20; // SRTP/UDP/IPv4
+	return impl()->maxMessageSize();
 }
 
 void Track::setRtcpHandler(std::shared_ptr<MediaHandler> handler) {