Issues in Binary.php (master) - Issues in master - kakserpom/phpdaemon - Measure and Improve Code Quality continuously with Scrutinizer

Issues (1507)

Security Analysis not enabled

Cross-Site Scripting

Cross-Site Scripting enables an attacker to inject code into the response of a web-request that is viewed by other users. It can for example be used to bypass access controls, or even to take over other users' accounts.

File Exposure

File Exposure allows an attacker to gain access to local files that he should not be able to access. These files can for example include database credentials, or other configuration files.

File Manipulation

File Manipulation enables an attacker to write custom data to files. This potentially leads to injection of arbitrary code on the server.

Object Injection

Object Injection enables an attacker to inject an object into PHP code, and can lead to arbitrary code execution, file exposure, or file manipulation attacks.

Code Injection

Code Injection enables an attacker to execute arbitrary code on the server.

Response Splitting

Response Splitting can be used to send arbitrary responses.

File Inclusion

File Inclusion enables an attacker to inject custom files into PHP's file loading mechanism, either explicitly passed to include, or for example via PHP's auto-loading mechanism.

Command Injection

Command Injection enables an attacker to inject a shell command that is execute with the privileges of the web-server. This can be used to expose sensitive data, or gain access of your server.

SQL Injection

SQL Injection enables an attacker to execute arbitrary SQL code on your database server gaining access to user data, or manipulating user data.

XPath Injection

XPath Injection enables an attacker to modify the parts of XML document that are read. If that XML document is for example used for authentication, this can lead to further vulnerabilities similar to SQL Injection.

LDAP Injection

LDAP Injection enables an attacker to inject LDAP statements potentially granting permission to run unauthorized queries, or modify content inside the LDAP tree.

Header Injection

Other Vulnerability

This category comprises other attack vectors such as manipulating the PHP runtime, loading custom extensions, freezing the runtime, or similar.

Regex Injection

Regex Injection enables an attacker to execute arbitrary code in your PHP process.

XML Injection

XML Injection enables an attacker to read files on your local filesystem including configuration files, or can be abused to freeze your web-server process.

Variable Injection

Variable Injection enables an attacker to overwrite program variables with custom data, and can lead to further vulnerabilities.

Unfortunately, the security analysis is currently not available for your project. If you are a non-commercial open-source project, please contact support to gain access.

PHPDaemon/Utils/Binary.php (9 issues)

Labels

Severity

Informational 9

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php
namespace PHPDaemon\Utils;

use PHPDaemon\Core\Daemon;
use PHPDaemon\Core\Debug;

/**
 * Binary
 * @package PHPDaemon\Utils
 * @author  Vasily Zorin <[email protected]>
 */
class Binary
{
    use \PHPDaemon\Traits\ClassWatchdog;
    use \PHPDaemon\Traits\StaticObjectWatchdog;

    /**
     * Build structure of labels
     * @param  string $q Dot-separated labels list
     * @return string
     */
    public static function labels($q)
    {
        $e = explode('.', $q);
        $r = '';
        for ($i = 0, $s = sizeof($e); $i < $s; ++$i) {
            $r .= chr(mb_orig_strlen($e[$i])) . $e[$i];
        }
        if (mb_orig_substr($r, -1) !== "\x00") {
            $r .= "\x00";
        }
        return $r;
    }

    /**
     * Parse structure of labels
     * @param  string &$data Binary data
     * @param  string $orig Original packet

     * @return string        Dot-separated labels list
     */
    public static function parseLabels(&$data, $orig = null)
    {
        $str = '';
        while (mb_orig_strlen($data) > 0) {
            $l = ord($data[0]);

            if ($l >= 192) {
                $pos = Binary::bytes2int(chr($l - 192) . mb_orig_substr($data, 1, 1));
                $data = mb_orig_substr($data, 2);
                $ref = mb_orig_substr($orig, $pos);
                return $str . Binary::parseLabels($ref, $orig);
            }

            $p = mb_orig_substr($data, 1, $l);
            $str .= $p . (($l !== 0) ? '.' : '');
            $data = mb_orig_substr($data, $l + 1);
            if ($l === 0) {
                break;
            }
        }
        return $str;
    }

