From 6bf0a5cb5034a7e684dcc3500e841785237ce2dd Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 19:32:43 +0200 Subject: Adding upstream version 1:115.7.0. Signed-off-by: Daniel Baumann --- third_party/libwebrtc/pc/sctp_utils.cc | 233 +++++++++++++++++++++++++++++++++ 1 file changed, 233 insertions(+) create mode 100644 third_party/libwebrtc/pc/sctp_utils.cc (limited to 'third_party/libwebrtc/pc/sctp_utils.cc') diff --git a/third_party/libwebrtc/pc/sctp_utils.cc b/third_party/libwebrtc/pc/sctp_utils.cc new file mode 100644 index 0000000000..c60e339b08 --- /dev/null +++ b/third_party/libwebrtc/pc/sctp_utils.cc @@ -0,0 +1,233 @@ +/* + * Copyright 2013 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "pc/sctp_utils.h" + +#include + +#include + +#include "absl/types/optional.h" +#include "api/priority.h" +#include "rtc_base/byte_buffer.h" +#include "rtc_base/copy_on_write_buffer.h" +#include "rtc_base/logging.h" + +namespace webrtc { + +// Format defined at +// http://tools.ietf.org/html/draft-ietf-rtcweb-data-protocol-01#section + +static const uint8_t DATA_CHANNEL_OPEN_MESSAGE_TYPE = 0x03; +static const uint8_t DATA_CHANNEL_OPEN_ACK_MESSAGE_TYPE = 0x02; + +enum DataChannelOpenMessageChannelType { + DCOMCT_ORDERED_RELIABLE = 0x00, + DCOMCT_ORDERED_PARTIAL_RTXS = 0x01, + DCOMCT_ORDERED_PARTIAL_TIME = 0x02, + DCOMCT_UNORDERED_RELIABLE = 0x80, + DCOMCT_UNORDERED_PARTIAL_RTXS = 0x81, + DCOMCT_UNORDERED_PARTIAL_TIME = 0x82, +}; + +// Values of priority in the DC open protocol message. +// These are compared against an integer, so are enum, not enum class. +enum DataChannelPriority { + DCO_PRIORITY_VERY_LOW = 128, + DCO_PRIORITY_LOW = 256, + DCO_PRIORITY_MEDIUM = 512, + DCO_PRIORITY_HIGH = 1024, +}; + +bool IsOpenMessage(const rtc::CopyOnWriteBuffer& payload) { + // Format defined at + // http://tools.ietf.org/html/draft-jesup-rtcweb-data-protocol-04 + if (payload.size() < 1) { + RTC_LOG(LS_WARNING) << "Could not read OPEN message type."; + return false; + } + + uint8_t message_type = payload[0]; + return message_type == DATA_CHANNEL_OPEN_MESSAGE_TYPE; +} + +bool ParseDataChannelOpenMessage(const rtc::CopyOnWriteBuffer& payload, + std::string* label, + DataChannelInit* config) { + // Format defined at + // http://tools.ietf.org/html/draft-jesup-rtcweb-data-protocol-04 + + rtc::ByteBufferReader buffer(payload.data(), payload.size()); + uint8_t message_type; + if (!buffer.ReadUInt8(&message_type)) { + RTC_LOG(LS_WARNING) << "Could not read OPEN message type."; + return false; + } + if (message_type != DATA_CHANNEL_OPEN_MESSAGE_TYPE) { + RTC_LOG(LS_WARNING) << "Data Channel OPEN message of unexpected type: " + << message_type; + return false; + } + + uint8_t channel_type; + if (!buffer.ReadUInt8(&channel_type)) { + RTC_LOG(LS_WARNING) << "Could not read OPEN message channel type."; + return false; + } + + uint16_t priority; + if (!buffer.ReadUInt16(&priority)) { + RTC_LOG(LS_WARNING) + << "Could not read OPEN message reliabilility prioirty."; + return false; + } + // Parse priority as defined in + // https://w3c.github.io/webrtc-priority/#rtcdatachannel-processing-steps + if (priority <= DCO_PRIORITY_VERY_LOW) { + config->priority = Priority::kVeryLow; + } else if (priority <= DCO_PRIORITY_LOW) { + config->priority = Priority::kLow; + } else if (priority <= DCO_PRIORITY_MEDIUM) { + config->priority = Priority::kMedium; + } else { + config->priority = Priority::kHigh; + } + + uint32_t reliability_param; + if (!buffer.ReadUInt32(&reliability_param)) { + RTC_LOG(LS_WARNING) << "Could not read OPEN message reliabilility param."; + return false; + } + uint16_t label_length; + if (!buffer.ReadUInt16(&label_length)) { + RTC_LOG(LS_WARNING) << "Could not read OPEN message label length."; + return false; + } + uint16_t protocol_length; + if (!buffer.ReadUInt16(&protocol_length)) { + RTC_LOG(LS_WARNING) << "Could not read OPEN message protocol length."; + return false; + } + if (!buffer.ReadString(label, (size_t)label_length)) { + RTC_LOG(LS_WARNING) << "Could not read OPEN message label"; + return false; + } + if (!buffer.ReadString(&config->protocol, protocol_length)) { + RTC_LOG(LS_WARNING) << "Could not read OPEN message protocol."; + return false; + } + + config->ordered = true; + switch (channel_type) { + case DCOMCT_UNORDERED_RELIABLE: + case DCOMCT_UNORDERED_PARTIAL_RTXS: + case DCOMCT_UNORDERED_PARTIAL_TIME: + config->ordered = false; + } + + config->maxRetransmits = absl::nullopt; + config->maxRetransmitTime = absl::nullopt; + switch (channel_type) { + case DCOMCT_ORDERED_PARTIAL_RTXS: + case DCOMCT_UNORDERED_PARTIAL_RTXS: + config->maxRetransmits = reliability_param; + break; + case DCOMCT_ORDERED_PARTIAL_TIME: + case DCOMCT_UNORDERED_PARTIAL_TIME: + config->maxRetransmitTime = reliability_param; + break; + } + return true; +} + +bool ParseDataChannelOpenAckMessage(const rtc::CopyOnWriteBuffer& payload) { + if (payload.size() < 1) { + RTC_LOG(LS_WARNING) << "Could not read OPEN_ACK message type."; + return false; + } + + uint8_t message_type = payload[0]; + if (message_type != DATA_CHANNEL_OPEN_ACK_MESSAGE_TYPE) { + RTC_LOG(LS_WARNING) << "Data Channel OPEN_ACK message of unexpected type: " + << message_type; + return false; + } + return true; +} + +bool WriteDataChannelOpenMessage(const std::string& label, + const DataChannelInit& config, + rtc::CopyOnWriteBuffer* payload) { + // Format defined at + // http://tools.ietf.org/html/draft-ietf-rtcweb-data-protocol-09#section-5.1 + uint8_t channel_type = 0; + uint32_t reliability_param = 0; + uint16_t priority = 0; + // Set priority according to + // https://tools.ietf.org/html/draft-ietf-rtcweb-data-channel-12#section-6.4 + if (config.priority) { + switch (*config.priority) { + case Priority::kVeryLow: + priority = DCO_PRIORITY_VERY_LOW; + break; + case Priority::kLow: + priority = DCO_PRIORITY_LOW; + break; + case Priority::kMedium: + priority = DCO_PRIORITY_MEDIUM; + break; + case Priority::kHigh: + priority = DCO_PRIORITY_HIGH; + break; + } + } + if (config.ordered) { + if (config.maxRetransmits) { + channel_type = DCOMCT_ORDERED_PARTIAL_RTXS; + reliability_param = *config.maxRetransmits; + } else if (config.maxRetransmitTime) { + channel_type = DCOMCT_ORDERED_PARTIAL_TIME; + reliability_param = *config.maxRetransmitTime; + } else { + channel_type = DCOMCT_ORDERED_RELIABLE; + } + } else { + if (config.maxRetransmits) { + channel_type = DCOMCT_UNORDERED_PARTIAL_RTXS; + reliability_param = *config.maxRetransmits; + } else if (config.maxRetransmitTime) { + channel_type = DCOMCT_UNORDERED_PARTIAL_TIME; + reliability_param = *config.maxRetransmitTime; + } else { + channel_type = DCOMCT_UNORDERED_RELIABLE; + } + } + + rtc::ByteBufferWriter buffer(NULL, + 20 + label.length() + config.protocol.length()); + // TODO(tommi): Add error handling and check resulting length. + buffer.WriteUInt8(DATA_CHANNEL_OPEN_MESSAGE_TYPE); + buffer.WriteUInt8(channel_type); + buffer.WriteUInt16(priority); + buffer.WriteUInt32(reliability_param); + buffer.WriteUInt16(static_cast(label.length())); + buffer.WriteUInt16(static_cast(config.protocol.length())); + buffer.WriteString(label); + buffer.WriteString(config.protocol); + payload->SetData(buffer.Data(), buffer.Length()); + return true; +} + +void WriteDataChannelOpenAckMessage(rtc::CopyOnWriteBuffer* payload) { + uint8_t data = DATA_CHANNEL_OPEN_ACK_MESSAGE_TYPE; + payload->SetData(&data, sizeof(data)); +} + +} // namespace webrtc -- cgit v1.2.3