net/quic/quic_data_reader.cc

   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_data_reader.h"
   6
   7 #include "net/base/int128.h"
   8 #include "net/quic/quic_protocol.h"
   9
  10 using base::StringPiece;
  11
  12 namespace net {
  13
  14 QuicDataReader::QuicDataReader(const char* data, const size_t len)
  15     : data_(data),
  16       len_(len),
  17       pos_(0) {
  18 }
  19
  20 bool QuicDataReader::ReadUInt16(uint16* result) {
  21   return ReadBytes(result, sizeof(*result));
  22 }
  23
  24 bool QuicDataReader::ReadUInt32(uint32* result) {
  25   return ReadBytes(result, sizeof(*result));
  26 }
  27
  28 bool QuicDataReader::ReadUInt48(uint64* result) {
  29   uint32 lo;
  30   if (!ReadUInt32(&lo)) {
  31     return false;
  32   }
  33
  34   uint16 hi;
  35   if (!ReadUInt16(&hi)) {
  36     return false;
  37   }
  38
  39   *result = hi;
  40   *result <<= 32;
  41   *result += lo;
  42
  43   return true;
  44 }
  45
  46 bool QuicDataReader::ReadUInt64(uint64* result) {
  47   return ReadBytes(result, sizeof(*result));
  48 }
  49
  50 bool QuicDataReader::ReadUInt128(uint128* result) {
  51   uint64 high_hash;
  52   uint64 low_hash;
  53
  54   if (!ReadUInt64(&low_hash)) {
  55     return false;
  56   }
  57   if (!ReadUInt64(&high_hash)) {
  58     return false;
  59   }
  60
  61   *result = uint128(high_hash, low_hash);
  62   return true;
  63 }
  64
  65 bool QuicDataReader::ReadUFloat16(uint64* result) {
  66   uint16 value;
  67   if (!ReadUInt16(&value)) {
  68     return false;
  69   }
  70
  71   *result = value;
  72   if (*result < (1 << kUFloat16MantissaEffectiveBits)) {
  73     // Fast path: either the value is denormalized (no hidden bit), or
  74     // normalized (hidden bit set, exponent offset by one) with exponent zero.
  75     // Zero exponent offset by one sets the bit exactly where the hidden bit is.
  76     // So in both cases the value encodes itself.
  77     return true;
  78   }
  79
  80   uint16 exponent = value >> kUFloat16MantissaBits;  // No sign extend on uint!
  81   // After the fast pass, the exponent is at least one (offset by one).
  82   // Un-offset the exponent.
  83   --exponent;
  84   DCHECK_GE(exponent, 1);
  85   DCHECK_LE(exponent, kUFloat16MaxExponent);
  86   // Here we need to clear the exponent and set the hidden bit. We have already
  87   // decremented the exponent, so when we subtract it, it leaves behind the
  88   // hidden bit.
  89   *result -= exponent << kUFloat16MantissaBits;
  90   *result <<= exponent;
  91   DCHECK_GE(value, 1 << kUFloat16MantissaEffectiveBits);
  92   DCHECK_LE(value, kUFloat16MaxValue);
  93   return true;
  94 }
  95
  96 bool QuicDataReader::ReadStringPiece16(StringPiece* result) {
  97   // Read resultant length.
  98   uint16 result_len;
  99   if (!ReadUInt16(&result_len)) {
 100     // OnFailure() already called.
 101     return false;
 102   }
 103
 104   return ReadStringPiece(result, result_len);
 105 }
 106
 107 bool QuicDataReader::ReadStringPiece(StringPiece* result, size_t size) {
 108   // Make sure that we have enough data to read.
 109   if (!CanRead(size)) {
 110     OnFailure();
 111     return false;
 112   }
 113
 114   // Set result.
 115   result->set(data_ + pos_, size);
 116
 117   // Iterate.
 118   pos_ += size;
 119
 120   return true;
 121 }
 122
 123 StringPiece QuicDataReader::ReadRemainingPayload() {
 124   StringPiece payload = PeekRemainingPayload();
 125   pos_ = len_;
 126   return payload;
 127 }
 128
 129 StringPiece QuicDataReader::PeekRemainingPayload() {
 130   return StringPiece(data_ + pos_, len_ - pos_);
 131 }
 132
 133 bool QuicDataReader::ReadBytes(void* result, size_t size) {
 134   // Make sure that we have enough data to read.
 135   if (!CanRead(size)) {
 136     OnFailure();
 137     return false;
 138   }
 139
 140   // Read into result.
 141   memcpy(result, data_ + pos_, size);
 142
 143   // Iterate.
 144   pos_ += size;
 145
 146   return true;
 147 }
 148
 149 bool QuicDataReader::IsDoneReading() const {
 150   return len_ == pos_;
 151 }
 152
 153 size_t QuicDataReader::BytesRemaining() const {
 154   return len_ - pos_;
 155 }
 156
 157 bool QuicDataReader::CanRead(size_t bytes) const {
 158   return bytes <= (len_ - pos_);
 159 }
 160
 161 void QuicDataReader::OnFailure() {
 162   // Set our iterator to the end of the buffer so that further reads fail
 163   // immediately.
 164   pos_ = len_;
 165 }
 166
 167 }  // namespace net