OLD | NEW |
| (Empty) |
1 <?php | |
2 | |
3 // Protocol Buffers - Google's data interchange format | |
4 // Copyright 2008 Google Inc. All rights reserved. | |
5 // https://developers.google.com/protocol-buffers/ | |
6 // | |
7 // Redistribution and use in source and binary forms, with or without | |
8 // modification, are permitted provided that the following conditions are | |
9 // met: | |
10 // | |
11 // * Redistributions of source code must retain the above copyright | |
12 // notice, this list of conditions and the following disclaimer. | |
13 // * Redistributions in binary form must reproduce the above | |
14 // copyright notice, this list of conditions and the following disclaimer | |
15 // in the documentation and/or other materials provided with the | |
16 // distribution. | |
17 // * Neither the name of Google Inc. nor the names of its | |
18 // contributors may be used to endorse or promote products derived from | |
19 // this software without specific prior written permission. | |
20 // | |
21 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
22 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
23 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
24 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
25 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
26 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
27 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
28 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
29 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
30 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
31 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
32 | |
33 namespace Google\Protobuf\Internal; | |
34 | |
35 use Google\Protobuf\Internal\Uint64; | |
36 | |
37 function combineInt32ToInt64($high, $low) | |
38 { | |
39 $isNeg = $high < 0; | |
40 if ($isNeg) { | |
41 $high = ~$high; | |
42 $low = ~$low; | |
43 $low++; | |
44 if (!$low) { | |
45 $high++; | |
46 } | |
47 } | |
48 $result = bcadd(bcmul($high, 4294967296), $low); | |
49 if ($isNeg) { | |
50 $result = bcsub(0, $result); | |
51 } | |
52 return $result; | |
53 } | |
54 | |
55 class InputStream | |
56 { | |
57 | |
58 private $buffer; | |
59 private $buffer_size_after_limit; | |
60 private $buffer_end; | |
61 private $current; | |
62 private $current_limit; | |
63 private $legitimate_message_end; | |
64 private $recursion_budget; | |
65 private $recursion_limit; | |
66 private $total_bytes_limit; | |
67 private $total_bytes_read; | |
68 | |
69 const MAX_VARINT_BYTES = 10; | |
70 const MAX_VARINT32_BYTES = 5; | |
71 const DEFAULT_RECURSION_LIMIT = 100; | |
72 const DEFAULT_TOTAL_BYTES_LIMIT = 33554432; // 32 << 20, 32MB | |
73 | |
74 public function __construct($buffer) | |
75 { | |
76 $start = 0; | |
77 $end = strlen($buffer); | |
78 $this->buffer = $buffer; | |
79 $this->buffer_size_after_limit = 0; | |
80 $this->buffer_end = $end; | |
81 $this->current = $start; | |
82 $this->current_limit = $end; | |
83 $this->legitimate_message_end = false; | |
84 $this->recursion_budget = self::DEFAULT_RECURSION_LIMIT; | |
85 $this->recursion_limit = self::DEFAULT_RECURSION_LIMIT; | |
86 $this->total_bytes_limit = self::DEFAULT_TOTAL_BYTES_LIMIT; | |
87 $this->total_bytes_read = $end - $start; | |
88 } | |
89 | |
90 private function advance($amount) | |
91 { | |
92 $this->current += $amount; | |
93 } | |
94 | |
95 private function bufferSize() | |
96 { | |
97 return $this->buffer_end - $this->current; | |
98 } | |
99 | |
100 private function current() | |
101 { | |
102 return $this->total_bytes_read - | |
103 ($this->buffer_end - $this->current + | |
104 $this->buffer_size_after_limit); | |
105 } | |
106 | |
107 private function recomputeBufferLimits() | |
108 { | |
109 $this->buffer_end += $this->buffer_size_after_limit; | |
110 $closest_limit = min($this->current_limit, $this->total_bytes_limit); | |
111 if ($closest_limit < $this->total_bytes_read) { | |
112 // The limit position is in the current buffer. We must adjust the | |
113 // buffer size accordingly. | |
114 $this->buffer_size_after_limit = $this->total_bytes_read - | |
115 $closest_limit; | |
116 $this->buffer_end -= $this->buffer_size_after_limit; | |
117 } else { | |
118 $this->buffer_size_after_limit = 0; | |
119 } | |
120 } | |
121 | |
122 private function consumedEntireMessage() | |
123 { | |
124 return $this->legitimate_message_end; | |
125 } | |
126 | |
127 /** | |
128 * Read uint32 into $var. Advance buffer with consumed bytes. If the | |
129 * contained varint is larger than 32 bits, discard the high order bits. | |
130 * @param $var. | |
131 */ | |
132 public function readVarint32(&$var) | |
133 { | |
134 if (!$this->readVarint64($var)) { | |
135 return false; | |
136 } | |
137 | |
138 if (PHP_INT_SIZE == 4) { | |
139 $var = bcmod($var, 4294967296); | |
140 } else { | |
141 $var &= 0xFFFFFFFF; | |
142 } | |
143 | |
144 // Convert large uint32 to int32. | |
145 if ($var > 0x7FFFFFFF) { | |
146 if (PHP_INT_SIZE === 8) { | |
147 $var = $var | (0xFFFFFFFF << 32); | |
148 } else { | |
149 $var = bcsub($var, 4294967296); | |
150 } | |
151 } | |
152 | |
153 $var = intval($var); | |
154 return true; | |
155 } | |
156 | |
157 /** | |
158 * Read Uint64 into $var. Advance buffer with consumed bytes. | |
159 * @param $var. | |
160 */ | |
161 public function readVarint64(&$var) | |
162 { | |
163 $high = 0; | |
164 $low = 0; | |
165 $count = 0; | |
166 $b = 0; | |
167 | |
168 do { | |
169 if ($this->current === $this->buffer_end) { | |
170 return false; | |
171 } | |
172 if ($count === self::MAX_VARINT_BYTES) { | |
173 return false; | |
174 } | |
175 $b = ord($this->buffer[$this->current]); | |
176 $bits = 7 * $count; | |
177 if ($bits >= 32) { | |
178 $high |= (($b & 0x7F) << ($bits - 32)); | |
179 } else if ($bits > 25){ | |
180 $high_bits = $bits - 25; | |
181 $low = ($low | (($b & 0x7F) << $bits)) & (int) 0xFFFFFFFF; | |
182 $high = $b & ((0x1 << $high_bits) -1); | |
183 } else { | |
184 $low |= (($b & 0x7F) << $bits); | |
185 } | |
186 | |
187 $this->advance(1); | |
188 $count += 1; | |
189 } while ($b & 0x80); | |
190 | |
191 if (PHP_INT_SIZE == 4) { | |
192 $var = combineInt32ToInt64($high, $low); | |
193 } else { | |
194 $var = ($high & 0xFFFFFFFF) << 32 | | |
195 ($low & 0xFFFFFFFF); | |
196 } | |
197 return true; | |
198 } | |
199 | |
200 /** | |
201 * Read int into $var. If the result is larger than the largest integer, $va
r | |
202 * will be -1. Advance buffer with consumed bytes. | |
203 * @param $var. | |
204 */ | |
205 public function readVarintSizeAsInt(&$var) | |
206 { | |
207 if (!$this->readVarint64($var)) { | |
208 return false; | |
209 } | |
210 $var = (int)$var; | |
211 return true; | |
212 } | |
213 | |
214 /** | |
215 * Read 32-bit unsiged integer to $var. If the buffer has less than 4 bytes, | |
216 * return false. Advance buffer with consumed bytes. | |
217 * @param $var. | |
218 */ | |
219 public function readLittleEndian32(&$var) | |
220 { | |
221 $data = null; | |
222 if (!$this->readRaw(4, $data)) { | |
223 return false; | |
224 } | |
225 $var = unpack('V', $data); | |
226 $var = $var[1]; | |
227 return true; | |
228 } | |
229 | |
230 /** | |
231 * Read 64-bit unsiged integer to $var. If the buffer has less than 8 bytes, | |
232 * return false. Advance buffer with consumed bytes. | |
233 * @param $var. | |
234 */ | |
235 public function readLittleEndian64(&$var) | |
236 { | |
237 $data = null; | |
238 if (!$this->readRaw(4, $data)) { | |
239 return false; | |
240 } | |
241 $low = unpack('V', $data)[1]; | |
242 if (!$this->readRaw(4, $data)) { | |
243 return false; | |
244 } | |
245 $high = unpack('V', $data)[1]; | |
246 if (PHP_INT_SIZE == 4) { | |
247 $var = combineInt32ToInt64($high, $low); | |
248 } else { | |
249 $var = ($high << 32) | $low; | |
250 } | |
251 return true; | |
252 } | |
253 | |
254 /** | |
255 * Read tag into $var. Advance buffer with consumed bytes. | |
256 * @param $var. | |
257 */ | |
258 public function readTag() | |
259 { | |
260 if ($this->current === $this->buffer_end) { | |
261 // Make sure that it failed due to EOF, not because we hit | |
262 // total_bytes_limit, which, unlike normal limits, is not a valid | |
263 // place to end a message. | |
264 $current_position = $this->total_bytes_read - | |
265 $this->buffer_size_after_limit; | |
266 if ($current_position >= $this->total_bytes_limit) { | |
267 // Hit total_bytes_limit_. But if we also hit the normal limit, | |
268 // we're still OK. | |
269 $this->legitimate_message_end = | |
270 ($this->current_limit === $this->total_bytes_limit); | |
271 } else { | |
272 $this->legitimate_message_end = true; | |
273 } | |
274 return 0; | |
275 } | |
276 | |
277 $result = 0; | |
278 // The larget tag is 2^29 - 1, which can be represented by int32. | |
279 $success = $this->readVarint32($result); | |
280 if ($success) { | |
281 return $result; | |
282 } else { | |
283 return 0; | |
284 } | |
285 } | |
286 | |
287 public function readRaw($size, &$buffer) | |
288 { | |
289 $current_buffer_size = 0; | |
290 if ($this->bufferSize() < $size) { | |
291 return false; | |
292 } | |
293 | |
294 $buffer = substr($this->buffer, $this->current, $size); | |
295 $this->advance($size); | |
296 | |
297 return true; | |
298 } | |
299 | |
300 /* Places a limit on the number of bytes that the stream may read, starting | |
301 * from the current position. Once the stream hits this limit, it will act | |
302 * like the end of the input has been reached until popLimit() is called. | |
303 * | |
304 * As the names imply, the stream conceptually has a stack of limits. The | |
305 * shortest limit on the stack is always enforced, even if it is not the top | |
306 * limit. | |
307 * | |
308 * The value returned by pushLimit() is opaque to the caller, and must be | |
309 * passed unchanged to the corresponding call to popLimit(). | |
310 * | |
311 * @param integer $byte_limit | |
312 */ | |
313 public function pushLimit($byte_limit) | |
314 { | |
315 // Current position relative to the beginning of the stream. | |
316 $current_position = $this->current(); | |
317 $old_limit = $this->current_limit; | |
318 | |
319 // security: byte_limit is possibly evil, so check for negative values | |
320 // and overflow. | |
321 if ($byte_limit >= 0 && $byte_limit <= PHP_INT_MAX - $current_position)
{ | |
322 $this->current_limit = $current_position + $byte_limit; | |
323 } else { | |
324 // Negative or overflow. | |
325 $this->current_limit = PHP_INT_MAX; | |
326 } | |
327 | |
328 // We need to enforce all limits, not just the new one, so if the previo
us | |
329 // limit was before the new requested limit, we continue to enforce the | |
330 // previous limit. | |
331 $this->current_limit = min($this->current_limit, $old_limit); | |
332 | |
333 $this->recomputeBufferLimits(); | |
334 return $old_limit; | |
335 } | |
336 | |
337 /* The limit passed in is actually the *old* limit, which we returned from | |
338 * PushLimit(). | |
339 * | |
340 * @param integer $byte_limit | |
341 */ | |
342 public function popLimit($byte_limit) | |
343 { | |
344 $this->current_limit = $byte_limit; | |
345 $this->recomputeBufferLimits(); | |
346 // We may no longer be at a legitimate message end. ReadTag() needs to | |
347 // be called again to find out. | |
348 $this->legitimate_message_end = false; | |
349 } | |
350 | |
351 public function incrementRecursionDepthAndPushLimit( | |
352 $byte_limit, &$old_limit, &$recursion_budget) | |
353 { | |
354 $old_limit = $this->pushLimit($byte_limit); | |
355 $recursion_limit = --$this->recursion_limit; | |
356 } | |
357 | |
358 public function decrementRecursionDepthAndPopLimit($byte_limit) | |
359 { | |
360 $result = $this->consumedEntireMessage(); | |
361 $this->popLimit($byte_limit); | |
362 ++$this->recursion_budget; | |
363 return $result; | |
364 } | |
365 | |
366 public function bytesUntilLimit() | |
367 { | |
368 if ($this->current_limit === PHP_INT_MAX) { | |
369 return -1; | |
370 } | |
371 return $this->current_limit - $this->current; | |
372 } | |
373 } | |
OLD | NEW |