| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "net/quic/core/quic_protocol.h" | |
| 6 | |
| 7 #include "base/memory/ptr_util.h" | |
| 8 #include "base/strings/string_number_conversions.h" | |
| 9 #include "net/quic/core/quic_flags.h" | |
| 10 #include "net/quic/core/quic_utils.h" | |
| 11 #include "net/quic/core/quic_versions.h" | |
| 12 | |
| 13 using base::StringPiece; | |
| 14 using std::map; | |
| 15 using std::numeric_limits; | |
| 16 using std::ostream; | |
| 17 using std::string; | |
| 18 | |
| 19 namespace net { | |
| 20 | |
| 21 size_t GetPacketHeaderSize(QuicVersion version, | |
| 22 const QuicPacketHeader& header) { | |
| 23 return GetPacketHeaderSize(version, header.public_header.connection_id_length, | |
| 24 header.public_header.version_flag, | |
| 25 header.public_header.multipath_flag, | |
| 26 header.public_header.nonce != nullptr, | |
| 27 header.public_header.packet_number_length); | |
| 28 } | |
| 29 | |
| 30 size_t GetPacketHeaderSize(QuicVersion version, | |
| 31 QuicConnectionIdLength connection_id_length, | |
| 32 bool include_version, | |
| 33 bool include_path_id, | |
| 34 bool include_diversification_nonce, | |
| 35 QuicPacketNumberLength packet_number_length) { | |
| 36 return kPublicFlagsSize + connection_id_length + | |
| 37 (include_version ? kQuicVersionSize : 0) + | |
| 38 (include_path_id ? kQuicPathIdSize : 0) + packet_number_length + | |
| 39 (include_diversification_nonce ? kDiversificationNonceSize : 0); | |
| 40 } | |
| 41 | |
| 42 size_t GetStartOfEncryptedData(QuicVersion version, | |
| 43 const QuicPacketHeader& header) { | |
| 44 return GetPacketHeaderSize(version, header); | |
| 45 } | |
| 46 | |
| 47 size_t GetStartOfEncryptedData(QuicVersion version, | |
| 48 QuicConnectionIdLength connection_id_length, | |
| 49 bool include_version, | |
| 50 bool include_path_id, | |
| 51 bool include_diversification_nonce, | |
| 52 QuicPacketNumberLength packet_number_length) { | |
| 53 // Encryption starts before private flags. | |
| 54 return GetPacketHeaderSize(version, connection_id_length, include_version, | |
| 55 include_path_id, include_diversification_nonce, | |
| 56 packet_number_length); | |
| 57 } | |
| 58 | |
| 59 QuicPacketPublicHeader::QuicPacketPublicHeader() | |
| 60 : connection_id(0), | |
| 61 connection_id_length(PACKET_8BYTE_CONNECTION_ID), | |
| 62 multipath_flag(false), | |
| 63 reset_flag(false), | |
| 64 version_flag(false), | |
| 65 packet_number_length(PACKET_6BYTE_PACKET_NUMBER), | |
| 66 nonce(nullptr) {} | |
| 67 | |
| 68 QuicPacketPublicHeader::QuicPacketPublicHeader( | |
| 69 const QuicPacketPublicHeader& other) = default; | |
| 70 | |
| 71 QuicPacketPublicHeader::~QuicPacketPublicHeader() {} | |
| 72 | |
| 73 QuicPacketHeader::QuicPacketHeader() | |
| 74 : packet_number(0), path_id(kDefaultPathId) {} | |
| 75 | |
| 76 QuicPacketHeader::QuicPacketHeader(const QuicPacketPublicHeader& header) | |
| 77 : public_header(header), packet_number(0), path_id(kDefaultPathId) {} | |
| 78 | |
| 79 QuicPacketHeader::QuicPacketHeader(const QuicPacketHeader& other) = default; | |
| 80 | |
| 81 QuicPublicResetPacket::QuicPublicResetPacket() | |
| 82 : nonce_proof(0), rejected_packet_number(0) {} | |
| 83 | |
| 84 QuicPublicResetPacket::QuicPublicResetPacket( | |
| 85 const QuicPacketPublicHeader& header) | |
| 86 : public_header(header), nonce_proof(0), rejected_packet_number(0) {} | |
| 87 | |
| 88 ostream& operator<<(ostream& os, const QuicPacketHeader& header) { | |
| 89 os << "{ connection_id: " << header.public_header.connection_id | |
| 90 << ", connection_id_length: " << header.public_header.connection_id_length | |
| 91 << ", packet_number_length: " << header.public_header.packet_number_length | |
| 92 << ", multipath_flag: " << header.public_header.multipath_flag | |
| 93 << ", reset_flag: " << header.public_header.reset_flag | |
| 94 << ", version_flag: " << header.public_header.version_flag; | |
| 95 if (header.public_header.version_flag) { | |
| 96 os << ", version:"; | |
| 97 for (size_t i = 0; i < header.public_header.versions.size(); ++i) { | |
| 98 os << " "; | |
| 99 os << QuicVersionToString(header.public_header.versions[i]); | |
| 100 } | |
| 101 } | |
| 102 if (header.public_header.nonce != nullptr) { | |
| 103 os << ", diversification_nonce: " | |
| 104 << QuicUtils::HexEncode(StringPiece(header.public_header.nonce->data(), | |
| 105 header.public_header.nonce->size())); | |
| 106 } | |
| 107 os << ", path_id: " << static_cast<int>(header.path_id) | |
| 108 << ", packet_number: " << header.packet_number << " }\n"; | |
| 109 return os; | |
| 110 } | |
| 111 | |
| 112 QuicData::QuicData(const char* buffer, size_t length) | |
| 113 : buffer_(buffer), length_(length), owns_buffer_(false) {} | |
| 114 | |
| 115 QuicData::QuicData(const char* buffer, size_t length, bool owns_buffer) | |
| 116 : buffer_(buffer), length_(length), owns_buffer_(owns_buffer) {} | |
| 117 | |
| 118 QuicData::~QuicData() { | |
| 119 if (owns_buffer_) { | |
| 120 delete[] const_cast<char*>(buffer_); | |
| 121 } | |
| 122 } | |
| 123 | |
| 124 QuicPacket::QuicPacket(char* buffer, | |
| 125 size_t length, | |
| 126 bool owns_buffer, | |
| 127 QuicConnectionIdLength connection_id_length, | |
| 128 bool includes_version, | |
| 129 bool includes_path_id, | |
| 130 bool includes_diversification_nonce, | |
| 131 QuicPacketNumberLength packet_number_length) | |
| 132 : QuicData(buffer, length, owns_buffer), | |
| 133 buffer_(buffer), | |
| 134 connection_id_length_(connection_id_length), | |
| 135 includes_version_(includes_version), | |
| 136 includes_path_id_(includes_path_id), | |
| 137 includes_diversification_nonce_(includes_diversification_nonce), | |
| 138 packet_number_length_(packet_number_length) {} | |
| 139 | |
| 140 QuicEncryptedPacket::QuicEncryptedPacket(const char* buffer, size_t length) | |
| 141 : QuicData(buffer, length) {} | |
| 142 | |
| 143 QuicEncryptedPacket::QuicEncryptedPacket(const char* buffer, | |
| 144 size_t length, | |
| 145 bool owns_buffer) | |
| 146 : QuicData(buffer, length, owns_buffer) {} | |
| 147 | |
| 148 std::unique_ptr<QuicEncryptedPacket> QuicEncryptedPacket::Clone() const { | |
| 149 char* buffer = new char[this->length()]; | |
| 150 memcpy(buffer, this->data(), this->length()); | |
| 151 return base::MakeUnique<QuicEncryptedPacket>(buffer, this->length(), true); | |
| 152 } | |
| 153 | |
| 154 ostream& operator<<(ostream& os, const QuicEncryptedPacket& s) { | |
| 155 os << s.length() << "-byte data"; | |
| 156 return os; | |
| 157 } | |
| 158 | |
| 159 QuicReceivedPacket::QuicReceivedPacket(const char* buffer, | |
| 160 size_t length, | |
| 161 QuicTime receipt_time) | |
| 162 : QuicEncryptedPacket(buffer, length), | |
| 163 receipt_time_(receipt_time), | |
| 164 ttl_(0) {} | |
| 165 | |
| 166 QuicReceivedPacket::QuicReceivedPacket(const char* buffer, | |
| 167 size_t length, | |
| 168 QuicTime receipt_time, | |
| 169 bool owns_buffer) | |
| 170 : QuicEncryptedPacket(buffer, length, owns_buffer), | |
| 171 receipt_time_(receipt_time), | |
| 172 ttl_(0) {} | |
| 173 | |
| 174 QuicReceivedPacket::QuicReceivedPacket(const char* buffer, | |
| 175 size_t length, | |
| 176 QuicTime receipt_time, | |
| 177 bool owns_buffer, | |
| 178 int ttl, | |
| 179 bool ttl_valid) | |
| 180 : QuicEncryptedPacket(buffer, length, owns_buffer), | |
| 181 receipt_time_(receipt_time), | |
| 182 ttl_(ttl_valid ? ttl : -1) {} | |
| 183 | |
| 184 std::unique_ptr<QuicReceivedPacket> QuicReceivedPacket::Clone() const { | |
| 185 char* buffer = new char[this->length()]; | |
| 186 memcpy(buffer, this->data(), this->length()); | |
| 187 return base::MakeUnique<QuicReceivedPacket>( | |
| 188 buffer, this->length(), receipt_time(), true, ttl(), ttl() >= 0); | |
| 189 } | |
| 190 | |
| 191 ostream& operator<<(ostream& os, const QuicReceivedPacket& s) { | |
| 192 os << s.length() << "-byte data"; | |
| 193 return os; | |
| 194 } | |
| 195 | |
| 196 StringPiece QuicPacket::AssociatedData(QuicVersion version) const { | |
| 197 return StringPiece( | |
| 198 data(), GetStartOfEncryptedData(version, connection_id_length_, | |
| 199 includes_version_, includes_path_id_, | |
| 200 includes_diversification_nonce_, | |
| 201 packet_number_length_)); | |
| 202 } | |
| 203 | |
| 204 StringPiece QuicPacket::Plaintext(QuicVersion version) const { | |
| 205 const size_t start_of_encrypted_data = GetStartOfEncryptedData( | |
| 206 version, connection_id_length_, includes_version_, includes_path_id_, | |
| 207 includes_diversification_nonce_, packet_number_length_); | |
| 208 return StringPiece(data() + start_of_encrypted_data, | |
| 209 length() - start_of_encrypted_data); | |
| 210 } | |
| 211 | |
| 212 AckListenerWrapper::AckListenerWrapper(QuicAckListenerInterface* listener, | |
| 213 QuicPacketLength data_length) | |
| 214 : ack_listener(listener), length(data_length) { | |
| 215 DCHECK(listener != nullptr); | |
| 216 } | |
| 217 | |
| 218 AckListenerWrapper::AckListenerWrapper(const AckListenerWrapper& other) = | |
| 219 default; | |
| 220 | |
| 221 AckListenerWrapper::~AckListenerWrapper() {} | |
| 222 | |
| 223 SerializedPacket::SerializedPacket(QuicPathId path_id, | |
| 224 QuicPacketNumber packet_number, | |
| 225 QuicPacketNumberLength packet_number_length, | |
| 226 const char* encrypted_buffer, | |
| 227 QuicPacketLength encrypted_length, | |
| 228 bool has_ack, | |
| 229 bool has_stop_waiting) | |
| 230 : encrypted_buffer(encrypted_buffer), | |
| 231 encrypted_length(encrypted_length), | |
| 232 has_crypto_handshake(NOT_HANDSHAKE), | |
| 233 num_padding_bytes(0), | |
| 234 path_id(path_id), | |
| 235 packet_number(packet_number), | |
| 236 packet_number_length(packet_number_length), | |
| 237 encryption_level(ENCRYPTION_NONE), | |
| 238 has_ack(has_ack), | |
| 239 has_stop_waiting(has_stop_waiting), | |
| 240 transmission_type(NOT_RETRANSMISSION), | |
| 241 original_path_id(kInvalidPathId), | |
| 242 original_packet_number(0) {} | |
| 243 | |
| 244 SerializedPacket::SerializedPacket(const SerializedPacket& other) = default; | |
| 245 | |
| 246 SerializedPacket::~SerializedPacket() {} | |
| 247 | |
| 248 TransmissionInfo::TransmissionInfo() | |
| 249 : encryption_level(ENCRYPTION_NONE), | |
| 250 packet_number_length(PACKET_1BYTE_PACKET_NUMBER), | |
| 251 bytes_sent(0), | |
| 252 sent_time(QuicTime::Zero()), | |
| 253 transmission_type(NOT_RETRANSMISSION), | |
| 254 in_flight(false), | |
| 255 is_unackable(false), | |
| 256 has_crypto_handshake(false), | |
| 257 num_padding_bytes(0), | |
| 258 retransmission(0) {} | |
| 259 | |
| 260 void ClearSerializedPacket(SerializedPacket* serialized_packet) { | |
| 261 if (!serialized_packet->retransmittable_frames.empty()) { | |
| 262 DeleteFrames(&serialized_packet->retransmittable_frames); | |
| 263 } | |
| 264 serialized_packet->encrypted_buffer = nullptr; | |
| 265 serialized_packet->encrypted_length = 0; | |
| 266 } | |
| 267 | |
| 268 char* CopyBuffer(const SerializedPacket& packet) { | |
| 269 char* dst_buffer = new char[packet.encrypted_length]; | |
| 270 memcpy(dst_buffer, packet.encrypted_buffer, packet.encrypted_length); | |
| 271 return dst_buffer; | |
| 272 } | |
| 273 | |
| 274 TransmissionInfo::TransmissionInfo(EncryptionLevel level, | |
| 275 QuicPacketNumberLength packet_number_length, | |
| 276 TransmissionType transmission_type, | |
| 277 QuicTime sent_time, | |
| 278 QuicPacketLength bytes_sent, | |
| 279 bool has_crypto_handshake, | |
| 280 int num_padding_bytes) | |
| 281 : encryption_level(level), | |
| 282 packet_number_length(packet_number_length), | |
| 283 bytes_sent(bytes_sent), | |
| 284 sent_time(sent_time), | |
| 285 transmission_type(transmission_type), | |
| 286 in_flight(false), | |
| 287 is_unackable(false), | |
| 288 has_crypto_handshake(has_crypto_handshake), | |
| 289 num_padding_bytes(num_padding_bytes), | |
| 290 retransmission(0) {} | |
| 291 | |
| 292 TransmissionInfo::TransmissionInfo(const TransmissionInfo& other) = default; | |
| 293 | |
| 294 TransmissionInfo::~TransmissionInfo() {} | |
| 295 | |
| 296 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2541673002:
Rename quic_protocol to quic_packets. No behavior change. (Closed)