    /**
     * Convert bytes into integer
     * @param  string $str Bytes
     * @param  boolean $l Little endian? Default is false
     * @return integer

     */
    public static function bytes2int($str, $l = false)

    {
        if ($l) {
            $str = strrev($str);
        }
        $dec = 0;
        $len = mb_orig_strlen($str);
        for ($i = 0; $i < $len; ++$i) {
            $dec += ord(mb_orig_substr($str, $i, 1)) * pow(0x100, $len - $i - 1);
        }
        return $dec;
    }

    /**
     * Build nul-terminated string, with 2-byte of length
     * @param string $str Data
     * @return string
     */
    public static function LVnull($str)
    {
        return static::LV($str . "\x00", 2, true);
    }

    /**
     * Build length-value binary snippet
     * @param string $str Data
     * @param integer $len Number of bytes to encode length. Default is 1
     * @param boolean $lrev Reverse?
     * @return string
     */
    public static function LV($str, $len = 1, $lrev = false)
    {
        $l = static::i2b($len, mb_orig_strlen($str));
        if ($lrev) {
            $l = strrev($l);
        }
        return $l . $str;
    }

    /**
     * Converts integer to binary string
     * @alias Binary::int2bytes
     * @param  integer $len Length
     * @param  integer $int Integer
     * @param  boolean $l Optional. Little endian. Default value - false
     * @return string       Resulting binary string
     */
    public static function i2b($len, $int = 0, $l = false)
    {
        return static::int2bytes($len, $int, $l);
    }

    /**
     * Converts integer to binary string
     * @param  integer $len Length
     * @param  integer $int Integer
     * @param  boolean $l Optional. Little endian. Default value - false
     * @return string       Resulting binary string
     */
    public static function int2bytes($len, $int = 0, $l = false)

    {
        $hexstr = dechex($int);

        if ($len === null) {
            if (mb_orig_strlen($hexstr) % 2) {
                $hexstr = "0" . $hexstr;
            }
        } else {
            $hexstr = str_repeat('0', $len * 2 - mb_orig_strlen($hexstr)) . $hexstr;
        }

        $bytes = mb_orig_strlen($hexstr) / 2;
        $bin = '';

        for ($i = 0; $i < $bytes; ++$i) {
            $bin .= chr(hexdec(substr($hexstr, $i * 2, 2)));
        }

        return $l ? strrev($bin) : $bin;
    }

    /**
     * Build byte
     * @param  integer $int Byte number
     * @return string
     */
    public static function byte($int)
    {
        return chr($int);
    }

    /**
     * Build word (2 bytes) little-endian
     * @param  integer $int Integer
     * @return string
     */
    public static function wordl($int)
    {
        return strrev(static::word($int));
    }

    /**
     * Build word (2 bytes) big-endian
     * @param  integer $int Integer
     * @return string
     */
    public static function word($int)
    {
        return static::i2b(2, $int);
    }

    /**
     * Build double word (4 bytes) little endian
     * @param  integer $int Integer
     * @return string
     */
    public static function dwordl($int)
    {
        return strrev(static::dword($int));
    }

    /**
     * Build double word (4 bytes) big-endian
     * @param  integer $int Integer
     * @return string
     */
    public static function dword($int)
    {
        return static::i2b(4, $int);
    }

    /**
     * Build quadro word (8 bytes) little endian
     * @param  integer $int Integer
     * @return string
     */
    public static function qwordl($int)
    {
        return strrev(static::qword($int));
    }

    /**
     * Build quadro word (8 bytes) big endian
     * @param  integer $int Integer
     * @return string
     */
    public static function qword($int)
    {
        return static::i2b(8, $int);
    }

