1 // Copyright 2014 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/spdy/hpack_input_stream.h" 6 7 #include <algorithm> 8 9 #include "base/basictypes.h" 10 #include "base/logging.h" 11 12 namespace net { 13 14 using base::StringPiece; 15 using std::string; 16 17 HpackInputStream::HpackInputStream(uint32 max_string_literal_size, 18 StringPiece buffer) 19 : max_string_literal_size_(max_string_literal_size), 20 buffer_(buffer), 21 bit_offset_(0) {} 22 23 HpackInputStream::~HpackInputStream() {} 24 25 bool HpackInputStream::HasMoreData() const { 26 return !buffer_.empty(); 27 } 28 29 bool HpackInputStream::MatchPrefixAndConsume(HpackPrefix prefix) { 30 DCHECK_GT(prefix.bit_size, 0u); 31 DCHECK_LE(prefix.bit_size, 8u); 32 33 uint32 peeked = 0; 34 size_t peeked_count = 0; 35 36 if (!PeekBits(&peeked_count, &peeked)) 37 return false; 38 39 if ((peeked >> (32 - prefix.bit_size)) == prefix.bits) { 40 ConsumeBits(prefix.bit_size); 41 return true; 42 } 43 return false; 44 } 45 46 bool HpackInputStream::PeekNextOctet(uint8* next_octet) { 47 if ((bit_offset_ > 0) || buffer_.empty()) 48 return false; 49 50 *next_octet = buffer_[0]; 51 return true; 52 } 53 54 bool HpackInputStream::DecodeNextOctet(uint8* next_octet) { 55 if (!PeekNextOctet(next_octet)) 56 return false; 57 58 buffer_.remove_prefix(1); 59 return true; 60 } 61 62 bool HpackInputStream::DecodeNextUint32(uint32* I) { 63 size_t N = 8 - bit_offset_; 64 DCHECK_GT(N, 0u); 65 DCHECK_LE(N, 8u); 66 67 bit_offset_ = 0; 68 69 *I = 0; 70 71 uint8 next_marker = (1 << N) - 1; 72 uint8 next_octet = 0; 73 if (!DecodeNextOctet(&next_octet)) 74 return false; 75 *I = next_octet & next_marker; 76 77 bool has_more = (*I == next_marker); 78 size_t shift = 0; 79 while (has_more && (shift < 32)) { 80 uint8 next_octet = 0; 81 if (!DecodeNextOctet(&next_octet)) 82 return false; 83 has_more = (next_octet & 0x80) != 0; 84 next_octet &= 0x7f; 85 uint32 addend = next_octet << shift; 86 // Check for overflow. 87 if ((addend >> shift) != next_octet) { 88 return false; 89 } 90 *I += addend; 91 shift += 7; 92 } 93 94 return !has_more; 95 } 96 97 bool HpackInputStream::DecodeNextIdentityString(StringPiece* str) { 98 uint32 size = 0; 99 if (!DecodeNextUint32(&size)) 100 return false; 101 102 if (size > max_string_literal_size_) 103 return false; 104 105 if (size > buffer_.size()) 106 return false; 107 108 *str = StringPiece(buffer_.data(), size); 109 buffer_.remove_prefix(size); 110 return true; 111 } 112 113 bool HpackInputStream::DecodeNextHuffmanString(const HpackHuffmanTable& table, 114 string* str) { 115 uint32 encoded_size = 0; 116 if (!DecodeNextUint32(&encoded_size)) 117 return false; 118 119 if (encoded_size > buffer_.size()) 120 return false; 121 122 HpackInputStream bounded_reader( 123 max_string_literal_size_, 124 StringPiece(buffer_.data(), encoded_size)); 125 buffer_.remove_prefix(encoded_size); 126 127 // HpackHuffmanTable will not decode beyond |max_string_literal_size_|. 128 return table.DecodeString(&bounded_reader, max_string_literal_size_, str); 129 } 130 131 bool HpackInputStream::PeekBits(size_t* peeked_count, uint32* out) { 132 size_t byte_offset = (bit_offset_ + *peeked_count) / 8; 133 size_t bit_offset = (bit_offset_ + *peeked_count) % 8; 134 135 if (*peeked_count >= 32 || byte_offset >= buffer_.size()) { 136 return false; 137 } 138 // We'll read the minimum of the current byte remainder, 139 // and the remaining unfilled bits of |out|. 140 size_t bits_to_read = std::min(32 - *peeked_count, 8 - bit_offset); 141 142 uint32 new_bits = static_cast<uint32>(buffer_[byte_offset]); 143 // Shift byte remainder to most-signifcant bits of |new_bits|. 144 // This drops the leading |bit_offset| bits of the byte. 145 new_bits = new_bits << (24 + bit_offset); 146 // Shift bits to the most-significant open bits of |out|. 147 new_bits = new_bits >> *peeked_count; 148 149 CHECK_EQ(*out & new_bits, 0u); 150 *out |= new_bits; 151 152 *peeked_count += bits_to_read; 153 return true; 154 } 155 156 void HpackInputStream::ConsumeBits(size_t bit_count) { 157 size_t byte_count = (bit_offset_ + bit_count) / 8; 158 bit_offset_ = (bit_offset_ + bit_count) % 8; 159 CHECK_GE(buffer_.size(), byte_count); 160 if (bit_offset_ != 0) { 161 CHECK_GT(buffer_.size(), 0u); 162 } 163 buffer_.remove_prefix(byte_count); 164 } 165 166 void HpackInputStream::ConsumeByteRemainder() { 167 if (bit_offset_ != 0) { 168 ConsumeBits(8 - bit_offset_); 169 } 170 } 171 172 } // namespace net 173
