Buffer::getBuffer() - Code Metrics - Inspection of "Merge pull request #616 from Austinb/dns-mocking" - Austinb/GameQ - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — v3 ( 01700e...6888fb )

unknown

created 2022-05-22 20:27 UTC

Buffer::getBuffer() A

↳ Parent: Buffer

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	1
c	1
b	0
f	0
dl	0
loc	4
ccs	2
cts	2
cp	1
rs	10
cc	1
nc	1
nop	0
crap	1

<?php
/**
 * This file is part of GameQ.
 *
 * GameQ is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * GameQ is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *
 */

namespace GameQ;

use GameQ\Exception\Protocol as Exception;

/**
 * Class Buffer
 *
 * Read specific byte sequences from a provided string or Buffer
 *
 * @package GameQ
 *
 * @author  Austin Bischoff <[email protected]>
 * @author  Aidan Lister <[email protected]>
 * @author  Tom Buskens <[email protected]>
 */
class Buffer
{

    /**
     * Constants for the byte code types we need to read as
     */
    const NUMBER_TYPE_BIGENDIAN = 'be',
        NUMBER_TYPE_LITTLEENDIAN = 'le',
        NUMBER_TYPE_MACHINE = 'm';

    /**
     * The number type we use for reading integers.  Defaults to little endian
     *
     * @type string
     */
    private $number_type = self::NUMBER_TYPE_LITTLEENDIAN;

    /**
     * The original data
     *
     * @type string
     */
    private $data;

    /**
     * The original data
     *
     * @type int
     */
    private $length;

    /**
     * Position of pointer
     *
     * @type int
     */
    private $index = 0;

    /**
     * Constructor
     *
     * @param string $data
     * @param string $number_type
     */
    public function __construct($data, $number_type = self::NUMBER_TYPE_LITTLEENDIAN)
    {

        $this->number_type = $number_type;
        $this->data = $data;
        $this->length = strlen($data);
    }

    /**
     * Return all the data
     *
     * @return  string    The data
     */
    public function getData()
    {

        return $this->data;
    }

    /**
     * Return data currently in the buffer
     *
     * @return  string    The data currently in the buffer
     */
    public function getBuffer()
    {

        return substr($this->data, $this->index);
    }

    /**
     * Returns the number of bytes in the buffer
     *
     * @return  int  Length of the buffer
     */
    public function getLength()
    {

        return max($this->length - $this->index, 0);
    }

    /**
     * Read from the buffer
     *
     * @param int $length
     *
     * @return string
     * @throws \GameQ\Exception\Protocol
     */
    public function read($length = 1)
    {

        if (($length + $this->index) > $this->length) {
            throw new Exception("Unable to read length={$length} from buffer.  Bad protocol format or return?");
        }

        $string = substr($this->data, $this->index, $length);
        $this->index += $length;

        return $string;
    }

    /**
     * Read the last character from the buffer
     *
     * Unlike the other read functions, this function actually removes
     * the character from the buffer.
     *
     * @return string
     */
    public function readLast()
    {

        $len = strlen($this->data);
        $string = $this->data[strlen($this->data) - 1];
        $this->data = substr($this->data, 0, $len - 1);
        $this->length -= 1;

        return $string;
    }

    /**
     * Look at the buffer, but don't remove
     *
     * @param int $length
     *
     * @return string
     */
    public function lookAhead($length = 1)
    {

        return substr($this->data, $this->index, $length);
    }

    /**
     * Skip forward in the buffer
     *
     * @param int $length
     */
    public function skip($length = 1)
    {

        $this->index += $length;
    }

    /**
     * Jump to a specific position in the buffer,
     * will not jump past end of buffer
     *
     * @param $index
     */
    public function jumpto($index)
    {

        $this->index = min($index, $this->length - 1);
    }

    /**
     * Get the current pointer position
     *
     * @return int
     */
    public function getPosition()
    {

        return $this->index;
    }

