Client::pregResponse() - Code Metrics - Inspection of "Streamrefactor" - EvilFreelancer/routeros-api-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#8)

by Mr

created 2019-03-24 11:54 UTC

Client::pregResponse() A

↳ Parent: Client

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

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

<?php

namespace RouterOS;

use RouterOS\Exceptions\ClientException;
use RouterOS\Exceptions\ConfigException;
use RouterOS\Exceptions\QueryException;
use RouterOS\Helpers\ArrayHelper;

/**
 * Class Client for RouterOS management
 *
 * @package RouterOS
 * @since   0.1
 */
class Client implements Interfaces\ClientInterface
{
    use SocketTrait;

    /**
     * Configuration of connection
     *
     * @var \RouterOS\Config
     */
    private $_config;

    /**
     * API communication object
     *
     * @var \RouterOS\APIConnector
     */

    private $_connector;

    /**
     * Client constructor.
     *
     * @param   array|\RouterOS\Config $config
     * @throws  \RouterOS\Exceptions\ClientException
     * @throws  \RouterOS\Exceptions\ConfigException
     * @throws  \RouterOS\Exceptions\QueryException
     */
    public function __construct($config)
    {
        // If array then need create object
        if (\is_array($config)) {
            $config = new Config($config);
        }

        // Check for important keys
        if (true !== $key = ArrayHelper::checkIfKeysNotExist(['host', 'user', 'pass'], $config->getParameters())) {
            throw new ConfigException("One or few parameters '$key' of Config is not set or empty");
        }

        // Save config if everything is okay
        $this->setConfig($config);

        // Throw error if cannot to connect
        if (false === $this->connect()) {
            throw new ClientException('Unable to connect to ' . $config->get('host') . ':' . $config->get('port'));
        }
    }

    /**
     * Get some parameter from config
     *
     * @param   string $parameter Name of required parameter
     * @return  mixed
     * @throws  \RouterOS\Exceptions\ConfigException
     */
    private function config(string $parameter)
    {
        return $this->_config->get($parameter);
    }

    /**
     * Return socket resource if is exist
     *
     * @return  \RouterOS\Config
     * @since   0.6
     */
    public function getConfig(): Config
    {
        return $this->_config;
    }

    /**
     * Set configuration of client
     *
     * @param   \RouterOS\Config $config
     * @since   0.7
     */
    public function setConfig(Config $config)
    {
        $this->_config = $config;
    }

    /**
     * Send write query to RouterOS (with or without tag)
     *
     * @param   string|array|\RouterOS\Query $query
     * @return  \RouterOS\Client
     * @throws  \RouterOS\Exceptions\QueryException
     */
    public function write($query): Client
    {
        if (\is_string($query)) {
            $query = new Query($query);
        } elseif (\is_array($query)) {
            $endpoint = array_shift($query);
            $query    = new Query($endpoint, $query);
        }

        if (!$query instanceof Query) {
            throw new QueryException('Parameters cannot be processed');
        }

        // Send commands via loop to router
        foreach ($query->getQuery() as $command) {
            $this->_connector->writeWord(trim($command));
        }

        // Write zero-terminator (empty string)
        $this->_connector->writeWord('');

        return $this;
    }

    /**
     * Read answer from server after query was executed
     *
     * A Mikrotik reply is formed of blocks
     * Each block starts with a word, one of ('!re', '!trap', '!done', '!fatal')
     * Each block end with an zero byte (empty line)
     * Reply ends with a complete !done or !fatal block (ended with 'empty line')
     * A !fatal block precedes TCP connexion close
     *
     * @param   bool $parse
     * @return  array
     */
    public function read(bool $parse = true): array
    {
        // By default response is empty
        $response = [];
        // We have to wait a !done or !fatal 
        $lastReply = false;

        // Read answer from socket in loop
        while (true) {
            $word = $this->_connector->readWord();

            if ('' === $word) {
                if ($lastReply) {
                    // We received a !done or !fatal message in a precedent loop
                    // response is complete
                    break;
                }
                // We did not receive the !done or !fatal message
                // This 0 length message is the end of a reply !re or !trap
                // We have to wait the router to send a !done or !fatal reply followed by optionals values and a 0 length message
                continue;
            }

            // Save output line to response array
            $response[] = $word;

            // If we get a !done or !fatal line in response, we are now ready to finish the read
            // but we need to wait a 0 length message, switch the flag
            if ('!done' === $word || '!fatal' === $word) {
                $lastReply = true;
            }
        }

        // Parse results and return
        return $parse ? $this->parseResponse($response) : $response;
    }

