`max-message-size` is not passed to `sctp-proto`

[haikoschol]

IIUC, str0m hard-codes the SDP attribute a=max-message-size to 256 KB. But in RtcSctp::init(), where a SCTP association is created, sctp_proto::config::TransportConfig::with_max_message_size() is not called. Therefore the SCTP layer actually uses its default value of 64 KB.

I'm far from a SDP expert (or WebRTC in general). Is this a bug or am I missing something?

[haikoschol]

To provide some context, like @thomaseizinger describes in #166, I am also working on a libp2p-webrtc implementation, but in litep2p. I noticed that litep2p does not set max-message-size anywhere and then noticed that str0m does not expose an API for doing so. Thanks to Thomas' example code I now know how to do the SDP munging, but I'm wondering whether it will have any effect on max-message-size.

I started working on a PR to add RtcConfig::set_max_message_size() and propagate this value through the various objects involved, but from discussions in previously closed issues and PRs understand that this is probably not the way to go.

[algesten]

Hi @haikoschol, thanks for reporting this! You're right, it is a problem.

[algesten]

Plan: Fix max-message-size Handling in sctp-proto and str0m

Current Problems

1. str0m advertises a=max-message-size:262144 (256 KB) in SDP but doesn't configure sctp-proto with this value
2. str0m doesn't read/use the remote peer's max-message-size to limit outgoing messages
3. sctp-proto has no receive-side message size enforcement (potential DoS vector)
4. sctp-proto's max_message_size config is only used for send-side validation

SDP Semantics

max-message-size is asymmetric per direction:

• Each peer advertises what they can receive
• Each peer must respect what the remote advertised when sending

Peer	Advertises	Meaning
A	262144	"I can receive up to 256 KB"
B	65536	"I can receive up to 64 KB"

Result: A→B limited to 64 KB, B→A limited to 256 KB

---

Phase 1: sctp-proto Changes

1.1 Add Directional Message Size Limits

File: src/config.rs

Rename and split the config:

pub struct TransportConfig {
    // ... existing fields ...

    /// Maximum message size we will SEND (respects remote's advertised limit)
    /// Can be updated after association creation via set_max_send_message_size()
    max_send_message_size: u32,

    /// Maximum message size we will RECEIVE (what we advertise in SDP)
    /// Enforced during reassembly - messages exceeding this are rejected
    max_receive_message_size: u32,
}

impl Default for TransportConfig {
    fn default() -> Self {
        TransportConfig {
            // ...
            max_send_message_size: DEFAULT_MAX_MESSAGE_SIZE,    // 64 KB
            max_receive_message_size: DEFAULT_MAX_MESSAGE_SIZE, // 64 KB
            // ...
        }
    }
}

impl TransportConfig {
    /// Set maximum size of messages we will send
    pub fn with_max_send_message_size(mut self, value: u32) -> Self {
        self.max_send_message_size = value;
        self
    }

    /// Set maximum size of messages we will accept
    pub fn with_max_receive_message_size(mut self, value: u32) -> Self {
        self.max_receive_message_size = value;
        self
    }

    // Deprecate old method or keep as alias for send
    #[deprecated(note = "Use with_max_send_message_size instead")]
    pub fn with_max_message_size(self, value: u32) -> Self {
        self.with_max_send_message_size(value)
    }
}

1.2 Update Association Struct

File: src/association/mod.rs

pub struct Association {
    // ...
    max_send_message_size: u32,
    max_receive_message_size: u32,
}

impl Association {
    // Getter for send limit (used by Stream::write_source)
    pub(crate) fn max_send_message_size(&self) -> u32 {
        self.max_send_message_size
    }

    // Setter for send limit (called by str0m after SDP negotiation)
    pub fn set_max_send_message_size(&mut self, value: u32) {
        self.max_send_message_size = value;
    }

    // Getter for receive limit (used by ReassemblyQueue)
    pub(crate) fn max_receive_message_size(&self) -> u32 {
        self.max_receive_message_size
    }

    // Deprecation aliases
    #[deprecated(note = "Use max_send_message_size instead")]
    pub(crate) fn max_message_size(&self) -> u32 {
        self.max_send_message_size
    }

    #[deprecated(note = "Use set_max_send_message_size instead")]
    pub fn set_max_message_size(&mut self, value: u32) {
        self.set_max_send_message_size(value)
    }
}

1.3 Update Send Path

File: src/association/stream.rs

Update write_source to use the renamed method:

fn write_source<B: BytesSource>(
    &mut self,
    source: &mut B,
    ppi: PayloadProtocolIdentifier,
) -> Result<usize> {
    // ...
    if source.remaining() > self.association.max_send_message_size() as usize {
        return Err(Error::ErrOutboundPacketTooLarge);
    }
    // ...
}

1.4 Add Receive-Side Enforcement

File: src/queue/reassembly_queue.rs

Add limit checking during reassembly:

