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/quic_protocol.h" 6 7 #include "base/stl_util.h" 8 #include "net/quic/quic_utils.h" 9 10 using base::StringPiece; 11 using std::map; 12 using std::numeric_limits; 13 using std::ostream; 14 using std::string; 15 16 namespace net { 17 18 size_t GetPacketHeaderSize(QuicPacketHeader header) { 19 return GetPacketHeaderSize(header.public_header.guid_length, 20 header.public_header.version_flag, 21 header.public_header.sequence_number_length, 22 header.is_in_fec_group); 23 } 24 25 size_t GetPacketHeaderSize(QuicGuidLength guid_length, 26 bool include_version, 27 QuicSequenceNumberLength sequence_number_length, 28 InFecGroup is_in_fec_group) { 29 return kPublicFlagsSize + guid_length + 30 (include_version ? kQuicVersionSize : 0) + sequence_number_length + 31 kPrivateFlagsSize + (is_in_fec_group == IN_FEC_GROUP ? kFecGroupSize : 0); 32 } 33 34 size_t GetPublicResetPacketSize() { 35 return kPublicFlagsSize + PACKET_8BYTE_GUID + kPublicResetNonceSize + 36 PACKET_6BYTE_SEQUENCE_NUMBER; 37 } 38 39 size_t GetStartOfFecProtectedData( 40 QuicGuidLength guid_length, 41 bool include_version, 42 QuicSequenceNumberLength sequence_number_length) { 43 return GetPacketHeaderSize( 44 guid_length, include_version, sequence_number_length, IN_FEC_GROUP); 45 } 46 47 size_t GetStartOfEncryptedData( 48 QuicGuidLength guid_length, 49 bool include_version, 50 QuicSequenceNumberLength sequence_number_length) { 51 // Don't include the fec size, since encryption starts before private flags. 52 return GetPacketHeaderSize( 53 guid_length, include_version, sequence_number_length, NOT_IN_FEC_GROUP) - 54 kPrivateFlagsSize; 55 } 56 57 QuicPacketPublicHeader::QuicPacketPublicHeader() 58 : guid(0), 59 guid_length(PACKET_8BYTE_GUID), 60 reset_flag(false), 61 version_flag(false), 62 sequence_number_length(PACKET_6BYTE_SEQUENCE_NUMBER) { 63 } 64 65 QuicPacketPublicHeader::QuicPacketPublicHeader( 66 const QuicPacketPublicHeader& other) 67 : guid(other.guid), 68 guid_length(other.guid_length), 69 reset_flag(other.reset_flag), 70 version_flag(other.version_flag), 71 sequence_number_length(other.sequence_number_length), 72 versions(other.versions) { 73 } 74 75 QuicPacketPublicHeader::~QuicPacketPublicHeader() {} 76 77 QuicPacketPublicHeader& QuicPacketPublicHeader::operator=( 78 const QuicPacketPublicHeader& other) { 79 guid = other.guid; 80 reset_flag = other.reset_flag; 81 version_flag = other.version_flag; 82 versions = other.versions; 83 return *this; 84 } 85 86 QuicPacketHeader::QuicPacketHeader() 87 : fec_flag(false), 88 entropy_flag(false), 89 entropy_hash(0), 90 packet_sequence_number(0), 91 is_in_fec_group(NOT_IN_FEC_GROUP), 92 fec_group(0) { 93 } 94 95 QuicPacketHeader::QuicPacketHeader(const QuicPacketPublicHeader& header) 96 : public_header(header), 97 fec_flag(false), 98 entropy_flag(false), 99 entropy_hash(0), 100 packet_sequence_number(0), 101 is_in_fec_group(NOT_IN_FEC_GROUP), 102 fec_group(0) { 103 } 104 105 QuicStreamFrame::QuicStreamFrame() {} 106 107 QuicStreamFrame::QuicStreamFrame(QuicStreamId stream_id, 108 bool fin, 109 QuicStreamOffset offset, 110 StringPiece data) 111 : stream_id(stream_id), 112 fin(fin), 113 offset(offset), 114 data(data) { 115 } 116 117 uint32 MakeQuicTag(char a, char b, char c, char d) { 118 return static_cast<uint32>(a) | 119 static_cast<uint32>(b) << 8 | 120 static_cast<uint32>(c) << 16 | 121 static_cast<uint32>(d) << 24; 122 } 123 124 QuicVersion QuicVersionMax() { return kSupportedQuicVersions[0]; } 125 126 QuicVersion QuicVersionMin() { 127 return kSupportedQuicVersions[arraysize(kSupportedQuicVersions) - 1]; 128 } 129 130 QuicTag QuicVersionToQuicTag(const QuicVersion version) { 131 switch (version) { 132 case QUIC_VERSION_7: 133 return MakeQuicTag('Q', '0', '0', '7'); 134 case QUIC_VERSION_8: 135 return MakeQuicTag('Q', '0', '0', '8'); 136 default: 137 // This shold be an ERROR because we should never attempt to convert an 138 // invalid QuicVersion to be written to the wire. 139 LOG(ERROR) << "Unsupported QuicVersion: " << version; 140 return 0; 141 } 142 } 143 144 QuicVersion QuicTagToQuicVersion(const QuicTag version_tag) { 145 const QuicTag quic_tag_v7 = MakeQuicTag('Q', '0', '0', '7'); 146 const QuicTag quic_tag_v8 = MakeQuicTag('Q', '0', '0', '8'); 147 148 if (version_tag == quic_tag_v7) { 149 return QUIC_VERSION_7; 150 } else if (version_tag == quic_tag_v8) { 151 return QUIC_VERSION_8; 152 } else { 153 // Reading from the client so this should not be considered an ERROR. 154 DLOG(INFO) << "Unsupported QuicTag version: " 155 << QuicUtils::TagToString(version_tag); 156 return QUIC_VERSION_UNSUPPORTED; 157 } 158 } 159 160 #define RETURN_STRING_LITERAL(x) \ 161 case x: \ 162 return #x 163 164 string QuicVersionToString(const QuicVersion version) { 165 switch (version) { 166 RETURN_STRING_LITERAL(QUIC_VERSION_7); 167 RETURN_STRING_LITERAL(QUIC_VERSION_8); 168 default: 169 return "QUIC_VERSION_UNSUPPORTED"; 170 } 171 } 172 173 string QuicVersionArrayToString(const QuicVersion versions[], 174 int num_versions) { 175 string result = ""; 176 for (int i = 0; i < num_versions; ++i) { 177 const QuicVersion& version = versions[i]; 178 result.append(QuicVersionToString(version)); 179 result.append(","); 180 } 181 return result; 182 } 183 184 ostream& operator<<(ostream& os, const QuicPacketHeader& header) { 185 os << "{ guid: " << header.public_header.guid 186 << ", guid_length:" << header.public_header.guid_length 187 << ", reset_flag: " << header.public_header.reset_flag 188 << ", version_flag: " << header.public_header.version_flag; 189 if (header.public_header.version_flag) { 190 os << " version: "; 191 for (size_t i = 0; i < header.public_header.versions.size(); ++i) { 192 os << header.public_header.versions[0] << " "; 193 } 194 } 195 os << ", fec_flag: " << header.fec_flag 196 << ", entropy_flag: " << header.entropy_flag 197 << ", entropy hash: " << static_cast<int>(header.entropy_hash) 198 << ", sequence_number: " << header.packet_sequence_number 199 << ", is_in_fec_group:" << header.is_in_fec_group 200 << ", fec_group: " << header.fec_group<< "}\n"; 201 return os; 202 } 203 204 // TODO(ianswett): Initializing largest_observed to 0 should not be necessary. 205 ReceivedPacketInfo::ReceivedPacketInfo() 206 : largest_observed(0), 207 delta_time_largest_observed(QuicTime::Delta::Infinite()) { 208 } 209 210 ReceivedPacketInfo::~ReceivedPacketInfo() {} 211 212 bool IsAwaitingPacket(const ReceivedPacketInfo& received_info, 213 QuicPacketSequenceNumber sequence_number) { 214 return sequence_number > received_info.largest_observed || 215 ContainsKey(received_info.missing_packets, sequence_number); 216 } 217 218 void InsertMissingPacketsBetween(ReceivedPacketInfo* received_info, 219 QuicPacketSequenceNumber lower, 220 QuicPacketSequenceNumber higher) { 221 for (QuicPacketSequenceNumber i = lower; i < higher; ++i) { 222 received_info->missing_packets.insert(i); 223 } 224 } 225 226 SentPacketInfo::SentPacketInfo() {} 227 228 SentPacketInfo::~SentPacketInfo() {} 229 230 // Testing convenience method. 231 QuicAckFrame::QuicAckFrame(QuicPacketSequenceNumber largest_observed, 232 QuicTime largest_observed_receive_time, 233 QuicPacketSequenceNumber least_unacked) { 234 received_info.largest_observed = largest_observed; 235 received_info.entropy_hash = 0; 236 sent_info.least_unacked = least_unacked; 237 sent_info.entropy_hash = 0; 238 } 239 240 ostream& operator<<(ostream& os, const SentPacketInfo& sent_info) { 241 os << "entropy_hash: " << static_cast<int>(sent_info.entropy_hash) 242 << " least_unacked: " << sent_info.least_unacked; 243 return os; 244 } 245 246 ostream& operator<<(ostream& os, const ReceivedPacketInfo& received_info) { 247 os << "entropy_hash: " << static_cast<int>(received_info.entropy_hash) 248 << " largest_observed: " << received_info.largest_observed 249 << " missing_packets: [ "; 250 for (SequenceNumberSet::const_iterator it = 251 received_info.missing_packets.begin(); 252 it != received_info.missing_packets.end(); ++it) { 253 os << *it << " "; 254 } 255 os << " ] "; 256 return os; 257 } 258 259 QuicCongestionFeedbackFrame::QuicCongestionFeedbackFrame() { 260 } 261 262 QuicCongestionFeedbackFrame::~QuicCongestionFeedbackFrame() { 263 } 264 265 ostream& operator<<(ostream& os, 266 const QuicCongestionFeedbackFrame& congestion_frame) { 267 os << "type: " << congestion_frame.type; 268 switch (congestion_frame.type) { 269 case kInterArrival: { 270 const CongestionFeedbackMessageInterArrival& inter_arrival = 271 congestion_frame.inter_arrival; 272 os << " accumulated_number_of_lost_packets: " 273 << inter_arrival.accumulated_number_of_lost_packets; 274 os << " received packets: [ "; 275 for (TimeMap::const_iterator it = 276 inter_arrival.received_packet_times.begin(); 277 it != inter_arrival.received_packet_times.end(); ++it) { 278 os << it->first << "@" << it->second.ToDebuggingValue() << " "; 279 } 280 os << "]"; 281 break; 282 } 283 case kFixRate: { 284 os << " bitrate_in_bytes_per_second: " 285 << congestion_frame.fix_rate.bitrate.ToBytesPerSecond(); 286 break; 287 } 288 case kTCP: { 289 const CongestionFeedbackMessageTCP& tcp = congestion_frame.tcp; 290 os << " accumulated_number_of_lost_packets: " 291 << congestion_frame.tcp.accumulated_number_of_lost_packets; 292 os << " receive_window: " << tcp.receive_window; 293 break; 294 } 295 } 296 return os; 297 } 298 299 ostream& operator<<(ostream& os, const QuicAckFrame& ack_frame) { 300 os << "sent info { " << ack_frame.sent_info << " } " 301 << "received info { " << ack_frame.received_info << " }\n"; 302 return os; 303 } 304 305 CongestionFeedbackMessageFixRate::CongestionFeedbackMessageFixRate() 306 : bitrate(QuicBandwidth::Zero()) { 307 } 308 309 CongestionFeedbackMessageInterArrival:: 310 CongestionFeedbackMessageInterArrival() {} 311 312 CongestionFeedbackMessageInterArrival:: 313 ~CongestionFeedbackMessageInterArrival() {} 314 315 QuicGoAwayFrame::QuicGoAwayFrame(QuicErrorCode error_code, 316 QuicStreamId last_good_stream_id, 317 const string& reason) 318 : error_code(error_code), 319 last_good_stream_id(last_good_stream_id), 320 reason_phrase(reason) { 321 DCHECK_LE(error_code, numeric_limits<uint8>::max()); 322 } 323 324 QuicFecData::QuicFecData() {} 325 326 QuicData::~QuicData() { 327 if (owns_buffer_) { 328 delete [] const_cast<char*>(buffer_); 329 } 330 } 331 332 StringPiece QuicPacket::FecProtectedData() const { 333 const size_t start_of_fec = GetStartOfFecProtectedData( 334 guid_length_, includes_version_, sequence_number_length_); 335 return StringPiece(data() + start_of_fec, length() - start_of_fec); 336 } 337 338 StringPiece QuicPacket::AssociatedData() const { 339 return StringPiece( 340 data() + kStartOfHashData, 341 GetStartOfEncryptedData( 342 guid_length_, includes_version_, sequence_number_length_) - 343 kStartOfHashData); 344 } 345 346 StringPiece QuicPacket::BeforePlaintext() const { 347 return StringPiece(data(), GetStartOfEncryptedData(guid_length_, 348 includes_version_, 349 sequence_number_length_)); 350 } 351 352 StringPiece QuicPacket::Plaintext() const { 353 const size_t start_of_encrypted_data = 354 GetStartOfEncryptedData( 355 guid_length_, includes_version_, sequence_number_length_); 356 return StringPiece(data() + start_of_encrypted_data, 357 length() - start_of_encrypted_data); 358 } 359 360 RetransmittableFrames::RetransmittableFrames() 361 : encryption_level_(NUM_ENCRYPTION_LEVELS) { 362 } 363 364 RetransmittableFrames::~RetransmittableFrames() { 365 for (QuicFrames::iterator it = frames_.begin(); it != frames_.end(); ++it) { 366 switch (it->type) { 367 case PADDING_FRAME: 368 delete it->padding_frame; 369 break; 370 case STREAM_FRAME: 371 delete it->stream_frame; 372 break; 373 case ACK_FRAME: 374 delete it->ack_frame; 375 break; 376 case CONGESTION_FEEDBACK_FRAME: 377 delete it->congestion_feedback_frame; 378 break; 379 case RST_STREAM_FRAME: 380 delete it->rst_stream_frame; 381 break; 382 case CONNECTION_CLOSE_FRAME: 383 delete it->connection_close_frame; 384 break; 385 case GOAWAY_FRAME: 386 delete it->goaway_frame; 387 break; 388 case NUM_FRAME_TYPES: 389 DCHECK(false) << "Cannot delete type: " << it->type; 390 } 391 } 392 STLDeleteElements(&stream_data_); 393 } 394 395 const QuicFrame& RetransmittableFrames::AddStreamFrame( 396 QuicStreamFrame* stream_frame) { 397 // Make an owned copy of the StringPiece. 398 string* stream_data = new string(stream_frame->data.data(), 399 stream_frame->data.size()); 400 // Ensure the frame's StringPiece points to the owned copy of the data. 401 stream_frame->data = StringPiece(*stream_data); 402 stream_data_.push_back(stream_data); 403 frames_.push_back(QuicFrame(stream_frame)); 404 return frames_.back(); 405 } 406 407 const QuicFrame& RetransmittableFrames::AddNonStreamFrame( 408 const QuicFrame& frame) { 409 DCHECK_NE(frame.type, STREAM_FRAME); 410 frames_.push_back(frame); 411 return frames_.back(); 412 } 413 414 void RetransmittableFrames::set_encryption_level(EncryptionLevel level) { 415 encryption_level_ = level; 416 } 417 418 ostream& operator<<(ostream& os, const QuicEncryptedPacket& s) { 419 os << s.length() << "-byte data"; 420 return os; 421 } 422 423 ostream& operator<<(ostream& os, const QuicConsumedData& s) { 424 os << "bytes_consumed: " << s.bytes_consumed 425 << " fin_consumed: " << s.fin_consumed; 426 return os; 427 } 428 429 } // namespace net 430