In QUIC v39, read and write integers and floating numbers in big endian.

net/quic/core/quic_framer.cc

 // Copyright (c) 2012 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 "net/quic/core/quic_framer.h"
 
 #include <cstdint>
 #include <memory>
 
 #include "base/compiler_specific.h"
@@ skipping 295 matching lines @@
     : max_block_length(0), first_block_length(0), num_ack_blocks(0) {}
 
 QuicFramer::AckFrameInfo::AckFrameInfo(const AckFrameInfo& other) = default;
 
 QuicFramer::AckFrameInfo::~AckFrameInfo() {}
 
 size_t QuicFramer::BuildDataPacket(const QuicPacketHeader& header,
                                    const QuicFrames& frames,
                                    char* buffer,
                                    size_t packet_length) {
-  QuicDataWriter writer(packet_length, buffer, perspective_, HOST_BYTE_ORDER);
+  QuicDataWriter writer(packet_length, buffer, perspective_, endianness());
   if (!AppendPacketHeader(header, &writer)) {
     QUIC_BUG << "AppendPacketHeader failed";
     return 0;
   }
 
   size_t i = 0;
   for (const QuicFrame& frame : frames) {
     // Determine if we should write stream frame length in header.
     const bool no_stream_frame_length = i == frames.size() - 1;
     if (!AppendTypeByte(frame, no_stream_frame_length, &writer)) {
@@ skipping 93 matching lines @@
       return nullptr;
     }
     reset.SetStringPiece(kCADR, serialized_address);
   }
   const QuicData& reset_serialized =
       reset.GetSerialized(Perspective::IS_SERVER);
 
   size_t len =
       kPublicFlagsSize + PACKET_8BYTE_CONNECTION_ID + reset_serialized.length();
   std::unique_ptr<char[]> buffer(new char[len]);
+  // Endianness is not a concern here, as writer is not going to write integers
+  // or floating numbers.
   QuicDataWriter writer(len, buffer.get(), Perspective::IS_SERVER,
-                        HOST_BYTE_ORDER);
+                        NETWORK_BYTE_ORDER);
 
   uint8_t flags = static_cast<uint8_t>(PACKET_PUBLIC_FLAGS_RST |
                                        PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID);
   if (FLAGS_quic_reloadable_flag_quic_use_old_public_reset_packets) {
     // TODO(rch): Remove this QUIC_VERSION_32 is retired.
     flags |= static_cast<uint8_t>(PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID_OLD);
   }
   if (!writer.WriteUInt8(flags)) {
     return nullptr;
   }
 
   if (!writer.WriteConnectionId(packet.public_header.connection_id)) {
     return nullptr;
   }
 
   if (!writer.WriteBytes(reset_serialized.data(), reset_serialized.length())) {
     return nullptr;
   }
 
   return QuicMakeUnique<QuicEncryptedPacket>(buffer.release(), len, true);
 }
 
 // static
 std::unique_ptr<QuicEncryptedPacket> QuicFramer::BuildVersionNegotiationPacket(
     QuicConnectionId connection_id,
     const QuicVersionVector& versions) {
   DCHECK(!versions.empty());
   size_t len = GetVersionNegotiationPacketSize(versions.size());
   std::unique_ptr<char[]> buffer(new char[len]);
+  // Endianness is not a concern here, version negotiation packet does not have
+  // integers or floating numbers.
   QuicDataWriter writer(len, buffer.get(), Perspective::IS_SERVER,
-                        HOST_BYTE_ORDER);
+                        NETWORK_BYTE_ORDER);
 
   uint8_t flags = static_cast<uint8_t>(
       PACKET_PUBLIC_FLAGS_VERSION | PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID |
       // TODO(rch): Remove this QUIC_VERSION_32 is retired.
       PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID_OLD);
   if (!writer.WriteUInt8(flags)) {
     return nullptr;
   }
 
   if (!writer.WriteConnectionId(connection_id)) {
     return nullptr;
   }
 
   for (QuicVersion version : versions) {
     if (!writer.WriteTag(QuicVersionToQuicTag(version))) {
       return nullptr;
     }
   }
 
   return QuicMakeUnique<QuicEncryptedPacket>(buffer.release(), len, true);
 }
 
 bool QuicFramer::ProcessPacket(const QuicEncryptedPacket& packet) {
   QuicDataReader reader(packet.data(), packet.length(), perspective_,
-                        HOST_BYTE_ORDER);
+                        endianness());
 
   visitor_->OnPacket();
 
   // First parse the public header.
   QuicPacketPublicHeader public_header;
   if (!ProcessPublicHeader(&reader, &public_header)) {
     DCHECK_NE("", detailed_error_);
     QUIC_DVLOG(1) << ENDPOINT << "Unable to process public header. Error: "
                   << detailed_error_;
     DCHECK_NE("", detailed_error_);
     return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
 
   if (!visitor_->OnUnauthenticatedPublicHeader(public_header)) {
     // The visitor suppresses further processing of the packet.
     return true;
   }
 
   if (perspective_ == Perspective::IS_SERVER && public_header.version_flag &&
       public_header.versions[0] != quic_version_) {
     if (!visitor_->OnProtocolVersionMismatch(public_header.versions[0])) {
       return true;
     }
   }
 
+  // framer's version may change, reset reader's endianness.
+  reader.set_endianness(endianness());
+
   bool rv;
   if (perspective_ == Perspective::IS_CLIENT && public_header.version_flag) {
     rv = ProcessVersionNegotiationPacket(&reader, &public_header);
   } else if (public_header.reset_flag) {
     rv = ProcessPublicResetPacket(&reader, public_header);
   } else if (packet.length() <= kMaxPacketSize) {
     // The optimized decryption algorithm implementations run faster when
     // operating on aligned memory.
     QUIC_CACHELINE_ALIGNED char buffer[kMaxPacketSize];
     rv = ProcessDataPacket(&reader, public_header, packet, buffer,
@@ skipping 43 matching lines @@
   }
 
   size_t decrypted_length = 0;
   if (!DecryptPayload(encrypted_reader, header, packet, decrypted_buffer,
                       buffer_length, &decrypted_length)) {
     set_detailed_error("Unable to decrypt payload.");
     return RaiseError(QUIC_DECRYPTION_FAILURE);
   }
 
   QuicDataReader reader(decrypted_buffer, decrypted_length, perspective_,
-                        HOST_BYTE_ORDER);
+                        endianness());
 
   // Set the last packet number after we have decrypted the packet
   // so we are confident is not attacker controlled.
   SetLastPacketNumber(header);
 
   if (!visitor_->OnPacketHeader(header)) {
     // The visitor suppresses further processing of the packet.
     return true;
   }
 
@@ skipping 1567 matching lines @@
 }
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   QUIC_DLOG(INFO) << ENDPOINT << "Error: " << QuicErrorCodeToString(error)
                   << " detail: " << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   return false;
 }
 
+Endianness QuicFramer::endianness() const {
+  return quic_version_ > QUIC_VERSION_38 ? NETWORK_BYTE_ORDER : HOST_BYTE_ORDER;
+}
+
 }  // namespace net