#[derive(Default, Debug)]
pub(crate) struct ReassemblyQueue {
    pub(crate) si: StreamId,
    pub(crate) next_ssn: u16,
    pub(crate) ordered: Vec<Chunks>,
    pub(crate) unordered: Vec<Chunks>,
    pub(crate) unordered_chunks: Vec<ChunkPayloadData>,
    pub(crate) n_bytes: usize,
    pub(crate) max_message_size: u32,  // NEW: receive limit
}

impl ReassemblyQueue {
    pub(crate) fn new(si: StreamId, max_message_size: u32) -> Self {
        ReassemblyQueue {
            si,
            next_ssn: 0,
            ordered: vec![],
            unordered: vec![],
            unordered_chunks: vec![],
            n_bytes: 0,
            max_message_size,  // NEW
        }
    }

    pub(crate) fn push(&mut self, chunk: ChunkPayloadData) -> Result<bool, Error> {
        if chunk.stream_identifier != self.si {
            return Ok(false);
        }

        if chunk.unordered {
            // Check if adding this chunk would exceed limit for unordered
            let projected_size = self.calculate_unordered_message_size(&chunk);
            if projected_size > self.max_message_size as usize {
                return Err(Error::ErrInboundPacketTooLarge);
            }

            self.n_bytes += chunk.user_data.len();
            self.unordered_chunks.push(chunk);
            // ... rest of unordered handling
        } else {
            // Check if adding this chunk would exceed limit for ordered
            let projected_size = self.calculate_ordered_message_size(&chunk);
            if projected_size > self.max_message_size as usize {
                return Err(Error::ErrInboundPacketTooLarge);
            }

            self.n_bytes += chunk.user_data.len();
            // ... rest of ordered handling
        }
    }

    // Helper to calculate message size including new chunk
    fn calculate_ordered_message_size(&self, new_chunk: &ChunkPayloadData) -> usize {
        let ssn = new_chunk.stream_sequence_number;
        let existing: usize = self.ordered
            .iter()
            .find(|s| s.ssn == ssn)
            .map(|s| s.len())
            .unwrap_or(0);
        existing + new_chunk.user_data.len()
    }

    fn calculate_unordered_message_size(&self, new_chunk: &ChunkPayloadData) -> usize {
        // For unordered, calculate size of contiguous chunk set this belongs to
        // This is more complex - need to find the message boundary
        // Simplified: sum all unordered chunks + new chunk (conservative)
        self.unordered_chunks.iter().map(|c| c.user_data.len()).sum::<usize>()
            + new_chunk.user_data.len()
    }
}

1.5 Add New Error Type

File: src/error.rs

pub enum Error {
    // ... existing errors ...

    #[error("inbound packet too large")]
    ErrInboundPacketTooLarge,
}

1.6 Update StreamState Creation

File: src/association/stream.rs

Pass the receive limit when creating streams:

impl StreamState {
    pub(crate) fn new(
        side: Side,
        stream_identifier: StreamId,
        max_payload_size: u32,
        max_receive_message_size: u32,  // NEW
        default_payload_type: PayloadProtocolIdentifier,
    ) -> Self {
        StreamState {
            // ...
            reassembly_queue: ReassemblyQueue::new(stream_identifier, max_receive_message_size),
            // ...
        }
    }
}

---

Phase 2: str0m Changes

2.1 Define Constants

File: src/sctp/mod.rs

/// Maximum message size we advertise in SDP (what we can receive)
pub const LOCAL_MAX_MESSAGE_SIZE: u32 = 262144;  // 256 KB

/// Default max message size if remote doesn't advertise
pub const DEFAULT_REMOTE_MAX_MESSAGE_SIZE: u32 = 65536;  // 64 KB

2.2 Update SCTP Initialization

File: src/sctp/mod.rs

Configure sctp-proto with our receive limit:

pub fn init(&mut self, client: bool, now: Instant) {
    // ...

    if client {
        let transport = TransportConfig::default()
            .with_max_init_retransmits(None)
            .with_max_data_retransmits(None)
            .with_max_receive_message_size(LOCAL_MAX_MESSAGE_SIZE);  // NEW
            // Note: send limit set later after SDP negotiation

        let config = ClientConfig {
            transport: Arc::new(transport),
        };
        // ...
    } else {
        // Server config also needs the receive limit
        // ...
    }
}

2.3 Parse Remote's max-message-size from SDP

File: src/sdp/data.rs

Add method to extract max-message-size from MediaLine:

impl MediaLine {
    /// Get the max-message-size attribute value, if present
    pub fn max_message_size(&self) -> Option<usize> {
        self.attrs.iter().find_map(|a| {
            if let MediaAttribute::MaxMessageSize(size) = a {
                Some(*size)
            } else {
                None
            }
        })
    }
}

2.4 Store and Apply Remote's Limit

File: src/sctp/mod.rs

Add field and setter:

pub(crate) struct RtcSctp {
    // ... existing fields ...
    remote_max_message_size: Option<u32>,
}

impl RtcSctp {
    /// Set the remote peer's max-message-size (from SDP)
    /// This limits how large messages we can send
    pub fn set_remote_max_message_size(&mut self, size: u32) {
        self.remote_max_message_size = Some(size);
        if let Some(assoc) = &mut self.assoc {
            assoc.set_max_send_message_size(size);
        }
    }
}