    /**
     * Read from buffer until delimiter is reached
     *
     * If not found, return everything
     *
     * @param string $delim
     *
     * @return string
     * @throws \GameQ\Exception\Protocol
     */
    public function readString($delim = "\x00")
    {

        // Get position of delimiter
        $len = strpos($this->data, $delim, min($this->index, $this->length));

        // If it is not found then return whole buffer
        if ($len === false) {
            return $this->read(strlen($this->data) - $this->index);
        }

        // Read the string and remove the delimiter
        $string = $this->read($len - $this->index);
        ++$this->index;

        return $string;
    }

    /**
     * Reads a pascal string from the buffer
     *
     * @param int  $offset      Number of bits to cut off the end
     * @param bool $read_offset True if the data after the offset is to be read
     *
     * @return string
     * @throws \GameQ\Exception\Protocol
     */
    public function readPascalString($offset = 0, $read_offset = false)
    {

        // Get the proper offset
        $len = $this->readInt8();
        $offset = max($len - $offset, 0);

        // Read the data
        if ($read_offset) {
            return $this->read($offset);
        } else {
            return substr($this->read($len), 0, $offset);
        }
    }

    /**
     * Read from buffer until any of the delimiters is reached
     *
     * If not found, return everything
     *
     * @param              $delims
     * @param null|string &$delimfound
     *
     * @return string
     * @throws \GameQ\Exception\Protocol
     *
     * @todo: Check to see if this is even used anymore
     */
    public function readStringMulti($delims, &$delimfound = null)
    {

        // Get position of delimiters
        $pos = [];
        foreach ($delims as $delim) {
            if ($index = strpos($this->data, $delim, min($this->index, $this->length))) {
                $pos[] = $index;
            }
        }

        // If none are found then return whole buffer
        if (empty($pos)) {
            return $this->read(strlen($this->data) - $this->index);
        }

        // Read the string and remove the delimiter
        sort($pos);
        $string = $this->read($pos[0] - $this->index);
        $delimfound = $this->read();

        return $string;
    }

    /**
     * Read an 8-bit unsigned integer
     *
     * @return int
     * @throws \GameQ\Exception\Protocol
     */
    public function readInt8()
    {

        $int = unpack('Cint', $this->read(1));

        return $int['int'];
    }

    /**
     * Read and 8-bit signed integer
     *
     * @return int
     * @throws \GameQ\Exception\Protocol
     */
    public function readInt8Signed()
    {

        $int = unpack('cint', $this->read(1));

        return $int['int'];
    }

    /**
     * Read a 16-bit unsigned integer
     *
     * @return int
     * @throws \GameQ\Exception\Protocol
     */
    public function readInt16()
    {

        // Change the integer type we are looking up
        switch ($this->number_type) {
            case self::NUMBER_TYPE_BIGENDIAN:
                $type = 'nint';
                break;

            case self::NUMBER_TYPE_LITTLEENDIAN:
                $type = 'vint';
                break;

            default:
                $type = 'Sint';
        }

        $int = unpack($type, $this->read(2));

        return $int['int'];
    }

    /**
     * Read a 16-bit signed integer
     *
     * @return int
     * @throws \GameQ\Exception\Protocol
     */
    public function readInt16Signed()
    {

        // Read the data into a string
        $string = $this->read(2);

        // For big endian we need to reverse the bytes
        if ($this->number_type == self::NUMBER_TYPE_BIGENDIAN) {
            $string = strrev($string);
        }

        $int = unpack('sint', $string);

        unset($string);

        return $int['int'];
    }

    /**
     * Read a 32-bit unsigned integer
     *
     * @return int
     * @throws \GameQ\Exception\Protocol
     */
    public function readInt32($length = 4)
    {
        // Change the integer type we are looking up
        $littleEndian = null;
        switch ($this->number_type) {
            case self::NUMBER_TYPE_BIGENDIAN:
                $type = 'N';
                $littleEndian = false;
                break;

            case self::NUMBER_TYPE_LITTLEENDIAN:
                $type = 'V';
                $littleEndian = true;
                break;

            default:
                $type = 'L';
        }

        // read from the buffer and append/prepend empty bytes for shortened int32
        $corrected = $this->read($length);

        // Unpack the number
        $int = unpack($type . 'int', self::extendBinaryString($corrected, 4, $littleEndian));

        return $int['int'];
    }