    /**
     * Alias for ->write() method
     *
     * @param   string|array|\RouterOS\Query $query
     * @return  \RouterOS\Client
     * @throws  \RouterOS\Exceptions\QueryException
     */
    public function w($query): Client
    {
        return $this->write($query);
    }

    /**
     * Alias for ->read() method
     *
     * @param   bool $parse
     * @return  array
     * @since   0.7
     */
    public function r(bool $parse = true): array
    {
        return $this->read($parse);
    }

    /**
     * Alias for ->write()->read() combination of methods
     *
     * @param   string|array|\RouterOS\Query $query
     * @param   bool                         $parse
     * @return  array
     * @throws  \RouterOS\Exceptions\ClientException
     * @throws  \RouterOS\Exceptions\QueryException
     * @since   0.6
     */
    public function wr($query, bool $parse = true): array
    {
        return $this->write($query)->read($parse);
    }

    /**
     * Parse response from Router OS
     *
     * @param   array $response Response data
     * @return  array Array with parsed data
     */
    private function parseResponse(array $response): array
    {
        $result = [];
        $i      = -1;
        $lines  = \count($response);
        foreach ($response as $key => $value) {
            switch ($value) {
                case '!re':
                    $i++;
                    break;
                case '!fatal':
                    $result = $response;
                    break 2;
                case '!trap':
                case '!done':
                    // Check for =ret=, .tag and any other following messages
                    for ($j = $key + 1; $j <= $lines; $j++) {
                        // If we have lines after current one
                        if (isset($response[$j])) {
                            $this->pregResponse($response[$j], $matches);
                            if (!empty($matches)) {
                                $result['after'][$matches[1][0]] = $matches[2][0];
                            }
                        }
                    }
                    break 2;
                default:
                    $this->pregResponse($value, $matches);
                    if (!empty($matches)) {
                        $result[$i][$matches[1][0]] = $matches[2][0];
                    }
                    break;
            }
        }
        return $result;
    }

    /**
     * Parse result from RouterOS by regular expression
     *
     * @param   string $value
     * @param   array  $matches
     */
    private function pregResponse(string $value, &$matches)
    {
        preg_match_all('/^[=|\.](.*)=(.*)/', $value, $matches);
    }

    /**
     * Authorization logic
     *
     * @param   bool $legacyRetry Retry login if we detect legacy version of RouterOS
     * @return  bool
     * @throws  \RouterOS\Exceptions\ClientException
     * @throws  \RouterOS\Exceptions\ConfigException
     * @throws  \RouterOS\Exceptions\QueryException
     */
    private function login(bool $legacyRetry = false): bool
    {
        // If legacy login scheme is enabled
        if ($this->config('legacy')) {
            // For the first we need get hash with salt
            $query    = new Query('/login');
            $response = $this->write($query)->read();

            // Now need use this hash for authorization
            $query = (new Query('/login'))
                ->add('=name=' . $this->config('user'))
                ->add('=response=00' . md5(\chr(0) . $this->config('pass') . pack('H*', $response['after']['ret'])));
        } else {
            // Just login with our credentials
            $query = (new Query('/login'))
                ->add('=name=' . $this->config('user'))
                ->add('=password=' . $this->config('pass'));

            // If we set modern auth scheme but router with legacy firmware then need to retry query,
            // but need to prevent endless loop
            $legacyRetry = true;
        }

        // Execute query and get response
        $response = $this->write($query)->read(false);

        // if:
        //  - we have more than one response
        //  - response is '!done'
        // => problem with legacy version, swap it and retry
        // Only tested with ROS pre 6.43, will test with post 6.43 => this could make legacy parameter obsolete?
        if ($legacyRetry && $this->isLegacy($response)) {
            $this->_config->set('legacy', true);
            return $this->login();
        }

        // Return true if we have only one line from server and this line is !done
        return (1 === count($response)) && isset($response[0]) && ($response[0] === '!done');
    }