    /**
     * Parse byte, and remove it
     * @param  string &$p Data
     * @return integer
     */
    public static function getByte(&$p)
    {
        $r = static::bytes2int($p[0]);
        $p = mb_orig_substr($p, 1);
        return (int)$r;
    }

    /**
     * Get single-byte character
     * @param  string &$p Data
     * @return string
     */
    public static function getChar(&$p)
    {
        $r = $p[0];
        $p = mb_orig_substr($p, 1);
        return $r;
    }

    /**
     * Parse word (2 bytes)
     * @param  string &$p Data
     * @param  boolean $l Little endian?
     * @return integer
     */
    public static function getWord(&$p, $l = false)
    {
        $r = static::bytes2int(mb_orig_substr($p, 0, 2), !!$l);
        $p = mb_orig_substr($p, 2);
        return (int)$r;
    }

    /**
     * Get word (2 bytes)
     * @param  string &$p Data
     * @param  boolean $l Little endian?
     * @return string
     */
    public static function getStrWord(&$p, $l = false)

    {
        $r = mb_orig_substr($p, 0, 2);
        $p = mb_orig_substr($p, 2);
        if ($l) {
            $r = strrev($r);
        }
        return $r;
    }

    /**
     * Get double word (4 bytes)
     * @param  string &$p Data
     * @param  boolean $l Little endian?
     * @return integer
     */
    public static function getDWord(&$p, $l = false)
    {
        $r = static::bytes2int(mb_orig_substr($p, 0, 4), !!$l);
        $p = mb_orig_substr($p, 4);
        return (int)$r;
    }

    /**
     * Parse quadro word (8 bytes)
     * @param  string &$p Data
     * @param  boolean $l Little endian?
     * @return integer
     */
    public static function getQword(&$p, $l = false)
    {
        $r = static::bytes2int(mb_orig_substr($p, 0, 8), !!$l);
        $p = mb_orig_substr($p, 8);
        return (int)$r;
    }

    /**
     * Get quadro word (8 bytes)
     * @param  string &$p Data
     * @param  boolean $l Little endian?
     * @return string
     */
    public static function getStrQWord(&$p, $l = false)

    {
        $r = mb_orig_substr($p, 0, 8);
        if ($l) {
            $r = strrev($r);
        }
        $p = mb_orig_substr($p, 8);
        return $r;
    }

    /**
     * Parse nul-terminated string
     * @param  string &$str Data
     * @return string
     */
    public static function getString(&$str)

    {
        $p = mb_orig_strpos($str, "\x00");
        if ($p === false) {
            return '';
        }
        $r = mb_orig_substr($str, 0, $p);
        $str = mb_orig_substr($str, $p + 1);
        return $r;
    }

    /**
     * Parse length-value structure
     * @param  string &$p Data
     * @param  integer $l Number of length bytes
     * @param  boolean $nul Nul-terminated? Default is false
     * @param  boolean $lrev Length is little endian?
     * @return string
     */
    public static function getLV(&$p, $l = 1, $nul = false, $lrev = false)
    {
        $s = static::b2i(mb_orig_substr($p, 0, $l), !!$lrev);
        $p = mb_orig_substr($p, $l);
        if ($s === 0) {
            return '';
        }
        $r = '';
        if (mb_orig_strlen($p) < $s) {
            Daemon::log('getLV error: buf length (' . mb_orig_strlen($p) . '): ' . Debug::exportBytes($p) . ', must be >= string length (' . $s . ")\n");
        } elseif ($nul) {
            $lastByte = mb_orig_substr($p, -1);
            if ($lastByte !== "\x00") {
                Daemon:
                log('getLV error: Wrong end of NUL-string (' . Debug::exportBytes($lastByte) . '), len ' . $s . "\n");
            } else {
                $d = $s - 1;
                if ($d < 0) {
                    $d = 0;
                }
                $r = mb_orig_substr($p, 0, $d);
                $p = mb_orig_substr($p, $s);
            }
        } else {
            $r = mb_orig_substr($p, 0, $s);
            $p = mb_orig_substr($p, $s);
        }
        return $r;
    }

