| // Copyright 2014 The Chromium Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| #include "quic/core/quic_types.h" | |
| #include <cstdint> | |
| #include "absl/strings/str_cat.h" | |
| #include "quic/core/quic_error_codes.h" | |
| #include "common/print_elements.h" | |
| namespace quic { | |
| static_assert(sizeof(StatelessResetToken) == kStatelessResetTokenLength, | |
| "bad size"); | |
| std::ostream& operator<<(std::ostream& os, const QuicConsumedData& s) { | |
| os << "bytes_consumed: " << s.bytes_consumed | |
| << " fin_consumed: " << s.fin_consumed; | |
| return os; | |
| } | |
| std::string PerspectiveToString(Perspective perspective) { | |
| if (perspective == Perspective::IS_SERVER) { | |
| return "IS_SERVER"; | |
| } | |
| if (perspective == Perspective::IS_CLIENT) { | |
| return "IS_CLIENT"; | |
| } | |
| return absl::StrCat("Unknown(", static_cast<int>(perspective), ")"); | |
| } | |
| std::ostream& operator<<(std::ostream& os, const Perspective& perspective) { | |
| os << PerspectiveToString(perspective); | |
| return os; | |
| } | |
| std::string ConnectionCloseSourceToString( | |
| ConnectionCloseSource connection_close_source) { | |
| if (connection_close_source == ConnectionCloseSource::FROM_PEER) { | |
| return "FROM_PEER"; | |
| } | |
| if (connection_close_source == ConnectionCloseSource::FROM_SELF) { | |
| return "FROM_SELF"; | |
| } | |
| return absl::StrCat("Unknown(", static_cast<int>(connection_close_source), | |
| ")"); | |
| } | |
| std::ostream& operator<<(std::ostream& os, | |
| const ConnectionCloseSource& connection_close_source) { | |
| os << ConnectionCloseSourceToString(connection_close_source); | |
| return os; | |
| } | |
| std::string ConnectionCloseBehaviorToString( | |
| ConnectionCloseBehavior connection_close_behavior) { | |
| if (connection_close_behavior == ConnectionCloseBehavior::SILENT_CLOSE) { | |
| return "SILENT_CLOSE"; | |
| } | |
| if (connection_close_behavior == | |
| ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET) { | |
| return "SEND_CONNECTION_CLOSE_PACKET"; | |
| } | |
| return absl::StrCat("Unknown(", static_cast<int>(connection_close_behavior), | |
| ")"); | |
| } | |
| std::ostream& operator<<( | |
| std::ostream& os, | |
| const ConnectionCloseBehavior& connection_close_behavior) { | |
| os << ConnectionCloseBehaviorToString(connection_close_behavior); | |
| return os; | |
| } | |
| std::ostream& operator<<(std::ostream& os, const AckedPacket& acked_packet) { | |
| os << "{ packet_number: " << acked_packet.packet_number | |
| << ", bytes_acked: " << acked_packet.bytes_acked << ", receive_timestamp: " | |
| << acked_packet.receive_timestamp.ToDebuggingValue() << "} "; | |
| return os; | |
| } | |
| std::ostream& operator<<(std::ostream& os, const LostPacket& lost_packet) { | |
| os << "{ packet_number: " << lost_packet.packet_number | |
| << ", bytes_lost: " << lost_packet.bytes_lost << "} "; | |
| return os; | |
| } | |
| std::string HistogramEnumString(WriteStatus enum_value) { | |
| switch (enum_value) { | |
| case WRITE_STATUS_OK: | |
| return "OK"; | |
| case WRITE_STATUS_BLOCKED: | |
| return "BLOCKED"; | |
| case WRITE_STATUS_BLOCKED_DATA_BUFFERED: | |
| return "BLOCKED_DATA_BUFFERED"; | |
| case WRITE_STATUS_ERROR: | |
| return "ERROR"; | |
| case WRITE_STATUS_MSG_TOO_BIG: | |
| return "MSG_TOO_BIG"; | |
| case WRITE_STATUS_FAILED_TO_COALESCE_PACKET: | |
| return "WRITE_STATUS_FAILED_TO_COALESCE_PACKET"; | |
| case WRITE_STATUS_NUM_VALUES: | |
| return "NUM_VALUES"; | |
| } | |
| QUIC_DLOG(ERROR) << "Invalid WriteStatus value: " | |
| << static_cast<int16_t>(enum_value); | |
| return "<invalid>"; | |
| } | |
| std::ostream& operator<<(std::ostream& os, const WriteStatus& status) { | |
| os << HistogramEnumString(status); | |
| return os; | |
| } | |
| std::ostream& operator<<(std::ostream& os, const WriteResult& s) { | |
| os << "{ status: " << s.status; | |
| if (s.status == WRITE_STATUS_OK) { | |
| os << ", bytes_written: " << s.bytes_written; | |
| } else { | |
| os << ", error_code: " << s.error_code; | |
| } | |
| os << " }"; | |
| return os; | |
| } | |
| MessageResult::MessageResult(MessageStatus status, QuicMessageId message_id) | |
| : status(status), message_id(message_id) {} | |
| #define RETURN_STRING_LITERAL(x) \ | |
| case x: \ | |
| return #x; | |
| std::string QuicFrameTypeToString(QuicFrameType t) { | |
| switch (t) { | |
| RETURN_STRING_LITERAL(PADDING_FRAME) | |
| RETURN_STRING_LITERAL(RST_STREAM_FRAME) | |
| RETURN_STRING_LITERAL(CONNECTION_CLOSE_FRAME) | |
| RETURN_STRING_LITERAL(GOAWAY_FRAME) | |
| RETURN_STRING_LITERAL(WINDOW_UPDATE_FRAME) | |
| RETURN_STRING_LITERAL(BLOCKED_FRAME) | |
| RETURN_STRING_LITERAL(STOP_WAITING_FRAME) | |
| RETURN_STRING_LITERAL(PING_FRAME) | |
| RETURN_STRING_LITERAL(CRYPTO_FRAME) | |
| RETURN_STRING_LITERAL(HANDSHAKE_DONE_FRAME) | |
| RETURN_STRING_LITERAL(STREAM_FRAME) | |
| RETURN_STRING_LITERAL(ACK_FRAME) | |
| RETURN_STRING_LITERAL(MTU_DISCOVERY_FRAME) | |
| RETURN_STRING_LITERAL(NEW_CONNECTION_ID_FRAME) | |
| RETURN_STRING_LITERAL(MAX_STREAMS_FRAME) | |
| RETURN_STRING_LITERAL(STREAMS_BLOCKED_FRAME) | |
| RETURN_STRING_LITERAL(PATH_RESPONSE_FRAME) | |
| RETURN_STRING_LITERAL(PATH_CHALLENGE_FRAME) | |
| RETURN_STRING_LITERAL(STOP_SENDING_FRAME) | |
| RETURN_STRING_LITERAL(MESSAGE_FRAME) | |
| RETURN_STRING_LITERAL(NEW_TOKEN_FRAME) | |
| RETURN_STRING_LITERAL(RETIRE_CONNECTION_ID_FRAME) | |
| RETURN_STRING_LITERAL(ACK_FREQUENCY_FRAME) | |
| RETURN_STRING_LITERAL(NUM_FRAME_TYPES) | |
| } | |
| return absl::StrCat("Unknown(", static_cast<int>(t), ")"); | |
| } | |
| std::ostream& operator<<(std::ostream& os, const QuicFrameType& t) { | |
| os << QuicFrameTypeToString(t); | |
| return os; | |
| } | |
| std::string QuicIetfFrameTypeString(QuicIetfFrameType t) { | |
| if (IS_IETF_STREAM_FRAME(t)) { | |
| return "IETF_STREAM"; | |
| } | |
| switch (t) { | |
| RETURN_STRING_LITERAL(IETF_PADDING); | |
| RETURN_STRING_LITERAL(IETF_PING); | |
| RETURN_STRING_LITERAL(IETF_ACK); | |
| RETURN_STRING_LITERAL(IETF_ACK_ECN); | |
| RETURN_STRING_LITERAL(IETF_RST_STREAM); | |
| RETURN_STRING_LITERAL(IETF_STOP_SENDING); | |
| RETURN_STRING_LITERAL(IETF_CRYPTO); | |
| RETURN_STRING_LITERAL(IETF_NEW_TOKEN); | |
| RETURN_STRING_LITERAL(IETF_MAX_DATA); | |
| RETURN_STRING_LITERAL(IETF_MAX_STREAM_DATA); | |
| RETURN_STRING_LITERAL(IETF_MAX_STREAMS_BIDIRECTIONAL); | |
| RETURN_STRING_LITERAL(IETF_MAX_STREAMS_UNIDIRECTIONAL); | |
| RETURN_STRING_LITERAL(IETF_DATA_BLOCKED); | |
| RETURN_STRING_LITERAL(IETF_STREAM_DATA_BLOCKED); | |
| RETURN_STRING_LITERAL(IETF_STREAMS_BLOCKED_BIDIRECTIONAL); | |
| RETURN_STRING_LITERAL(IETF_STREAMS_BLOCKED_UNIDIRECTIONAL); | |
| RETURN_STRING_LITERAL(IETF_NEW_CONNECTION_ID); | |
| RETURN_STRING_LITERAL(IETF_RETIRE_CONNECTION_ID); | |
| RETURN_STRING_LITERAL(IETF_PATH_CHALLENGE); | |
| RETURN_STRING_LITERAL(IETF_PATH_RESPONSE); | |
| RETURN_STRING_LITERAL(IETF_CONNECTION_CLOSE); | |
| RETURN_STRING_LITERAL(IETF_APPLICATION_CLOSE); | |
| RETURN_STRING_LITERAL(IETF_EXTENSION_MESSAGE_NO_LENGTH); | |
| RETURN_STRING_LITERAL(IETF_EXTENSION_MESSAGE); | |
| RETURN_STRING_LITERAL(IETF_EXTENSION_MESSAGE_NO_LENGTH_V99); | |
| RETURN_STRING_LITERAL(IETF_EXTENSION_MESSAGE_V99); | |
| default: | |
| return absl::StrCat("Private value (", t, ")"); | |
| } | |
| } | |
| std::ostream& operator<<(std::ostream& os, const QuicIetfFrameType& c) { | |
| os << QuicIetfFrameTypeString(c); | |
| return os; | |
| } | |
| std::string TransmissionTypeToString(TransmissionType transmission_type) { | |
| switch (transmission_type) { | |
| RETURN_STRING_LITERAL(NOT_RETRANSMISSION); | |
| RETURN_STRING_LITERAL(HANDSHAKE_RETRANSMISSION); | |
| RETURN_STRING_LITERAL(ALL_ZERO_RTT_RETRANSMISSION); | |
| RETURN_STRING_LITERAL(LOSS_RETRANSMISSION); | |
| RETURN_STRING_LITERAL(RTO_RETRANSMISSION); | |
| RETURN_STRING_LITERAL(TLP_RETRANSMISSION); | |
| RETURN_STRING_LITERAL(PTO_RETRANSMISSION); | |
| RETURN_STRING_LITERAL(PROBING_RETRANSMISSION); | |
| RETURN_STRING_LITERAL(PATH_RETRANSMISSION); | |
| RETURN_STRING_LITERAL(ALL_INITIAL_RETRANSMISSION); | |
| default: | |
| // Some varz rely on this behavior for statistic collection. | |
| if (transmission_type == LAST_TRANSMISSION_TYPE + 1) { | |
| return "INVALID_TRANSMISSION_TYPE"; | |
| } | |
| return absl::StrCat("Unknown(", static_cast<int>(transmission_type), ")"); | |
| } | |
| } | |
| std::ostream& operator<<(std::ostream& os, TransmissionType transmission_type) { | |
| os << TransmissionTypeToString(transmission_type); | |
| return os; | |
| } | |
| std::string PacketHeaderFormatToString(PacketHeaderFormat format) { | |
| switch (format) { | |
| RETURN_STRING_LITERAL(IETF_QUIC_LONG_HEADER_PACKET); | |
| RETURN_STRING_LITERAL(IETF_QUIC_SHORT_HEADER_PACKET); | |
| RETURN_STRING_LITERAL(GOOGLE_QUIC_PACKET); | |
| default: | |
| return absl::StrCat("Unknown (", static_cast<int>(format), ")"); | |
| } | |
| } | |
| std::string QuicLongHeaderTypeToString(QuicLongHeaderType type) { | |
| switch (type) { | |
| RETURN_STRING_LITERAL(VERSION_NEGOTIATION); | |
| RETURN_STRING_LITERAL(INITIAL); | |
| RETURN_STRING_LITERAL(ZERO_RTT_PROTECTED); | |
| RETURN_STRING_LITERAL(HANDSHAKE); | |
| RETURN_STRING_LITERAL(RETRY); | |
| RETURN_STRING_LITERAL(INVALID_PACKET_TYPE); | |
| default: | |
| return absl::StrCat("Unknown (", static_cast<int>(type), ")"); | |
| } | |
| } | |
| std::string MessageStatusToString(MessageStatus message_status) { | |
| switch (message_status) { | |
| RETURN_STRING_LITERAL(MESSAGE_STATUS_SUCCESS); | |
| RETURN_STRING_LITERAL(MESSAGE_STATUS_ENCRYPTION_NOT_ESTABLISHED); | |
| RETURN_STRING_LITERAL(MESSAGE_STATUS_UNSUPPORTED); | |
| RETURN_STRING_LITERAL(MESSAGE_STATUS_BLOCKED); | |
| RETURN_STRING_LITERAL(MESSAGE_STATUS_TOO_LARGE); | |
| RETURN_STRING_LITERAL(MESSAGE_STATUS_INTERNAL_ERROR); | |
| default: | |
| return absl::StrCat("Unknown(", static_cast<int>(message_status), ")"); | |
| } | |
| } | |
| std::string MessageResultToString(MessageResult message_result) { | |
| if (message_result.status != MESSAGE_STATUS_SUCCESS) { | |
| return absl::StrCat("{", MessageStatusToString(message_result.status), "}"); | |
| } | |
| return absl::StrCat("{MESSAGE_STATUS_SUCCESS,id=", message_result.message_id, | |
| "}"); | |
| } | |
| std::ostream& operator<<(std::ostream& os, const MessageResult& mr) { | |
| os << MessageResultToString(mr); | |
| return os; | |
| } | |
| std::string PacketNumberSpaceToString(PacketNumberSpace packet_number_space) { | |
| switch (packet_number_space) { | |
| RETURN_STRING_LITERAL(INITIAL_DATA); | |
| RETURN_STRING_LITERAL(HANDSHAKE_DATA); | |
| RETURN_STRING_LITERAL(APPLICATION_DATA); | |
| default: | |
| return absl::StrCat("Unknown(", static_cast<int>(packet_number_space), | |
| ")"); | |
| } | |
| } | |
| std::string SerializedPacketFateToString(SerializedPacketFate fate) { | |
| switch (fate) { | |
| RETURN_STRING_LITERAL(COALESCE); | |
| RETURN_STRING_LITERAL(BUFFER); | |
| RETURN_STRING_LITERAL(SEND_TO_WRITER); | |
| RETURN_STRING_LITERAL(LEGACY_VERSION_ENCAPSULATE); | |
| default: | |
| return absl::StrCat("Unknown(", static_cast<int>(fate), ")"); | |
| } | |
| } | |
| std::ostream& operator<<(std::ostream& os, SerializedPacketFate fate) { | |
| os << SerializedPacketFateToString(fate); | |
| return os; | |
| } | |
| std::string EncryptionLevelToString(EncryptionLevel level) { | |
| switch (level) { | |
| RETURN_STRING_LITERAL(ENCRYPTION_INITIAL); | |
| RETURN_STRING_LITERAL(ENCRYPTION_HANDSHAKE); | |
| RETURN_STRING_LITERAL(ENCRYPTION_ZERO_RTT); | |
| RETURN_STRING_LITERAL(ENCRYPTION_FORWARD_SECURE); | |
| default: | |
| return absl::StrCat("Unknown(", static_cast<int>(level), ")"); | |
| } | |
| } | |
| std::ostream& operator<<(std::ostream& os, EncryptionLevel level) { | |
| os << EncryptionLevelToString(level); | |
| return os; | |
| } | |
| absl::string_view ClientCertModeToString(ClientCertMode mode) { | |
| #define RETURN_REASON_LITERAL(x) \ | |
| case ClientCertMode::x: \ | |
| return #x | |
| switch (mode) { | |
| RETURN_REASON_LITERAL(kNone); | |
| RETURN_REASON_LITERAL(kRequest); | |
| RETURN_REASON_LITERAL(kRequire); | |
| default: | |
| return "<invalid>"; | |
| } | |
| #undef RETURN_REASON_LITERAL | |
| } | |
| std::ostream& operator<<(std::ostream& os, ClientCertMode mode) { | |
| os << ClientCertModeToString(mode); | |
| return os; | |
| } | |
| std::string QuicConnectionCloseTypeString(QuicConnectionCloseType type) { | |
| switch (type) { | |
| RETURN_STRING_LITERAL(GOOGLE_QUIC_CONNECTION_CLOSE); | |
| RETURN_STRING_LITERAL(IETF_QUIC_TRANSPORT_CONNECTION_CLOSE); | |
| RETURN_STRING_LITERAL(IETF_QUIC_APPLICATION_CONNECTION_CLOSE); | |
| default: | |
| return absl::StrCat("Unknown(", static_cast<int>(type), ")"); | |
| } | |
| } | |
| std::ostream& operator<<(std::ostream& os, const QuicConnectionCloseType type) { | |
| os << QuicConnectionCloseTypeString(type); | |
| return os; | |
| } | |
| std::string AddressChangeTypeToString(AddressChangeType type) { | |
| using IntType = typename std::underlying_type<AddressChangeType>::type; | |
| switch (type) { | |
| RETURN_STRING_LITERAL(NO_CHANGE); | |
| RETURN_STRING_LITERAL(PORT_CHANGE); | |
| RETURN_STRING_LITERAL(IPV4_SUBNET_CHANGE); | |
| RETURN_STRING_LITERAL(IPV4_TO_IPV4_CHANGE); | |
| RETURN_STRING_LITERAL(IPV4_TO_IPV6_CHANGE); | |
| RETURN_STRING_LITERAL(IPV6_TO_IPV4_CHANGE); | |
| RETURN_STRING_LITERAL(IPV6_TO_IPV6_CHANGE); | |
| default: | |
| return absl::StrCat("Unknown(", static_cast<IntType>(type), ")"); | |
| } | |
| } | |
| std::ostream& operator<<(std::ostream& os, AddressChangeType type) { | |
| os << AddressChangeTypeToString(type); | |
| return os; | |
| } | |
| std::string KeyUpdateReasonString(KeyUpdateReason reason) { | |
| #define RETURN_REASON_LITERAL(x) \ | |
| case KeyUpdateReason::x: \ | |
| return #x | |
| switch (reason) { | |
| RETURN_REASON_LITERAL(kInvalid); | |
| RETURN_REASON_LITERAL(kRemote); | |
| RETURN_REASON_LITERAL(kLocalForTests); | |
| RETURN_REASON_LITERAL(kLocalForInteropRunner); | |
| RETURN_REASON_LITERAL(kLocalAeadConfidentialityLimit); | |
| RETURN_REASON_LITERAL(kLocalKeyUpdateLimitOverride); | |
| default: | |
| return absl::StrCat("Unknown(", static_cast<int>(reason), ")"); | |
| } | |
| #undef RETURN_REASON_LITERAL | |
| } | |
| std::ostream& operator<<(std::ostream& os, const KeyUpdateReason reason) { | |
| os << KeyUpdateReasonString(reason); | |
| return os; | |
| } | |
| bool operator==(const ParsedClientHello& a, const ParsedClientHello& b) { | |
| return a.sni == b.sni && a.uaid == b.uaid && a.alpns == b.alpns && | |
| a.legacy_version_encapsulation_inner_packet == | |
| b.legacy_version_encapsulation_inner_packet && | |
| a.retry_token == b.retry_token && | |
| a.resumption_attempted == b.resumption_attempted && | |
| a.early_data_attempted == b.early_data_attempted; | |
| } | |
| std::ostream& operator<<(std::ostream& os, | |
| const ParsedClientHello& parsed_chlo) { | |
| os << "{ sni:" << parsed_chlo.sni << ", uaid:" << parsed_chlo.uaid | |
| << ", alpns:" << quiche::PrintElements(parsed_chlo.alpns) | |
| << ", len(retry_token):" << parsed_chlo.retry_token.size() | |
| << ", len(inner_packet):" | |
| << parsed_chlo.legacy_version_encapsulation_inner_packet.size() << " }"; | |
| return os; | |
| } | |
| #undef RETURN_STRING_LITERAL // undef for jumbo builds | |
| } // namespace quic |