    /**
     * Detect by login request if firmware is legacy
     *
     * @param   array $response
     * @return  bool
     * @throws  ConfigException
     */
    private function isLegacy(array &$response): bool
    {
        return \count($response) > 1 && $response[0] === '!done' && !$this->config('legacy');
    }

    /**
     * Connect to socket server
     *
     * @return  bool
     * @throws  \RouterOS\Exceptions\ClientException
     * @throws  \RouterOS\Exceptions\ConfigException
     * @throws  \RouterOS\Exceptions\QueryException
     */
    private function connect(): bool
    {
        // By default we not connected
        $connected = false;

        // Few attempts in loop
        for ($attempt = 1; $attempt <= $this->config('attempts'); $attempt++) {

            // Initiate socket session
            $this->openSocket();

            // If socket is active
            if (null !== $this->getSocket()) {
                $this->_connector = new APIConnector(new Streams\ResourceStream($this->getSocket()));
                // If we logged in then exit from loop
                if (true === $this->login()) {
                    $connected = true;
                    break;
                }

                // Else close socket and start from begin
                $this->closeSocket();
            }

            // Sleep some time between tries
            sleep($this->config('delay'));
        }

        // Return status of connection
        return $connected;
    }

}


1		<?php
2
3		namespace RouterOS;
4
5		use RouterOS\Exceptions\ClientException;
6		use RouterOS\Exceptions\ConfigException;
7		use RouterOS\Exceptions\QueryException;
8		use RouterOS\Helpers\ArrayHelper;
9
10		/**
11		* Class Client for RouterOS management
12		*
13		* @package RouterOS
14		* @since 0.1
15		*/
16		class Client implements Interfaces\ClientInterface
17		{
18		use SocketTrait;
19
20		/**
21		* Configuration of connection
22		*
23		* @var \RouterOS\Config
24		*/
25		private $_config;
26
27		/**
28		* API communication object
29		*
30		* @var \RouterOS\APIConnector
31		*/
32
33		private $_connector;
34
35		/**
36		* Client constructor.
37		*
38		* @param array\|\RouterOS\Config $config
39		* @throws \RouterOS\Exceptions\ClientException
40		* @throws \RouterOS\Exceptions\ConfigException
41		* @throws \RouterOS\Exceptions\QueryException
42		*/
43	14	public function __construct($config)
44		{
45		// If array then need create object
46	14	if (\is_array($config)) {
47	3	$config = new Config($config);
48		}
49
50		// Check for important keys
51	14	if (true !== $key = ArrayHelper::checkIfKeysNotExist(['host', 'user', 'pass'], $config->getParameters())) {
52	1	throw new ConfigException("One or few parameters '$key' of Config is not set or empty");
53		}
54
55		// Save config if everything is okay
56	13	$this->setConfig($config);
57
58		// Throw error if cannot to connect
59	13	if (false === $this->connect()) {
60	1	throw new ClientException('Unable to connect to ' . $config->get('host') . ':' . $config->get('port'));
61		}
62	11	}
63
64		/**
65		* Get some parameter from config
66		*
67		* @param string $parameter Name of required parameter
68		* @return mixed
69		* @throws \RouterOS\Exceptions\ConfigException
70		*/
71	13	private function config(string $parameter)
72		{
73	13	return $this->_config->get($parameter);
74		}
75
76		/**
77		* Return socket resource if is exist
78		*
79		* @return \RouterOS\Config
80		* @since 0.6
81		*/
82	1	public function getConfig(): Config
83		{
84	1	return $this->_config;
85		}
86
87		/**
88		* Set configuration of client
89		*
90		* @param \RouterOS\Config $config
91		* @since 0.7
92		*/
93	13	public function setConfig(Config $config)
94		{
95	13	$this->_config = $config;
96	13	}
97
98		/**
99		* Send write query to RouterOS (with or without tag)
100		*
101		* @param string\|array\|\RouterOS\Query $query
102		* @return \RouterOS\Client
103		* @throws \RouterOS\Exceptions\QueryException
104		*/
105	12	public function write($query): Client
106		{
107	12	if (\is_string($query)) {
108	2	$query = new Query($query);
109	12	} elseif (\is_array($query)) {
110	1	$endpoint = array_shift($query);
111	1	$query = new Query($endpoint, $query);
112		}
113
114	12	if (!$query instanceof Query) {
115	1	throw new QueryException('Parameters cannot be processed');
116		}
117
118		// Send commands via loop to router
119	12	foreach ($query->getQuery() as $command) {
120	12	$this->_connector->writeWord(trim($command));
121		}
122
123		// Write zero-terminator (empty string)
124	12	$this->_connector->writeWord('');
125
126	12	return $this;
127		}
128
129		/**
130		* Read answer from server after query was executed
131		*
132		* A Mikrotik reply is formed of blocks
133		* Each block starts with a word, one of ('!re', '!trap', '!done', '!fatal')
134		* Each block end with an zero byte (empty line)
135		* Reply ends with a complete !done or !fatal block (ended with 'empty line')
136		* A !fatal block precedes TCP connexion close
137		*
138		* @param bool $parse
139		* @return array
140		*/
141	12	public function read(bool $parse = true): array
142		{
143		// By default response is empty
144	12	$response = [];
145		// We have to wait a !done or !fatal
146	12	$lastReply = false;
147
148		// Read answer from socket in loop
149	12	while (true) {
150	12	$word = $this->_connector->readWord();
151
152	12	if ('' === $word) {
153	12	if ($lastReply) {
154		// We received a !done or !fatal message in a precedent loop
155		// response is complete
156	12	break;
157		}
158		// We did not receive the !done or !fatal message
159		// This 0 length message is the end of a reply !re or !trap
160		// We have to wait the router to send a !done or !fatal reply followed by optionals values and a 0 length message
161	4	continue;
162		}
163
164		// Save output line to response array
165	12	$response[] = $word;
166
167		// If we get a !done or !fatal line in response, we are now ready to finish the read
168		// but we need to wait a 0 length message, switch the flag
169	12	if ('!done' === $word \|\| '!fatal' === $word) {
170	12	$lastReply = true;
171		}
172		}
173
174		// Parse results and return
175	12	return $parse ? $this->parseResponse($response) : $response;
176		}
177
178		/**
179		* Alias for ->write() method
180		*
181		* @param string\|array\|\RouterOS\Query $query
182		* @return \RouterOS\Client
183		* @throws \RouterOS\Exceptions\QueryException
184		*/
185	1	public function w($query): Client
186		{
187	1	return $this->write($query);
188		}
189
190		/**
191		* Alias for ->read() method
192		*
193		* @param bool $parse
194		* @return array
195		* @since 0.7
196		*/
197	1	public function r(bool $parse = true): array
198		{
199	1	return $this->read($parse);
200		}
201
202		/**
203		* Alias for ->write()->read() combination of methods
204		*
205		* @param string\|array\|\RouterOS\Query $query
206		* @param bool $parse
207		* @return array
208		* @throws \RouterOS\Exceptions\ClientException
209		* @throws \RouterOS\Exceptions\QueryException
210		* @since 0.6
211		*/
212	4	public function wr($query, bool $parse = true): array
213		{
214	4	return $this->write($query)->read($parse);
215		}
216
217		/**
218		* Parse response from Router OS
219		*
220		* @param array $response Response data
221		* @return array Array with parsed data
222		*/
223	4	private function parseResponse(array $response): array
224		{
225	4	$result = [];
226	4	$i = -1;
227	4	$lines = \count($response);
228	4	foreach ($response as $key => $value) {
229	4	switch ($value) {
230	4	case '!re':
231	1	$i++;
232	1	break;
233	4	case '!fatal':
234	1	$result = $response;
235	1	break 2;
236	3	case '!trap':
237	3	case '!done':
238		// Check for =ret=, .tag and any other following messages
239	3	for ($j = $key + 1; $j <= $lines; $j++) {
240		// If we have lines after current one
241	3	if (isset($response[$j])) {
242	2	$this->pregResponse($response[$j], $matches);
243	2	if (!empty($matches)) {
244	2	$result['after'][$matches[1][0]] = $matches[2][0];
245		}
246		}
247		}
248	3	break 2;
249		default:
250	1	$this->pregResponse($value, $matches);
251	1	if (!empty($matches)) {
252	1	$result[$i][$matches[1][0]] = $matches[2][0];
253		}
254	1	break;
255		}
256		}
257	4	return $result;
258		}
259
260		/**
261		* Parse result from RouterOS by regular expression
262		*
263		* @param string $value
264		* @param array $matches
265		*/
266	3	private function pregResponse(string $value, &$matches)
267		{
268	3	preg_match_all('/^[=\|\.](.)=(.)/', $value, $matches);
269	3	}
270
271		/**
272		* Authorization logic
273		*
274		* @param bool $legacyRetry Retry login if we detect legacy version of RouterOS
275		* @return bool
276		* @throws \RouterOS\Exceptions\ClientException
277		* @throws \RouterOS\Exceptions\ConfigException
278		* @throws \RouterOS\Exceptions\QueryException
279		*/
280	12	private function login(bool $legacyRetry = false): bool
281		{
282		// If legacy login scheme is enabled
283	12	if ($this->config('legacy')) {
284		// For the first we need get hash with salt
285	2	$query = new Query('/login');
286	2	$response = $this->write($query)->read();
287
288		// Now need use this hash for authorization
289	2	$query = (new Query('/login'))
290	2	->add('=name=' . $this->config('user'))
291	2	->add('=response=00' . md5(\chr(0) . $this->config('pass') . pack('H*', $response['after']['ret'])));
292		} else {
293		// Just login with our credentials
294	11	$query = (new Query('/login'))
295	11	->add('=name=' . $this->config('user'))
296	11	->add('=password=' . $this->config('pass'));
297
298		// If we set modern auth scheme but router with legacy firmware then need to retry query,
299		// but need to prevent endless loop
300	11	$legacyRetry = true;
301		}
302
303		// Execute query and get response
304	12	$response = $this->write($query)->read(false);
305
306		// if:
307		// - we have more than one response
308		// - response is '!done'
309		// => problem with legacy version, swap it and retry
310		// Only tested with ROS pre 6.43, will test with post 6.43 => this could make legacy parameter obsolete?
311	12	if ($legacyRetry && $this->isLegacy($response)) {
312	1	$this->_config->set('legacy', true);
313	1	return $this->login();
314		}
315
316		// Return true if we have only one line from server and this line is !done
317	12	return (1 === count($response)) && isset($response[0]) && ($response[0] === '!done');
318		}
319
320		/**
321		* Detect by login request if firmware is legacy
322		*
323		* @param array $response
324		* @return bool
325		* @throws ConfigException
326		*/
327	11	private function isLegacy(array &$response): bool
328		{
329	11	return \count($response) > 1 && $response[0] === '!done' && !$this->config('legacy');
330		}
331
332		/**
333		* Connect to socket server
334		*
335		* @return bool
336		* @throws \RouterOS\Exceptions\ClientException
337		* @throws \RouterOS\Exceptions\ConfigException
338		* @throws \RouterOS\Exceptions\QueryException
339		*/
340	13	private function connect(): bool
341		{
342		// By default we not connected
343	13	$connected = false;
344
345		// Few attempts in loop
346	13	for ($attempt = 1; $attempt <= $this->config('attempts'); $attempt++) {
347
348		// Initiate socket session
349	13	$this->openSocket();
350
351		// If socket is active
352	12	if (null !== $this->getSocket()) {
353	12	$this->_connector = new APIConnector(new Streams\ResourceStream($this->getSocket()));
354		// If we logged in then exit from loop
355	12	if (true === $this->login()) {
356	11	$connected = true;
357	11	break;
358		}
359
360		// Else close socket and start from begin
361	1	$this->closeSocket();
362		}
363
364		// Sleep some time between tries
365	1	sleep($this->config('delay'));
366		}
367
368		// Return status of connection
369	12	return $connected;
370		}
371
372		}
373

EvilFreelancer / routeros-api-php

Pull Request — master (#8)

Client::pregResponse() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like