    /**
     * Convert bytes into integer
     * @alias Binary::bytes2int
     * @param  string $str Bytes

     * @param  boolean $l Little endian? Default is false
     * @return integer

     */
    public static function b2i($str = 0, $l = false)
    {
        return static::bytes2int($str, $l);
    }

    /**
     * Convert array of flags into bit array
     * @param  array $flags Flags
     * @param  integer $len Length. Default is 4
     * @return string
     */
    public static function flags2bitarray($flags, $len = 4)
    {
        $ret = 0;
        foreach ($flags as $v) {
            $ret |= $v;
        }
        return static::i2b($len, $ret);
    }

    /**
     * Convert bitmap into bytes
     * @param  string $bitmap Bitmap
     * @param  integer $check_len Check length?
     * @return string|false
     */
    public static function bitmap2bytes($bitmap, $check_len = 0)
    {
        $r = '';
        $bitmap = str_pad($bitmap, ceil(mb_orig_strlen($bitmap) / 8) * 8, '0', STR_PAD_LEFT);
        for ($i = 0, $n = mb_orig_strlen($bitmap) / 8; $i < $n; ++$i) {
            $r .= chr((int)bindec(mb_orig_substr($bitmap, $i * 8, 8)));
        }
        if ($check_len && (mb_orig_strlen($r) !== $check_len)) {
            return false;
        }
        return $r;
    }

    /**
     * Get bitmap
     * @param  integer $byte Byte
     * @return string
     */
    public static function getbitmap($byte)
    {
        return sprintf('%08b', $byte);
    }
}