    /**
     * Read a 32-bit signed integer
     *
     * @return int
     * @throws \GameQ\Exception\Protocol
     */
    public function readInt32Signed()
    {

        // Read the data into a string
        $string = $this->read(4);

        // For big endian we need to reverse the bytes
        if ($this->number_type == self::NUMBER_TYPE_BIGENDIAN) {
            $string = strrev($string);
        }

        $int = unpack('lint', $string);

        unset($string);

        return $int['int'];
    }

    /**
     * Read a 64-bit unsigned integer
     *
     * @return int
     * @throws \GameQ\Exception\Protocol
     */
    public function readInt64()
    {

        // We have the pack 64-bit codes available. See: http://php.net/manual/en/function.pack.php
        if (version_compare(PHP_VERSION, '5.6.3') >= 0 && PHP_INT_SIZE == 8) {
            // Change the integer type we are looking up
            switch ($this->number_type) {
                case self::NUMBER_TYPE_BIGENDIAN:
                    $type = 'Jint';
                    break;

                case self::NUMBER_TYPE_LITTLEENDIAN:
                    $type = 'Pint';
                    break;

                default:
                    $type = 'Qint';
            }

            $int64 = unpack($type, $this->read(8));

            $int = $int64['int'];

            unset($int64);
        } else {
            if ($this->number_type == self::NUMBER_TYPE_BIGENDIAN) {
                $high = $this->readInt32();
                $low = $this->readInt32();
            } else {
                $low = $this->readInt32();
                $high = $this->readInt32();
            }

            // We have to determine the number via bitwise
            $int = ($high << 32) | $low;

            unset($low, $high);
        }

        return $int;
    }

    /**
     * Read a 32-bit float
     *
     * @return float
     * @throws \GameQ\Exception\Protocol
     */
    public function readFloat32()
    {

        // Read the data into a string
        $string = $this->read(4);

        // For big endian we need to reverse the bytes
        if ($this->number_type == self::NUMBER_TYPE_BIGENDIAN) {
            $string = strrev($string);
        }

        $float = unpack('ffloat', $string);

        unset($string);

        return $float['float'];
    }

    private static function extendBinaryString($input, $length = 4, $littleEndian = null)
    {
        if (is_null($littleEndian)) {
            $littleEndian = self::isLittleEndian();
        }

        $extension = str_repeat(pack($littleEndian ? 'V' : 'N', 0b0000), $length - strlen($input));

        if ($littleEndian) {
            return $input . $extension;
        } else {
            return $extension . $input;
        }
    }

    private static function isLittleEndian()
    {
        return 0x00FF === current(unpack('v', pack('S', 0x00FF)));
    }
}


