| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * Copyright 2013 The WebRTC project authors. All Rights Reserved. | |
| 3 * | |
| 4 * Use of this source code is governed by a BSD-style license | |
| 5 * that can be found in the LICENSE file in the root of the source | |
| 6 * tree. An additional intellectual property rights grant can be found | |
| 7 * in the file PATENTS. All contributing project authors may | |
| 8 * be found in the AUTHORS file in the root of the source tree. | |
| 9 */ | |
| 10 | |
| 11 #include "webrtc/api/sctputils.h" | |
| 12 | |
| 13 #include "webrtc/base/bytebuffer.h" | |
| 14 #include "webrtc/base/copyonwritebuffer.h" | |
| 15 #include "webrtc/base/logging.h" | |
| 16 | |
| 17 namespace webrtc { | |
| 18 | |
| 19 // Format defined at | |
| 20 // http://tools.ietf.org/html/draft-ietf-rtcweb-data-protocol-01#section | |
| 21 | |
| 22 static const uint8_t DATA_CHANNEL_OPEN_MESSAGE_TYPE = 0x03; | |
| 23 static const uint8_t DATA_CHANNEL_OPEN_ACK_MESSAGE_TYPE = 0x02; | |
| 24 | |
| 25 enum DataChannelOpenMessageChannelType { | |
| 26 DCOMCT_ORDERED_RELIABLE = 0x00, | |
| 27 DCOMCT_ORDERED_PARTIAL_RTXS = 0x01, | |
| 28 DCOMCT_ORDERED_PARTIAL_TIME = 0x02, | |
| 29 DCOMCT_UNORDERED_RELIABLE = 0x80, | |
| 30 DCOMCT_UNORDERED_PARTIAL_RTXS = 0x81, | |
| 31 DCOMCT_UNORDERED_PARTIAL_TIME = 0x82, | |
| 32 }; | |
| 33 | |
| 34 bool IsOpenMessage(const rtc::CopyOnWriteBuffer& payload) { | |
| 35 // Format defined at | |
| 36 // http://tools.ietf.org/html/draft-jesup-rtcweb-data-protocol-04 | |
| 37 if (payload.size() < 1) { | |
| 38 LOG(LS_WARNING) << "Could not read OPEN message type."; | |
| 39 return false; | |
| 40 } | |
| 41 | |
| 42 uint8_t message_type = payload[0]; | |
| 43 return message_type == DATA_CHANNEL_OPEN_MESSAGE_TYPE; | |
| 44 } | |
| 45 | |
| 46 bool ParseDataChannelOpenMessage(const rtc::CopyOnWriteBuffer& payload, | |
| 47 std::string* label, | |
| 48 DataChannelInit* config) { | |
| 49 // Format defined at | |
| 50 // http://tools.ietf.org/html/draft-jesup-rtcweb-data-protocol-04 | |
| 51 | |
| 52 rtc::ByteBufferReader buffer(payload.data<char>(), payload.size()); | |
| 53 uint8_t message_type; | |
| 54 if (!buffer.ReadUInt8(&message_type)) { | |
| 55 LOG(LS_WARNING) << "Could not read OPEN message type."; | |
| 56 return false; | |
| 57 } | |
| 58 if (message_type != DATA_CHANNEL_OPEN_MESSAGE_TYPE) { | |
| 59 LOG(LS_WARNING) << "Data Channel OPEN message of unexpected type: " | |
| 60 << message_type; | |
| 61 return false; | |
| 62 } | |
| 63 | |
| 64 uint8_t channel_type; | |
| 65 if (!buffer.ReadUInt8(&channel_type)) { | |
| 66 LOG(LS_WARNING) << "Could not read OPEN message channel type."; | |
| 67 return false; | |
| 68 } | |
| 69 | |
| 70 uint16_t priority; | |
| 71 if (!buffer.ReadUInt16(&priority)) { | |
| 72 LOG(LS_WARNING) << "Could not read OPEN message reliabilility prioirty."; | |
| 73 return false; | |
| 74 } | |
| 75 uint32_t reliability_param; | |
| 76 if (!buffer.ReadUInt32(&reliability_param)) { | |
| 77 LOG(LS_WARNING) << "Could not read OPEN message reliabilility param."; | |
| 78 return false; | |
| 79 } | |
| 80 uint16_t label_length; | |
| 81 if (!buffer.ReadUInt16(&label_length)) { | |
| 82 LOG(LS_WARNING) << "Could not read OPEN message label length."; | |
| 83 return false; | |
| 84 } | |
| 85 uint16_t protocol_length; | |
| 86 if (!buffer.ReadUInt16(&protocol_length)) { | |
| 87 LOG(LS_WARNING) << "Could not read OPEN message protocol length."; | |
| 88 return false; | |
| 89 } | |
| 90 if (!buffer.ReadString(label, (size_t) label_length)) { | |
| 91 LOG(LS_WARNING) << "Could not read OPEN message label"; | |
| 92 return false; | |
| 93 } | |
| 94 if (!buffer.ReadString(&config->protocol, protocol_length)) { | |
| 95 LOG(LS_WARNING) << "Could not read OPEN message protocol."; | |
| 96 return false; | |
| 97 } | |
| 98 | |
| 99 config->ordered = true; | |
| 100 switch (channel_type) { | |
| 101 case DCOMCT_UNORDERED_RELIABLE: | |
| 102 case DCOMCT_UNORDERED_PARTIAL_RTXS: | |
| 103 case DCOMCT_UNORDERED_PARTIAL_TIME: | |
| 104 config->ordered = false; | |
| 105 } | |
| 106 | |
| 107 config->maxRetransmits = -1; | |
| 108 config->maxRetransmitTime = -1; | |
| 109 switch (channel_type) { | |
| 110 case DCOMCT_ORDERED_PARTIAL_RTXS: | |
| 111 case DCOMCT_UNORDERED_PARTIAL_RTXS: | |
| 112 config->maxRetransmits = reliability_param; | |
| 113 break; | |
| 114 case DCOMCT_ORDERED_PARTIAL_TIME: | |
| 115 case DCOMCT_UNORDERED_PARTIAL_TIME: | |
| 116 config->maxRetransmitTime = reliability_param; | |
| 117 break; | |
| 118 } | |
| 119 return true; | |
| 120 } | |
| 121 | |
| 122 bool ParseDataChannelOpenAckMessage(const rtc::CopyOnWriteBuffer& payload) { | |
| 123 if (payload.size() < 1) { | |
| 124 LOG(LS_WARNING) << "Could not read OPEN_ACK message type."; | |
| 125 return false; | |
| 126 } | |
| 127 | |
| 128 uint8_t message_type = payload[0]; | |
| 129 if (message_type != DATA_CHANNEL_OPEN_ACK_MESSAGE_TYPE) { | |
| 130 LOG(LS_WARNING) << "Data Channel OPEN_ACK message of unexpected type: " | |
| 131 << message_type; | |
| 132 return false; | |
| 133 } | |
| 134 return true; | |
| 135 } | |
| 136 | |
| 137 bool WriteDataChannelOpenMessage(const std::string& label, | |
| 138 const DataChannelInit& config, | |
| 139 rtc::CopyOnWriteBuffer* payload) { | |
| 140 // Format defined at | |
| 141 // http://tools.ietf.org/html/draft-ietf-rtcweb-data-protocol-00#section-6.1 | |
| 142 uint8_t channel_type = 0; | |
| 143 uint32_t reliability_param = 0; | |
| 144 uint16_t priority = 0; | |
| 145 if (config.ordered) { | |
| 146 if (config.maxRetransmits > -1) { | |
| 147 channel_type = DCOMCT_ORDERED_PARTIAL_RTXS; | |
| 148 reliability_param = config.maxRetransmits; | |
| 149 } else if (config.maxRetransmitTime > -1) { | |
| 150 channel_type = DCOMCT_ORDERED_PARTIAL_TIME; | |
| 151 reliability_param = config.maxRetransmitTime; | |
| 152 } else { | |
| 153 channel_type = DCOMCT_ORDERED_RELIABLE; | |
| 154 } | |
| 155 } else { | |
| 156 if (config.maxRetransmits > -1) { | |
| 157 channel_type = DCOMCT_UNORDERED_PARTIAL_RTXS; | |
| 158 reliability_param = config.maxRetransmits; | |
| 159 } else if (config.maxRetransmitTime > -1) { | |
| 160 channel_type = DCOMCT_UNORDERED_PARTIAL_TIME; | |
| 161 reliability_param = config.maxRetransmitTime; | |
| 162 } else { | |
| 163 channel_type = DCOMCT_UNORDERED_RELIABLE; | |
| 164 } | |
| 165 } | |
| 166 | |
| 167 rtc::ByteBufferWriter buffer( | |
| 168 NULL, 20 + label.length() + config.protocol.length(), | |
| 169 rtc::ByteBuffer::ORDER_NETWORK); | |
| 170 // TODO(tommi): Add error handling and check resulting length. | |
| 171 buffer.WriteUInt8(DATA_CHANNEL_OPEN_MESSAGE_TYPE); | |
| 172 buffer.WriteUInt8(channel_type); | |
| 173 buffer.WriteUInt16(priority); | |
| 174 buffer.WriteUInt32(reliability_param); | |
| 175 buffer.WriteUInt16(static_cast<uint16_t>(label.length())); | |
| 176 buffer.WriteUInt16(static_cast<uint16_t>(config.protocol.length())); | |
| 177 buffer.WriteString(label); | |
| 178 buffer.WriteString(config.protocol); | |
| 179 payload->SetData(buffer.Data(), buffer.Length()); | |
| 180 return true; | |
| 181 } | |
| 182 | |
| 183 void WriteDataChannelOpenAckMessage(rtc::CopyOnWriteBuffer* payload) { | |
| 184 uint8_t data = DATA_CHANNEL_OPEN_ACK_MESSAGE_TYPE; | |
| 185 payload->SetData(&data, sizeof(data)); | |
| 186 } | |
| 187 | |
| 188 } // namespace webrtc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2514883002:
Create //webrtc/api:libjingle_peerconnection_api + refactorings. (Closed)
