Index: third_party/protobuf/php/src/Google/Protobuf/Internal/InputStream.php |
diff --git a/third_party/protobuf/php/src/Google/Protobuf/Internal/InputStream.php b/third_party/protobuf/php/src/Google/Protobuf/Internal/InputStream.php |
deleted file mode 100644 |
index 6d6c74e906d3d14aba332a64c357d8c72c9aad4b..0000000000000000000000000000000000000000 |
--- a/third_party/protobuf/php/src/Google/Protobuf/Internal/InputStream.php |
+++ /dev/null |
@@ -1,373 +0,0 @@ |
-<?php |
- |
-// Protocol Buffers - Google's data interchange format |
-// Copyright 2008 Google Inc. All rights reserved. |
-// https://developers.google.com/protocol-buffers/ |
-// |
-// Redistribution and use in source and binary forms, with or without |
-// modification, are permitted provided that the following conditions are |
-// met: |
-// |
-// * Redistributions of source code must retain the above copyright |
-// notice, this list of conditions and the following disclaimer. |
-// * Redistributions in binary form must reproduce the above |
-// copyright notice, this list of conditions and the following disclaimer |
-// in the documentation and/or other materials provided with the |
-// distribution. |
-// * Neither the name of Google Inc. nor the names of its |
-// contributors may be used to endorse or promote products derived from |
-// this software without specific prior written permission. |
-// |
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
- |
-namespace Google\Protobuf\Internal; |
- |
-use Google\Protobuf\Internal\Uint64; |
- |
-function combineInt32ToInt64($high, $low) |
-{ |
- $isNeg = $high < 0; |
- if ($isNeg) { |
- $high = ~$high; |
- $low = ~$low; |
- $low++; |
- if (!$low) { |
- $high++; |
- } |
- } |
- $result = bcadd(bcmul($high, 4294967296), $low); |
- if ($isNeg) { |
- $result = bcsub(0, $result); |
- } |
- return $result; |
-} |
- |
-class InputStream |
-{ |
- |
- private $buffer; |
- private $buffer_size_after_limit; |
- private $buffer_end; |
- private $current; |
- private $current_limit; |
- private $legitimate_message_end; |
- private $recursion_budget; |
- private $recursion_limit; |
- private $total_bytes_limit; |
- private $total_bytes_read; |
- |
- const MAX_VARINT_BYTES = 10; |
- const MAX_VARINT32_BYTES = 5; |
- const DEFAULT_RECURSION_LIMIT = 100; |
- const DEFAULT_TOTAL_BYTES_LIMIT = 33554432; // 32 << 20, 32MB |
- |
- public function __construct($buffer) |
- { |
- $start = 0; |
- $end = strlen($buffer); |
- $this->buffer = $buffer; |
- $this->buffer_size_after_limit = 0; |
- $this->buffer_end = $end; |
- $this->current = $start; |
- $this->current_limit = $end; |
- $this->legitimate_message_end = false; |
- $this->recursion_budget = self::DEFAULT_RECURSION_LIMIT; |
- $this->recursion_limit = self::DEFAULT_RECURSION_LIMIT; |
- $this->total_bytes_limit = self::DEFAULT_TOTAL_BYTES_LIMIT; |
- $this->total_bytes_read = $end - $start; |
- } |
- |
- private function advance($amount) |
- { |
- $this->current += $amount; |
- } |
- |
- private function bufferSize() |
- { |
- return $this->buffer_end - $this->current; |
- } |
- |
- private function current() |
- { |
- return $this->total_bytes_read - |
- ($this->buffer_end - $this->current + |
- $this->buffer_size_after_limit); |
- } |
- |
- private function recomputeBufferLimits() |
- { |
- $this->buffer_end += $this->buffer_size_after_limit; |
- $closest_limit = min($this->current_limit, $this->total_bytes_limit); |
- if ($closest_limit < $this->total_bytes_read) { |
- // The limit position is in the current buffer. We must adjust the |
- // buffer size accordingly. |
- $this->buffer_size_after_limit = $this->total_bytes_read - |
- $closest_limit; |
- $this->buffer_end -= $this->buffer_size_after_limit; |
- } else { |
- $this->buffer_size_after_limit = 0; |
- } |
- } |
- |
- private function consumedEntireMessage() |
- { |
- return $this->legitimate_message_end; |
- } |
- |
- /** |
- * Read uint32 into $var. Advance buffer with consumed bytes. If the |
- * contained varint is larger than 32 bits, discard the high order bits. |
- * @param $var. |
- */ |
- public function readVarint32(&$var) |
- { |
- if (!$this->readVarint64($var)) { |
- return false; |
- } |
- |
- if (PHP_INT_SIZE == 4) { |
- $var = bcmod($var, 4294967296); |
- } else { |
- $var &= 0xFFFFFFFF; |
- } |
- |
- // Convert large uint32 to int32. |
- if ($var > 0x7FFFFFFF) { |
- if (PHP_INT_SIZE === 8) { |
- $var = $var | (0xFFFFFFFF << 32); |
- } else { |
- $var = bcsub($var, 4294967296); |
- } |
- } |
- |
- $var = intval($var); |
- return true; |
- } |
- |
- /** |
- * Read Uint64 into $var. Advance buffer with consumed bytes. |
- * @param $var. |
- */ |
- public function readVarint64(&$var) |
- { |
- $high = 0; |
- $low = 0; |
- $count = 0; |
- $b = 0; |
- |
- do { |
- if ($this->current === $this->buffer_end) { |
- return false; |
- } |
- if ($count === self::MAX_VARINT_BYTES) { |
- return false; |
- } |
- $b = ord($this->buffer[$this->current]); |
- $bits = 7 * $count; |
- if ($bits >= 32) { |
- $high |= (($b & 0x7F) << ($bits - 32)); |
- } else if ($bits > 25){ |
- $high_bits = $bits - 25; |
- $low = ($low | (($b & 0x7F) << $bits)) & (int) 0xFFFFFFFF; |
- $high = $b & ((0x1 << $high_bits) -1); |
- } else { |
- $low |= (($b & 0x7F) << $bits); |
- } |
- |
- $this->advance(1); |
- $count += 1; |
- } while ($b & 0x80); |
- |
- if (PHP_INT_SIZE == 4) { |
- $var = combineInt32ToInt64($high, $low); |
- } else { |
- $var = ($high & 0xFFFFFFFF) << 32 | |
- ($low & 0xFFFFFFFF); |
- } |
- return true; |
- } |
- |
- /** |
- * Read int into $var. If the result is larger than the largest integer, $var |
- * will be -1. Advance buffer with consumed bytes. |
- * @param $var. |
- */ |
- public function readVarintSizeAsInt(&$var) |
- { |
- if (!$this->readVarint64($var)) { |
- return false; |
- } |
- $var = (int)$var; |
- return true; |
- } |
- |
- /** |
- * Read 32-bit unsiged integer to $var. If the buffer has less than 4 bytes, |
- * return false. Advance buffer with consumed bytes. |
- * @param $var. |
- */ |
- public function readLittleEndian32(&$var) |
- { |
- $data = null; |
- if (!$this->readRaw(4, $data)) { |
- return false; |
- } |
- $var = unpack('V', $data); |
- $var = $var[1]; |
- return true; |
- } |
- |
- /** |
- * Read 64-bit unsiged integer to $var. If the buffer has less than 8 bytes, |
- * return false. Advance buffer with consumed bytes. |
- * @param $var. |
- */ |
- public function readLittleEndian64(&$var) |
- { |
- $data = null; |
- if (!$this->readRaw(4, $data)) { |
- return false; |
- } |
- $low = unpack('V', $data)[1]; |
- if (!$this->readRaw(4, $data)) { |
- return false; |
- } |
- $high = unpack('V', $data)[1]; |
- if (PHP_INT_SIZE == 4) { |
- $var = combineInt32ToInt64($high, $low); |
- } else { |
- $var = ($high << 32) | $low; |
- } |
- return true; |
- } |
- |
- /** |
- * Read tag into $var. Advance buffer with consumed bytes. |
- * @param $var. |
- */ |
- public function readTag() |
- { |
- if ($this->current === $this->buffer_end) { |
- // Make sure that it failed due to EOF, not because we hit |
- // total_bytes_limit, which, unlike normal limits, is not a valid |
- // place to end a message. |
- $current_position = $this->total_bytes_read - |
- $this->buffer_size_after_limit; |
- if ($current_position >= $this->total_bytes_limit) { |
- // Hit total_bytes_limit_. But if we also hit the normal limit, |
- // we're still OK. |
- $this->legitimate_message_end = |
- ($this->current_limit === $this->total_bytes_limit); |
- } else { |
- $this->legitimate_message_end = true; |
- } |
- return 0; |
- } |
- |
- $result = 0; |
- // The larget tag is 2^29 - 1, which can be represented by int32. |
- $success = $this->readVarint32($result); |
- if ($success) { |
- return $result; |
- } else { |
- return 0; |
- } |
- } |
- |
- public function readRaw($size, &$buffer) |
- { |
- $current_buffer_size = 0; |
- if ($this->bufferSize() < $size) { |
- return false; |
- } |
- |
- $buffer = substr($this->buffer, $this->current, $size); |
- $this->advance($size); |
- |
- return true; |
- } |
- |
- /* Places a limit on the number of bytes that the stream may read, starting |
- * from the current position. Once the stream hits this limit, it will act |
- * like the end of the input has been reached until popLimit() is called. |
- * |
- * As the names imply, the stream conceptually has a stack of limits. The |
- * shortest limit on the stack is always enforced, even if it is not the top |
- * limit. |
- * |
- * The value returned by pushLimit() is opaque to the caller, and must be |
- * passed unchanged to the corresponding call to popLimit(). |
- * |
- * @param integer $byte_limit |
- */ |
- public function pushLimit($byte_limit) |
- { |
- // Current position relative to the beginning of the stream. |
- $current_position = $this->current(); |
- $old_limit = $this->current_limit; |
- |
- // security: byte_limit is possibly evil, so check for negative values |
- // and overflow. |
- if ($byte_limit >= 0 && $byte_limit <= PHP_INT_MAX - $current_position) { |
- $this->current_limit = $current_position + $byte_limit; |
- } else { |
- // Negative or overflow. |
- $this->current_limit = PHP_INT_MAX; |
- } |
- |
- // We need to enforce all limits, not just the new one, so if the previous |
- // limit was before the new requested limit, we continue to enforce the |
- // previous limit. |
- $this->current_limit = min($this->current_limit, $old_limit); |
- |
- $this->recomputeBufferLimits(); |
- return $old_limit; |
- } |
- |
- /* The limit passed in is actually the *old* limit, which we returned from |
- * PushLimit(). |
- * |
- * @param integer $byte_limit |
- */ |
- public function popLimit($byte_limit) |
- { |
- $this->current_limit = $byte_limit; |
- $this->recomputeBufferLimits(); |
- // We may no longer be at a legitimate message end. ReadTag() needs to |
- // be called again to find out. |
- $this->legitimate_message_end = false; |
- } |
- |
- public function incrementRecursionDepthAndPushLimit( |
- $byte_limit, &$old_limit, &$recursion_budget) |
- { |
- $old_limit = $this->pushLimit($byte_limit); |
- $recursion_limit = --$this->recursion_limit; |
- } |
- |
- public function decrementRecursionDepthAndPopLimit($byte_limit) |
- { |
- $result = $this->consumedEntireMessage(); |
- $this->popLimit($byte_limit); |
- ++$this->recursion_budget; |
- return $result; |
- } |
- |
- public function bytesUntilLimit() |
- { |
- if ($this->current_limit === PHP_INT_MAX) { |
- return -1; |
- } |
- return $this->current_limit - $this->current; |
- } |
-} |