|
|
|
|
@ -48,6 +48,7 @@ |
|
|
|
|
#include <cstring> |
|
|
|
|
#include <utility> |
|
|
|
|
|
|
|
|
|
#include "google/protobuf/stubs/logging.h" |
|
|
|
|
#include "google/protobuf/stubs/logging.h" |
|
|
|
|
#include "absl/strings/cord.h" |
|
|
|
|
#include "absl/strings/internal/resize_uninitialized.h" |
|
|
|
|
@ -174,7 +175,7 @@ CodedInputStream::Limit CodedInputStream::ReadLengthAndPushLimit() { |
|
|
|
|
bool CodedInputStream::DecrementRecursionDepthAndPopLimit(Limit limit) { |
|
|
|
|
bool result = ConsumedEntireMessage(); |
|
|
|
|
PopLimit(limit); |
|
|
|
|
GOOGLE_DCHECK_LT(recursion_budget_, recursion_limit_); |
|
|
|
|
GOOGLE_ABSL_DCHECK_LT(recursion_budget_, recursion_limit_); |
|
|
|
|
++recursion_budget_; |
|
|
|
|
return result; |
|
|
|
|
} |
|
|
|
|
@ -206,13 +207,12 @@ int CodedInputStream::BytesUntilTotalBytesLimit() const { |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
void CodedInputStream::PrintTotalBytesLimitError() { |
|
|
|
|
GOOGLE_LOG(ERROR) |
|
|
|
|
<< "A protocol message was rejected because it was too " |
|
|
|
|
"big (more than " |
|
|
|
|
<< total_bytes_limit_ |
|
|
|
|
<< " bytes). To increase the limit (or to disable these " |
|
|
|
|
"warnings), see CodedInputStream::SetTotalBytesLimit() " |
|
|
|
|
"in third_party/protobuf/io/coded_stream.h."; |
|
|
|
|
GOOGLE_ABSL_LOG(ERROR) << "A protocol message was rejected because it was too " |
|
|
|
|
"big (more than " |
|
|
|
|
<< total_bytes_limit_ |
|
|
|
|
<< " bytes). To increase the limit (or to disable these " |
|
|
|
|
"warnings), see CodedInputStream::SetTotalBytesLimit() " |
|
|
|
|
"in third_party/protobuf/io/coded_stream.h."; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
bool CodedInputStream::SkipFallback(int count, int original_buffer_size) { |
|
|
|
|
@ -280,7 +280,7 @@ bool CodedInputStream::ReadString(std::string* buffer, int size) { |
|
|
|
|
if (z.second) { |
|
|
|
|
// Oddly enough, memcpy() requires its first two args to be non-NULL even
|
|
|
|
|
// if we copy 0 bytes. So, we have ensured that z.first is non-NULL here.
|
|
|
|
|
GOOGLE_DCHECK(z.first != NULL); |
|
|
|
|
GOOGLE_ABSL_DCHECK(z.first != NULL); |
|
|
|
|
memcpy(z.first, buffer_, size); |
|
|
|
|
Advance(size); |
|
|
|
|
} |
|
|
|
|
@ -405,7 +405,7 @@ namespace { |
|
|
|
|
// subtracting 0x80 at each iteration, it subtracts properly shifted mask once.
|
|
|
|
|
template <size_t N> |
|
|
|
|
const uint8_t* DecodeVarint64KnownSize(const uint8_t* buffer, uint64_t* value) { |
|
|
|
|
GOOGLE_DCHECK_GT(N, 0); |
|
|
|
|
GOOGLE_ABSL_DCHECK_GT(N, 0); |
|
|
|
|
uint64_t result = static_cast<uint64_t>(buffer[N - 1]) << (7 * (N - 1)); |
|
|
|
|
for (size_t i = 0, offset = 0; i < N - 1; i++, offset += 7) { |
|
|
|
|
result += static_cast<uint64_t>(buffer[i] - 0x80) << offset; |
|
|
|
|
@ -426,8 +426,8 @@ inline ::std::pair<bool, const uint8_t*> ReadVarint32FromArray( |
|
|
|
|
uint32_t first_byte, const uint8_t* buffer, uint32_t* value) { |
|
|
|
|
// Fast path: We have enough bytes left in the buffer to guarantee that
|
|
|
|
|
// this read won't cross the end, so we can skip the checks.
|
|
|
|
|
GOOGLE_DCHECK_EQ(*buffer, first_byte); |
|
|
|
|
GOOGLE_DCHECK_EQ(first_byte & 0x80, 0x80) << first_byte; |
|
|
|
|
GOOGLE_ABSL_DCHECK_EQ(*buffer, first_byte); |
|
|
|
|
GOOGLE_ABSL_DCHECK_EQ(first_byte & 0x80, 0x80) << first_byte; |
|
|
|
|
const uint8_t* ptr = buffer; |
|
|
|
|
uint32_t b; |
|
|
|
|
uint32_t result = first_byte - 0x80; |
|
|
|
|
@ -470,7 +470,7 @@ PROTOBUF_ALWAYS_INLINE::std::pair<bool, const uint8_t*> ReadVarint64FromArray( |
|
|
|
|
inline ::std::pair<bool, const uint8_t*> ReadVarint64FromArray( |
|
|
|
|
const uint8_t* buffer, uint64_t* value) { |
|
|
|
|
// Assumes varint64 is at least 2 bytes.
|
|
|
|
|
GOOGLE_DCHECK_GE(buffer[0], 128); |
|
|
|
|
GOOGLE_ABSL_DCHECK_GE(buffer[0], 128); |
|
|
|
|
|
|
|
|
|
const uint8_t* next; |
|
|
|
|
if (buffer[1] < 128) { |
|
|
|
|
@ -515,7 +515,7 @@ int64_t CodedInputStream::ReadVarint32Fallback(uint32_t first_byte_or_zero) { |
|
|
|
|
// Optimization: We're also safe if the buffer is non-empty and it ends
|
|
|
|
|
// with a byte that would terminate a varint.
|
|
|
|
|
(buffer_end_ > buffer_ && !(buffer_end_[-1] & 0x80))) { |
|
|
|
|
GOOGLE_DCHECK_NE(first_byte_or_zero, 0) |
|
|
|
|
GOOGLE_ABSL_DCHECK_NE(first_byte_or_zero, 0) |
|
|
|
|
<< "Caller should provide us with *buffer_ when buffer is non-empty"; |
|
|
|
|
uint32_t temp; |
|
|
|
|
::std::pair<bool, const uint8_t*> p = |
|
|
|
|
@ -590,7 +590,7 @@ uint32_t CodedInputStream::ReadTagFallback(uint32_t first_byte_or_zero) { |
|
|
|
|
// Optimization: We're also safe if the buffer is non-empty and it ends
|
|
|
|
|
// with a byte that would terminate a varint.
|
|
|
|
|
(buf_size > 0 && !(buffer_end_[-1] & 0x80))) { |
|
|
|
|
GOOGLE_DCHECK_EQ(first_byte_or_zero, buffer_[0]); |
|
|
|
|
GOOGLE_ABSL_DCHECK_EQ(first_byte_or_zero, buffer_[0]); |
|
|
|
|
if (first_byte_or_zero == 0) { |
|
|
|
|
++buffer_; |
|
|
|
|
return 0; |
|
|
|
|
@ -670,7 +670,7 @@ std::pair<uint64_t, bool> CodedInputStream::ReadVarint64Fallback() { |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
bool CodedInputStream::Refresh() { |
|
|
|
|
GOOGLE_DCHECK_EQ(0, BufferSize()); |
|
|
|
|
GOOGLE_ABSL_DCHECK_EQ(0, BufferSize()); |
|
|
|
|
|
|
|
|
|
if (buffer_size_after_limit_ > 0 || overflow_bytes_ > 0 || |
|
|
|
|
total_bytes_read_ == current_limit_) { |
|
|
|
|
@ -691,7 +691,7 @@ bool CodedInputStream::Refresh() { |
|
|
|
|
if (NextNonEmpty(input_, &void_buffer, &buffer_size)) { |
|
|
|
|
buffer_ = reinterpret_cast<const uint8_t*>(void_buffer); |
|
|
|
|
buffer_end_ = buffer_ + buffer_size; |
|
|
|
|
GOOGLE_CHECK_GE(buffer_size, 0); |
|
|
|
|
GOOGLE_ABSL_CHECK_GE(buffer_size, 0); |
|
|
|
|
|
|
|
|
|
if (total_bytes_read_ <= INT_MAX - buffer_size) { |
|
|
|
|
total_bytes_read_ += buffer_size; |
|
|
|
|
@ -738,8 +738,8 @@ int64_t EpsCopyOutputStream::ByteCount(uint8_t* ptr) const { |
|
|
|
|
int EpsCopyOutputStream::Flush(uint8_t* ptr) { |
|
|
|
|
while (buffer_end_ && ptr > end_) { |
|
|
|
|
int overrun = ptr - end_; |
|
|
|
|
GOOGLE_DCHECK(!had_error_); |
|
|
|
|
GOOGLE_DCHECK(overrun <= kSlopBytes); // NOLINT
|
|
|
|
|
GOOGLE_ABSL_DCHECK(!had_error_); |
|
|
|
|
GOOGLE_ABSL_DCHECK(overrun <= kSlopBytes); // NOLINT
|
|
|
|
|
ptr = Next() + overrun; |
|
|
|
|
if (had_error_) return 0; |
|
|
|
|
} |
|
|
|
|
@ -753,7 +753,7 @@ int EpsCopyOutputStream::Flush(uint8_t* ptr) { |
|
|
|
|
s = end_ + kSlopBytes - ptr; |
|
|
|
|
buffer_end_ = ptr; |
|
|
|
|
} |
|
|
|
|
GOOGLE_DCHECK(s >= 0); // NOLINT
|
|
|
|
|
GOOGLE_ABSL_DCHECK(s >= 0); // NOLINT
|
|
|
|
|
return s; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
@ -841,7 +841,7 @@ uint8_t* EpsCopyOutputStream::GetDirectBufferForNBytesAndAdvance(int size, |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
uint8_t* EpsCopyOutputStream::Next() { |
|
|
|
|
GOOGLE_DCHECK(!had_error_); // NOLINT
|
|
|
|
|
GOOGLE_ABSL_DCHECK(!had_error_); // NOLINT
|
|
|
|
|
if (PROTOBUF_PREDICT_FALSE(stream_ == nullptr)) return Error(); |
|
|
|
|
if (buffer_end_) { |
|
|
|
|
// We're in the patch buffer and need to fill up the previous buffer.
|
|
|
|
|
@ -863,7 +863,7 @@ uint8_t* EpsCopyOutputStream::Next() { |
|
|
|
|
buffer_end_ = nullptr; |
|
|
|
|
return ptr; |
|
|
|
|
} else { |
|
|
|
|
GOOGLE_DCHECK(size > 0); // NOLINT
|
|
|
|
|
GOOGLE_ABSL_DCHECK(size > 0); // NOLINT
|
|
|
|
|
// Buffer to small
|
|
|
|
|
std::memmove(buffer_, end_, kSlopBytes); |
|
|
|
|
buffer_end_ = ptr; |
|
|
|
|
@ -882,11 +882,11 @@ uint8_t* EpsCopyOutputStream::EnsureSpaceFallback(uint8_t* ptr) { |
|
|
|
|
do { |
|
|
|
|
if (PROTOBUF_PREDICT_FALSE(had_error_)) return buffer_; |
|
|
|
|
int overrun = ptr - end_; |
|
|
|
|
GOOGLE_DCHECK(overrun >= 0); // NOLINT
|
|
|
|
|
GOOGLE_DCHECK(overrun <= kSlopBytes); // NOLINT
|
|
|
|
|
GOOGLE_ABSL_DCHECK(overrun >= 0); // NOLINT
|
|
|
|
|
GOOGLE_ABSL_DCHECK(overrun <= kSlopBytes); // NOLINT
|
|
|
|
|
ptr = Next() + overrun; |
|
|
|
|
} while (ptr >= end_); |
|
|
|
|
GOOGLE_DCHECK(ptr < end_); // NOLINT
|
|
|
|
|
GOOGLE_ABSL_DCHECK(ptr < end_); // NOLINT
|
|
|
|
|
return ptr; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
@ -1029,7 +1029,7 @@ uint8_t* CodedOutputStream::WriteCordToArray(const absl::Cord& cord, |
|
|
|
|
|
|
|
|
|
uint8_t* CodedOutputStream::WriteStringWithSizeToArray(const std::string& str, |
|
|
|
|
uint8_t* target) { |
|
|
|
|
GOOGLE_DCHECK_LE(str.size(), std::numeric_limits<uint32_t>::max()); |
|
|
|
|
GOOGLE_ABSL_DCHECK_LE(str.size(), std::numeric_limits<uint32_t>::max()); |
|
|
|
|
target = WriteVarint32ToArray(str.size(), target); |
|
|
|
|
return WriteStringToArray(str, target); |
|
|
|
|
} |
|
|
|
|
|
Mike Kruskal
2 years ago
committed by
Copybara-Service