1		<?php
2		/**
3		* This file is part of GameQ.
4		*
5		* GameQ is free software; you can redistribute it and/or modify
6		* it under the terms of the GNU Lesser General Public License as published by
7		* the Free Software Foundation; either version 3 of the License, or
8		* (at your option) any later version.
9		*
10		* GameQ is distributed in the hope that it will be useful,
11		* but WITHOUT ANY WARRANTY; without even the implied warranty of
12		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13		* GNU Lesser General Public License for more details.
14		*
15		* You should have received a copy of the GNU Lesser General Public License
16		* along with this program. If not, see <http://www.gnu.org/licenses/>.
17		*
18		*
19		*/
20
21		namespace GameQ;
22
23		use GameQ\Exception\Protocol as Exception;
24
25		/**
26		* Class Buffer
27		*
28		* Read specific byte sequences from a provided string or Buffer
29		*
30		* @package GameQ
31		*
32		* @author Austin Bischoff <[email protected]>
33		* @author Aidan Lister <[email protected]>
34		* @author Tom Buskens <[email protected]>
35		*/
36		class Buffer
37		{
38
39		/**
40		* Constants for the byte code types we need to read as
41		*/
42		const NUMBER_TYPE_BIGENDIAN = 'be',
43		NUMBER_TYPE_LITTLEENDIAN = 'le',
44		NUMBER_TYPE_MACHINE = 'm';
45
46		/**
47		* The number type we use for reading integers. Defaults to little endian
48		*
49		* @type string
50		*/
51		private $number_type = self::NUMBER_TYPE_LITTLEENDIAN;
52
53		/**
54		* The original data
55		*
56		* @type string
57		*/
58		private $data;
59
60		/**
61		* The original data
62		*
63		* @type int
64		*/
65		private $length;
66
67		/**
68		* Position of pointer
69		*
70		* @type int
71		*/
72		private $index = 0;
73
74		/**
75		* Constructor
76		*
77		* @param string $data
78		* @param string $number_type
79		*/
80	1740	public function __construct($data, $number_type = self::NUMBER_TYPE_LITTLEENDIAN)
81		{
82
83	1740	$this->number_type = $number_type;
84	1740	$this->data = $data;
85	1740	$this->length = strlen($data);
86	1160	}
87
88		/**
89		* Return all the data
90		*
91		* @return string The data
92		*/
93	12	public function getData()
94		{
95
96	12	return $this->data;
97		}
98
99		/**
100		* Return data currently in the buffer
101		*
102		* @return string The data currently in the buffer
103		*/
104	1224	public function getBuffer()
105		{
106
107	1224	return substr($this->data, $this->index);
108		}
109
110		/**
111		* Returns the number of bytes in the buffer
112		*
113		* @return int Length of the buffer
114		*/
115	1152	public function getLength()
116		{
117
118	1152	return max($this->length - $this->index, 0);
119		}
120
121		/**
122		* Read from the buffer
123		*
124		* @param int $length
125		*
126		* @return string
127		* @throws \GameQ\Exception\Protocol
128		*/
129	1656	public function read($length = 1)
130		{
131
132	1656	if (($length + $this->index) > $this->length) {
133	12	throw new Exception("Unable to read length={$length} from buffer. Bad protocol format or return?");
134		}
135
136	1644	$string = substr($this->data, $this->index, $length);
137	1644	$this->index += $length;
138
139	1644	return $string;
140		}
141
142		/**
143		* Read the last character from the buffer
144		*
145		* Unlike the other read functions, this function actually removes
146		* the character from the buffer.
147		*
148		* @return string
149		*/
150	6	public function readLast()
151		{
152
153	6	$len = strlen($this->data);
154	6	$string = $this->data[strlen($this->data) - 1];
155	6	$this->data = substr($this->data, 0, $len - 1);
156	6	$this->length -= 1;
157
158	6	return $string;
159		}
160
161		/**
162		* Look at the buffer, but don't remove
163		*
164		* @param int $length
165		*
166		* @return string
167		*/
168	888	public function lookAhead($length = 1)
169		{
170
171	888	return substr($this->data, $this->index, $length);
172		}
173
174		/**
175		* Skip forward in the buffer
176		*
177		* @param int $length
178		*/
179	384	public function skip($length = 1)
180		{
181
182	384	$this->index += $length;
183	256	}
184
185		/**
186		* Jump to a specific position in the buffer,
187		* will not jump past end of buffer
188		*
189		* @param $index
190		*/
191	54	public function jumpto($index)
192		{
193
194	54	$this->index = min($index, $this->length - 1);
195	36	}
196
197		/**
198		* Get the current pointer position
199		*
200		* @return int
201		*/
202	6	public function getPosition()
203		{
204
205	6	return $this->index;
206		}
207
208		/**
209		* Read from buffer until delimiter is reached
210		*
211		* If not found, return everything
212		*
213		* @param string $delim
214		*
215		* @return string
216		* @throws \GameQ\Exception\Protocol
217		*/
218	1200	public function readString($delim = "\x00")
219		{
220
221		// Get position of delimiter
222	1200	$len = strpos($this->data, $delim, min($this->index, $this->length));
223
224		// If it is not found then return whole buffer
225	1200	if ($len === false) {
226	156	return $this->read(strlen($this->data) - $this->index);
227		}
228
229		// Read the string and remove the delimiter
230	1200	$string = $this->read($len - $this->index);
231	1200	++$this->index;
232
233	1200	return $string;
234		}
235
236		/**
237		* Reads a pascal string from the buffer
238		*
239		* @param int $offset Number of bits to cut off the end
240		* @param bool $read_offset True if the data after the offset is to be read
241		*
242		* @return string
243		* @throws \GameQ\Exception\Protocol
244		*/
245	72	public function readPascalString($offset = 0, $read_offset = false)
246		{
247
248		// Get the proper offset
249	72	$len = $this->readInt8();
250	72	$offset = max($len - $offset, 0);
251
252		// Read the data
253	72	if ($read_offset) {
254	30	return $this->read($offset);
255		} else {
256	42	return substr($this->read($len), 0, $offset);
257		}
258		}
259
260		/**
261		* Read from buffer until any of the delimiters is reached
262		*
263		* If not found, return everything
264		*
265		* @param $delims
266		* @param null\|string &$delimfound
267		*
268		* @return string
269		* @throws \GameQ\Exception\Protocol
270		*
271		* @todo: Check to see if this is even used anymore
272		*/
273	174	public function readStringMulti($delims, &$delimfound = null)
274		{
275
276		// Get position of delimiters
277	174	$pos = [];
278	174	foreach ($delims as $delim) {
279	174	if ($index = strpos($this->data, $delim, min($this->index, $this->length))) {
280	174	$pos[] = $index;
281	29	}
282	29	}
283
284		// If none are found then return whole buffer
285	174	if (empty($pos)) {
286	174	return $this->read(strlen($this->data) - $this->index);
287		}
288
289		// Read the string and remove the delimiter
290	174	sort($pos);
291	174	$string = $this->read($pos[0] - $this->index);
292	174	$delimfound = $this->read();
293
294	174	return $string;
295		}
296
297		/**
298		* Read an 8-bit unsigned integer
299		*
300		* @return int
301		* @throws \GameQ\Exception\Protocol
302		*/
303	924	public function readInt8()
304		{
305
306	924	$int = unpack('Cint', $this->read(1));
307
308	924	return $int['int'];
309		}
310
311		/**
312		* Read and 8-bit signed integer
313		*
314		* @return int
315		* @throws \GameQ\Exception\Protocol
316		*/
317	30	public function readInt8Signed()
318		{
319
320	30	$int = unpack('cint', $this->read(1));
321
322	30	return $int['int'];
323		}
324
325		/**
326		* Read a 16-bit unsigned integer
327		*
328		* @return int
329		* @throws \GameQ\Exception\Protocol
330		*/
331	720	public function readInt16()
332		{
333
334		// Change the integer type we are looking up
335	720	switch ($this->number_type) {
336	720	case self::NUMBER_TYPE_BIGENDIAN:
337	30	$type = 'nint';
338	30	break;
339
340	690	case self::NUMBER_TYPE_LITTLEENDIAN:
341	678	$type = 'vint';
342	678	break;
343
344	2	default:
345	12	$type = 'Sint';
346	120	}
347
348	720	$int = unpack($type, $this->read(2));
349
350	720	return $int['int'];
351		}
352
353		/**
354		* Read a 16-bit signed integer
355		*
356		* @return int
357		* @throws \GameQ\Exception\Protocol
358		*/
359	690	public function readInt16Signed()
360		{
361
362		// Read the data into a string
363	690	$string = $this->read(2);
364
365		// For big endian we need to reverse the bytes
366	690	if ($this->number_type == self::NUMBER_TYPE_BIGENDIAN) {
367	18	$string = strrev($string);
368	3	}
369
370	690	$int = unpack('sint', $string);
371
372	690	unset($string);
373
374	690	return $int['int'];
375		}
376
377		/**
378		* Read a 32-bit unsigned integer
379		*
380		* @return int
381		* @throws \GameQ\Exception\Protocol
382		*/
383	312	public function readInt32($length = 4)
384		{
385		// Change the integer type we are looking up
386	312	$littleEndian = null;
387	312	switch ($this->number_type) {
388	312	case self::NUMBER_TYPE_BIGENDIAN:
389	144	$type = 'N';
390	144	$littleEndian = false;
391	144	break;
392
393	168	case self::NUMBER_TYPE_LITTLEENDIAN:
394	156	$type = 'V';
395	156	$littleEndian = true;
396	156	break;
397
398	2	default:
399	12	$type = 'L';
400	52	}
401
402		// read from the buffer and append/prepend empty bytes for shortened int32
403	312	$corrected = $this->read($length);
404
405		// Unpack the number
406	312	$int = unpack($type . 'int', self::extendBinaryString($corrected, 4, $littleEndian));
407
408	312	return $int['int'];
409		}
410
411		/**
412		* Read a 32-bit signed integer
413		*
414		* @return int
415		* @throws \GameQ\Exception\Protocol
416		*/
417	708	public function readInt32Signed()
418		{
419
420		// Read the data into a string
421	708	$string = $this->read(4);
422
423		// For big endian we need to reverse the bytes
424	708	if ($this->number_type == self::NUMBER_TYPE_BIGENDIAN) {
425	18	$string = strrev($string);
426	3	}
427
428	708	$int = unpack('lint', $string);
429
430	708	unset($string);
431
432	708	return $int['int'];
433		}
434
435		/**
436		* Read a 64-bit unsigned integer
437		*
438		* @return int
439		* @throws \GameQ\Exception\Protocol
440		*/
441	636	public function readInt64()
442		{
443
444		// We have the pack 64-bit codes available. See: http://php.net/manual/en/function.pack.php
445	636	if (version_compare(PHP_VERSION, '5.6.3') >= 0 && PHP_INT_SIZE == 8) {
446		// Change the integer type we are looking up
447	636	switch ($this->number_type) {
448	636	case self::NUMBER_TYPE_BIGENDIAN:
449	18	$type = 'Jint';
450	18	break;
451
452	618	case self::NUMBER_TYPE_LITTLEENDIAN:
453	606	$type = 'Pint';
454	606	break;
455
456	2	default:
457	12	$type = 'Qint';
458	106	}
459
460	636	$int64 = unpack($type, $this->read(8));
461
462	636	$int = $int64['int'];
463
464	636	unset($int64);
465	106	} else {
466		if ($this->number_type == self::NUMBER_TYPE_BIGENDIAN) {
467		$high = $this->readInt32();
468		$low = $this->readInt32();
469		} else {
470		$low = $this->readInt32();
471		$high = $this->readInt32();
472		}
473
474		// We have to determine the number via bitwise
475		$int = ($high << 32) \| $low;
476
477		unset($low, $high);
478		}
479
480	636	return $int;
481		}
482
483		/**
484		* Read a 32-bit float
485		*
486		* @return float
487		* @throws \GameQ\Exception\Protocol
488		*/
489	498	public function readFloat32()
490		{
491
492		// Read the data into a string
493	498	$string = $this->read(4);
494
495		// For big endian we need to reverse the bytes
496	498	if ($this->number_type == self::NUMBER_TYPE_BIGENDIAN) {
497	18	$string = strrev($string);
498	3	}
499
500	498	$float = unpack('ffloat', $string);
501
502	498	unset($string);
503
504	498	return $float['float'];
505		}
506
507	312	private static function extendBinaryString($input, $length = 4, $littleEndian = null)
508		{
509	312	if (is_null($littleEndian)) {
510	12	$littleEndian = self::isLittleEndian();
511	2	}
512
513	312	$extension = str_repeat(pack($littleEndian ? 'V' : 'N', 0b0000), $length - strlen($input));
514
515	312	if ($littleEndian) {
516	168	return $input . $extension;
517		} else {
518	144	return $extension . $input;
519		}
520		}
521
522	12	private static function isLittleEndian()
523		{
524	12	return 0x00FF === current(unpack('v', pack('S', 0x00FF)));
525		}
526		}
527

Austinb / GameQ

Push — v3 ( 01700e...6888fb )

Buffer::getBuffer() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like