1		<?php
2		namespace PHPDaemon\Utils;
3
4		use PHPDaemon\Core\Daemon;
5		use PHPDaemon\Core\Debug;
6
7		/**
8		* Binary
9		* @package PHPDaemon\Utils
10		* @author Vasily Zorin <[email protected]>
11		*/
12		class Binary
13		{
14		use \PHPDaemon\Traits\ClassWatchdog;
15		use \PHPDaemon\Traits\StaticObjectWatchdog;
16
17		/**
18		* Build structure of labels
19		* @param string $q Dot-separated labels list
20		* @return string
21		*/
22		public static function labels($q)
23		{
24		$e = explode('.', $q);
25		$r = '';
26		for ($i = 0, $s = sizeof($e); $i < $s; ++$i) {
27		$r .= chr(mb_orig_strlen($e[$i])) . $e[$i];
28		}
29		if (mb_orig_substr($r, -1) !== "\x00") {
30		$r .= "\x00";
31		}
32		return $r;
33		}
34
35		/**
36		* Parse structure of labels
37		* @param string &$data Binary data
38		* @param string $orig Original packet
		0 ignored issues – show Documentation introduced 2015-12-06 14:42 UTC by Report Bug Copy Issue Report Show Similar Issues like this Should the type for parameter `$orig` not be `string\|null`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
39		* @return string Dot-separated labels list
40		*/
41		public static function parseLabels(&$data, $orig = null)
42		{
43		$str = '';
44		while (mb_orig_strlen($data) > 0) {
45		$l = ord($data[0]);
46
47		if ($l >= 192) {
48		$pos = Binary::bytes2int(chr($l - 192) . mb_orig_substr($data, 1, 1));
49		$data = mb_orig_substr($data, 2);
50		$ref = mb_orig_substr($orig, $pos);
51		return $str . Binary::parseLabels($ref, $orig);
52		}
53
54		$p = mb_orig_substr($data, 1, $l);
55		$str .= $p . (($l !== 0) ? '.' : '');
56		$data = mb_orig_substr($data, $l + 1);
57		if ($l === 0) {
58		break;
59		}
60		}
61		return $str;
62		}
63
64		/**
65		* Convert bytes into integer
66		* @param string $str Bytes
67		* @param boolean $l Little endian? Default is false
68		* @return integer
		0 ignored issues – show Documentation introduced 2016-05-18 23:30 UTC by Report Bug Copy Issue Report Show Similar Issues like this Should the return type not be `integer\|double`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
69		*/
70	View Code Duplication	public static function bytes2int($str, $l = false)
		0 ignored issues – show Duplication introduced 2015-12-06 14:42 UTC by Report Bug Copy Issue Report Show Similar Issues like this This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
71		{
72		if ($l) {
73		$str = strrev($str);
74		}
75		$dec = 0;
76		$len = mb_orig_strlen($str);
77		for ($i = 0; $i < $len; ++$i) {
78		$dec += ord(mb_orig_substr($str, $i, 1)) * pow(0x100, $len - $i - 1);
79		}
80		return $dec;
81		}
82
83		/**
84		* Build nul-terminated string, with 2-byte of length
85		* @param string $str Data
86		* @return string
87		*/
88		public static function LVnull($str)
89		{
90		return static::LV($str . "\x00", 2, true);
91		}
92
93		/**
94		* Build length-value binary snippet
95		* @param string $str Data
96		* @param integer $len Number of bytes to encode length. Default is 1
97		* @param boolean $lrev Reverse?
98		* @return string
99		*/
100		public static function LV($str, $len = 1, $lrev = false)
101		{
102		$l = static::i2b($len, mb_orig_strlen($str));
103		if ($lrev) {
104		$l = strrev($l);
105		}
106		return $l . $str;
107		}
108
109		/**
110		* Converts integer to binary string
111		* @alias Binary::int2bytes
112		* @param integer $len Length
113		* @param integer $int Integer
114		* @param boolean $l Optional. Little endian. Default value - false
115		* @return string Resulting binary string
116		*/
117		public static function i2b($len, $int = 0, $l = false)
118		{
119		return static::int2bytes($len, $int, $l);
120		}
121
122		/**
123		* Converts integer to binary string
124		* @param integer $len Length
125		* @param integer $int Integer
126		* @param boolean $l Optional. Little endian. Default value - false
127		* @return string Resulting binary string
128		*/
129	View Code Duplication	public static function int2bytes($len, $int = 0, $l = false)
		0 ignored issues – show Duplication introduced 2015-12-06 14:42 UTC by Report Bug Copy Issue Report Show Similar Issues like this This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
130		{
131		$hexstr = dechex($int);
132
133		if ($len === null) {
134		if (mb_orig_strlen($hexstr) % 2) {
135		$hexstr = "0" . $hexstr;
136		}
137		} else {
138		$hexstr = str_repeat('0', $len * 2 - mb_orig_strlen($hexstr)) . $hexstr;
139		}
140
141		$bytes = mb_orig_strlen($hexstr) / 2;
142		$bin = '';
143
144		for ($i = 0; $i < $bytes; ++$i) {
145		$bin .= chr(hexdec(substr($hexstr, $i * 2, 2)));
146		}
147
148		return $l ? strrev($bin) : $bin;
149		}
150
151		/**
152		* Build byte
153		* @param integer $int Byte number
154		* @return string
155		*/
156		public static function byte($int)
157		{
158		return chr($int);
159		}
160
161		/**
162		* Build word (2 bytes) little-endian
163		* @param integer $int Integer
164		* @return string
165		*/
166		public static function wordl($int)
167		{
168		return strrev(static::word($int));
169		}
170
171		/**
172		* Build word (2 bytes) big-endian
173		* @param integer $int Integer
174		* @return string
175		*/
176		public static function word($int)
177		{
178		return static::i2b(2, $int);
179		}
180
181		/**
182		* Build double word (4 bytes) little endian
183		* @param integer $int Integer
184		* @return string
185		*/
186		public static function dwordl($int)
187		{
188		return strrev(static::dword($int));
189		}
190
191		/**
192		* Build double word (4 bytes) big-endian
193		* @param integer $int Integer
194		* @return string
195		*/
196		public static function dword($int)
197		{
198		return static::i2b(4, $int);
199		}
200
201		/**
202		* Build quadro word (8 bytes) little endian
203		* @param integer $int Integer
204		* @return string
205		*/
206		public static function qwordl($int)
207		{
208		return strrev(static::qword($int));
209		}
210
211		/**
212		* Build quadro word (8 bytes) big endian
213		* @param integer $int Integer
214		* @return string
215		*/
216		public static function qword($int)
217		{
218		return static::i2b(8, $int);
219		}
220
221		/**
222		* Parse byte, and remove it
223		* @param string &$p Data
224		* @return integer
225		*/
226		public static function getByte(&$p)
227		{
228		$r = static::bytes2int($p[0]);
229		$p = mb_orig_substr($p, 1);
230		return (int)$r;
231		}
232
233		/**
234		* Get single-byte character
235		* @param string &$p Data
236		* @return string
237		*/
238		public static function getChar(&$p)
239		{
240		$r = $p[0];
241		$p = mb_orig_substr($p, 1);
242		return $r;
243		}
244
245		/**
246		* Parse word (2 bytes)
247		* @param string &$p Data
248		* @param boolean $l Little endian?
249		* @return integer
250		*/
251		public static function getWord(&$p, $l = false)
252		{
253		$r = static::bytes2int(mb_orig_substr($p, 0, 2), !!$l);
254		$p = mb_orig_substr($p, 2);
255		return (int)$r;
256		}
257
258		/**
259		* Get word (2 bytes)
260		* @param string &$p Data
261		* @param boolean $l Little endian?
262		* @return string
263		*/
264	View Code Duplication	public static function getStrWord(&$p, $l = false)
		0 ignored issues – show Duplication introduced 2015-12-06 14:42 UTC by Report Bug Copy Issue Report Show Similar Issues like this This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
265		{
266		$r = mb_orig_substr($p, 0, 2);
267		$p = mb_orig_substr($p, 2);
268		if ($l) {
269		$r = strrev($r);
270		}
271		return $r;
272		}
273
274		/**
275		* Get double word (4 bytes)
276		* @param string &$p Data
277		* @param boolean $l Little endian?
278		* @return integer
279		*/
280		public static function getDWord(&$p, $l = false)
281		{
282		$r = static::bytes2int(mb_orig_substr($p, 0, 4), !!$l);
283		$p = mb_orig_substr($p, 4);
284		return (int)$r;
285		}
286
287		/**
288		* Parse quadro word (8 bytes)
289		* @param string &$p Data
290		* @param boolean $l Little endian?
291		* @return integer
292		*/
293		public static function getQword(&$p, $l = false)
294		{
295		$r = static::bytes2int(mb_orig_substr($p, 0, 8), !!$l);
296		$p = mb_orig_substr($p, 8);
297		return (int)$r;
298		}
299
300		/**
301		* Get quadro word (8 bytes)
302		* @param string &$p Data
303		* @param boolean $l Little endian?
304		* @return string
305		*/
306	View Code Duplication	public static function getStrQWord(&$p, $l = false)
		0 ignored issues – show Duplication introduced 2015-12-06 14:42 UTC by Report Bug Copy Issue Report Show Similar Issues like this This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
307		{
308		$r = mb_orig_substr($p, 0, 8);
309		if ($l) {
310		$r = strrev($r);
311		}
312		$p = mb_orig_substr($p, 8);
313		return $r;
314		}
315
316		/**
317		* Parse nul-terminated string
318		* @param string &$str Data
319		* @return string
320		*/
321	View Code Duplication	public static function getString(&$str)
		0 ignored issues – show Duplication introduced 2015-12-06 14:42 UTC by Report Bug Copy Issue Report Show Similar Issues like this This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
322		{
323		$p = mb_orig_strpos($str, "\x00");
324		if ($p === false) {
325		return '';
326		}
327		$r = mb_orig_substr($str, 0, $p);
328		$str = mb_orig_substr($str, $p + 1);
329		return $r;
330		}
331
332		/**
333		* Parse length-value structure
334		* @param string &$p Data
335		* @param integer $l Number of length bytes
336		* @param boolean $nul Nul-terminated? Default is false
337		* @param boolean $lrev Length is little endian?
338		* @return string
339		*/
340		public static function getLV(&$p, $l = 1, $nul = false, $lrev = false)
341		{
342		$s = static::b2i(mb_orig_substr($p, 0, $l), !!$lrev);
343		$p = mb_orig_substr($p, $l);
344		if ($s === 0) {
345		return '';
346		}
347		$r = '';
348		if (mb_orig_strlen($p) < $s) {
349		Daemon::log('getLV error: buf length (' . mb_orig_strlen($p) . '): ' . Debug::exportBytes($p) . ', must be >= string length (' . $s . ")\n");
350		} elseif ($nul) {
351		$lastByte = mb_orig_substr($p, -1);
352		if ($lastByte !== "\x00") {
353		Daemon:
354		log('getLV error: Wrong end of NUL-string (' . Debug::exportBytes($lastByte) . '), len ' . $s . "\n");
355		} else {
356		$d = $s - 1;
357		if ($d < 0) {
358		$d = 0;
359		}
360		$r = mb_orig_substr($p, 0, $d);
361		$p = mb_orig_substr($p, $s);
362		}
363		} else {
364		$r = mb_orig_substr($p, 0, $s);
365		$p = mb_orig_substr($p, $s);
366		}
367		return $r;
368		}
369
370		/**
371		* Convert bytes into integer
372		* @alias Binary::bytes2int
373		* @param string $str Bytes
		0 ignored issues – show Documentation introduced 2015-12-06 14:42 UTC by Report Bug Copy Issue Report Show Similar Issues like this Should the type for parameter `$str` not be `integer`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
374		* @param boolean $l Little endian? Default is false
375		* @return integer
		0 ignored issues – show Documentation introduced 2016-05-12 20:55 UTC by Report Bug Copy Issue Report Show Similar Issues like this Should the return type not be `integer\|double`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
376		*/
377		public static function b2i($str = 0, $l = false)
378		{
379		return static::bytes2int($str, $l);
380		}
381
382		/**
383		* Convert array of flags into bit array
384		* @param array $flags Flags
385		* @param integer $len Length. Default is 4
386		* @return string
387		*/
388		public static function flags2bitarray($flags, $len = 4)
389		{
390		$ret = 0;
391		foreach ($flags as $v) {
392		$ret \|= $v;
393		}
394		return static::i2b($len, $ret);
395		}
396
397		/**
398		* Convert bitmap into bytes
399		* @param string $bitmap Bitmap
400		* @param integer $check_len Check length?
401		* @return string\|false
402		*/
403		public static function bitmap2bytes($bitmap, $check_len = 0)
404		{
405		$r = '';
406		$bitmap = str_pad($bitmap, ceil(mb_orig_strlen($bitmap) / 8) * 8, '0', STR_PAD_LEFT);
407		for ($i = 0, $n = mb_orig_strlen($bitmap) / 8; $i < $n; ++$i) {
408		$r .= chr((int)bindec(mb_orig_substr($bitmap, $i * 8, 8)));
409		}
410		if ($check_len && (mb_orig_strlen($r) !== $check_len)) {
411		return false;
412		}
413		return $r;
414		}
415
416		/**
417		* Get bitmap
418		* @param integer $byte Byte
419		* @return string
420		*/
421		public static function getbitmap($byte)
422		{
423		return sprintf('%08b', $byte);
424		}
425		}
426

kakserpom / phpdaemon

Issues (1507)

Security Analysis not enabled

PHPDaemon/Utils/Binary.php (9 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like