2.5 Apply Limit After SDP Negotiation

File: src/change/sdp.rs

In apply_offer and apply_answer, extract and apply the remote's limit:

fn apply_offer(session: &mut Session, rtc: &mut Rtc, offer: SdpOffer) -> Result<(), RtcError> {
    // ... existing code ...

    // Extract remote's max-message-size from application m-line
    if let Some(app_line) = offer.media_lines.iter().find(|m| m.typ.is_channel()) {
        if let Some(max_size) = app_line.max_message_size() {
            rtc.sctp.set_remote_max_message_size(max_size as u32);
        }
    }

    // ... rest of existing code ...
}

fn apply_answer(session: &mut Session, rtc: &mut Rtc, answer: SdpAnswer) -> Result<(), RtcError> {
    // ... similar extraction ...
}

2.6 Update SDP Generation to Use Constant

File: src/change/sdp.rs

Use the constant instead of hardcoded value:

impl AsSdpMediaLine for (Mid, usize) {
    fn as_media_line(/* ... */) -> MediaLine {
        // ...
        attrs.push(MediaAttribute::MaxMessageSize(
            crate::sctp::LOCAL_MAX_MESSAGE_SIZE as usize
        ));
        // ...
    }
}

---

Phase 3: Testing

3.1 sctp-proto Tests

#[test]
fn test_receive_message_size_limit() {
    // Create association with 1KB receive limit
    let config = TransportConfig::default()
        .with_max_receive_message_size(1024);

    // Attempt to reassemble message larger than 1KB
    // Should return ErrInboundPacketTooLarge
}

#[test]
fn test_send_message_size_limit() {
    // Create association with 1KB send limit
    let config = TransportConfig::default()
        .with_max_send_message_size(1024);

    // Attempt to send message larger than 1KB
    // Should return ErrOutboundPacketTooLarge
}

#[test]
fn test_asymmetric_limits() {
    // Create association with different send/receive limits
    let config = TransportConfig::default()
        .with_max_send_message_size(1024)
        .with_max_receive_message_size(4096);

    // Verify send is limited to 1KB
    // Verify receive accepts up to 4KB
}

3.2 str0m Tests

#[test]
fn test_remote_max_message_size_parsing() {
    // Parse SDP with max-message-size attribute
    // Verify value is extracted correctly
}

#[test]
fn test_remote_max_message_size_applied() {
    // Complete SDP negotiation
    // Verify sctp send limit matches remote's advertised value
}

#[test]
fn test_local_max_message_size_advertised() {
    // Generate SDP offer/answer
    // Verify max-message-size attribute matches LOCAL_MAX_MESSAGE_SIZE
}

---

Migration / Deprecation Strategy

1. sctp-proto 0.x.y (current): Keep max_message_size as-is
2. sctp-proto 0.x.y+1: Add new directional methods, deprecate old ones
3. sctp-proto 0.x+1.0: Remove deprecated methods (breaking change)

For str0m, coordinate the version bump with sctp-proto changes.

---

Summary Checklist

sctp-proto

• Split max_message_size into max_send_message_size and max_receive_message_size
• Add receive-side enforcement in ReassemblyQueue
• Add ErrInboundPacketTooLarge error
• Update Stream::write_source to use max_send_message_size
• Add deprecation warnings for old API
• Add tests for both directions
• Update documentation

str0m

• Define LOCAL_MAX_MESSAGE_SIZE constant (256 KB)
• Configure sctp-proto with receive limit on init
• Parse remote's max-message-size from SDP offer/answer
• Apply remote's limit via set_max_send_message_size
• Update SDP generation to use constant
• Add tests for SDP parsing and limit application
• Update documentation

[haikoschol]

Hi @algesten, thanks for the very comprehensive answer! Looks like you already did 80% of the work. I'd be happy to take a crack at doing the other 80%. :)

[algesten]

@haikoschol sure go ahead! :)

[haikoschol]

@haikoschol sure go ahead! :)

Phase 1: algesten/sctp-proto#27

Phase 2: #852

The latter needs at least one more update to switch back to a (future) sctp-proto release.

I hope this is what you had in mind and we can get it reviewed and merged soon, but there is one more thing I need for the libp2p-webrtc use case.

I spoke too soon when I wrote in a comment above that I understood how to set max-message-size in litep2p. In the meantime, I've realized that, following the changes in #324, litep2p uses the DirectApi instead of SDP and the two shall not be mixed. Therefore we would need to add setters for local and remote max-message-size to DirectApi.

I read in a few issue discussions that you are not too keen on increasing API surface (understandably so), which is what I was referring to when I wrote

I started working on a PR to add RtcConfig::set_max_message_size() and propagate this value through the various objects involved, but from discussions in previously closed issues and PRs understand that this is probably not the way to go.

Buuut... would you be ok with adding just these tiny two setters, either in #852 or a subsequent PR? 🥺