PEAR2/Net/RouterOS/Client.php

Go to the documentation of this file.

<?php

namespace PEAR2\Net\RouterOS;

class Client
{
    const FILTER_CALLBACK = 1;
    const FILTER_BUFFER = 2;
    const FILTER_ALL = 3;

    protected $com;

    protected $pendingRequestsCount = 0;

    protected $responseBuffer = array();

    protected $callbacks = array();

    private $_streamResponses = false;

    public function __construct($host, $username, $password = '', $port = 8728,
        $persist = false, $timeout = null, $context = null
    ) {
        $this->com = new Communicator(
            $host, $port, $persist, $timeout, $username, $context
        );
        //Login the user if necessary
        if ($this->com->getTransmitter()->isFresh()) {
            if (!self::login($this->com, $username, $password)) {
                $this->com->close();
                throw new DataFlowException(
                    'Invalid username or password supplied.', 100
                );
            }
        }
    }

    public static function login(Communicator $com, $username, $password = '')
    {
        try {
            $request = new Request('/login');
            $request->send($com);
            $response = new Response($com);
            $request->setArgument('name', $username);
            $request->setArgument(
                'response', '00' . md5(
                    chr(0) . $password
                    . pack('H*', $response->getArgument('ret'))
                )
            );
            $request->send($com);
            $response = new Response($com);
            return $response->getType() === Response::TYPE_FINAL
                && null === $response->getArgument('ret');
        } catch (\Exception $e) {
            throw ($e instanceof NotSupportedException
            || $e instanceof UnexpectedValueException
            || !$com->getTransmitter()->isDataAwaiting()) ? new SocketException(
                'This is not a compatible RouterOS service', 101, $e
            ) : $e;
        }
    }
    
    public function setCharset(
        $charset, $charsetType = Communicator::CHARSET_ALL
    ) {
        return $this->com->setCharset($charset, $charsetType);
    }
    
    public function getCharset($charsetType)
    {
        return $this->com->getCharset($charsetType);
    }

    public function sendAsync(Request $request, $callback = null)
    {
        //Error checking
        $tag = $request->getTag();
        if (null === $tag) {
            throw new DataFlowException(
                'Asynchonous commands must have a tag.', 102
            );
        }
        if ($this->isRequestActive($tag)) {
            throw new DataFlowException(
                'There must not be multiple active requests sharing a tag.', 103
            );
        }
        
        $this->send($request);

        if (null === $callback) {
            //Register the request at the buffer
            $this->responseBuffer[$tag] = array();
        } else {
            //Prepare the callback
            $this->callbacks[$tag] = $callback;
        }
        return $this;
    }

    public function isRequestActive($tag, $filter = self::FILTER_ALL)
    {
        $result = 0;
        if (self::FILTER_CALLBACK === ($filter & self::FILTER_CALLBACK)) {
            $result |= (int) array_key_exists($tag, $this->callbacks);
        }
        if (self::FILTER_BUFFER === ($filter & self::FILTER_BUFFER)) {
            $result |= (int) array_key_exists($tag, $this->responseBuffer);
        }
        return 0 !== $result;
    }

    public function sendSync(Request $request)
    {
        $this->send($request);
        return $this->completeRequest($request->getTag());
    }

    public function completeRequest($tag = null)
    {
        $isTagNull = null === $tag;
        $result = $isTagNull ? array()
            : $this->extractNewResponses($tag)->toArray();
        while ((!$isTagNull && $this->isRequestActive($tag))
        || ($isTagNull && 0 !== $this->getPendingRequestsCount())
        ) {
            $newReply = $this->dispatchNextResponse();
            if ($newReply->getTag() === $tag) {
                if ($isTagNull) {
                    $result[] = $newReply;
                }
                if ($newReply->getType() === Response::TYPE_FINAL) {
                    if (!$isTagNull) {
                        $result = array_merge(
                            $result,
                            $this->extractNewResponses($tag)->toArray()
                        );
                    }
                    break;
                }
            }
        }
        return new ResponseCollection($result);
    }

    public function extractNewResponses($tag = null)
    {
        if (null === $tag) {
            $result = array();
            foreach (array_keys($this->responseBuffer) as $tag) {
                $result = array_merge(
                    $result, $this->extractNewResponses($tag)->toArray()
                );
            }
            return new ResponseCollection($result);
        } elseif ($this->isRequestActive($tag, self::FILTER_CALLBACK)) {
            return new ResponseCollection(array());
        } elseif ($this->isRequestActive($tag, self::FILTER_BUFFER)) {
            $result = $this->responseBuffer[$tag];
            if (!empty($result)) {
                if ($result[count($result) - 1]->getType()
                    === Response::TYPE_FINAL
                ) {
                    unset($this->responseBuffer[$tag]);
                } else {
                    $this->responseBuffer[$tag] = array();
                }
            }
            return new ResponseCollection($result);
        } else {
            throw new DataFlowException(
                'No such request, or the request has already finished.', 104
            );
        }
    }

    public function loop($timeout = 0)
    {
        if ($this->getPendingRequestsCount() !== 0) {
            $start = microtime(true);
            do {
                $this->dispatchNextResponse();
            } while (
            ((microtime(true) - $start) <= $timeout)
            || (0 === $timeout && $this->getPendingRequestsCount() !== 0)
            );
        }
        return $this->getPendingRequestsCount() !== 0;
    }

    public function getPendingRequestsCount()
    {
        return $this->pendingRequestsCount;
    }

    public function cancelRequest($tag = null)
    {
        $cancelRequest = new Request('/cancel');
        $tagIsNotNull = !(null === $tag);
        if ($tagIsNotNull) {
            if ($this->isRequestActive($tag)) {
                $cancelRequest->setArgument('tag', $tag);
            } else {
                throw new DataFlowException(
                    'No such request. Canceling aborted.', 105
                );
            }
        }
        $this->sendSync($cancelRequest);

        if ($tagIsNotNull) {
            if ($this->isRequestActive($tag, self::FILTER_BUFFER)) {
                unset($this->responseBuffer[$tag]);
            } elseif ($this->isRequestActive($tag, self::FILTER_CALLBACK)) {
                unset($this->callbacks[$tag]);
            }
            $this->pendingRequestsCount--;
        } else {
            $this->responseBuffer = array();
            $this->callbacks = array();
            $this->pendingRequestsCount = 0;
        }
        return $this;
    }

    public function setStreamResponses($streamResponses)
    {
        $oldStreamResponses = $this->_streamResponses;
        $this->_streamResponses = (bool) $streamResponses;
        return $oldStreamResponses;
    }

    public function getStreamResponses()
    {
        return $this->_streamResponses;
    }

    public function close()
    {
        $result = false;
        try {
            $response = $this->sendSync(new Request('/quit'));
            $result = $this->com->close()
                && $response->getType() === Response::TYPE_FATAL;
        } catch (SocketException $e) {
            $result = $e->getCode() === 205;
        }
        $this->callbacks = array();
        $this->pendingRequestsCount = 0;
        return $result;
    }

    protected function send(Request $request)
    {
        $request->send($this->com);
        $this->pendingRequestsCount++;
        return $this;
    }

    protected function dispatchNextResponse()
    {
        $response = new Response($this->com, $this->_streamResponses);
        if ($response->getType() === Response::TYPE_FATAL) {
            $this->pendingRequestsCount = 0;
            $this->com->close();
            return $response;
        }

        $tag = $response->getTag();
        $isLastForRequest = $response->getType() === Response::TYPE_FINAL;
        if ($isLastForRequest) {
            $this->pendingRequestsCount--;
        }

        if (null !== $tag) {
            if ($this->isRequestActive($tag, self::FILTER_CALLBACK)) {
                if ($this->callbacks[$tag]($response, $this)) {
                    $this->cancelRequest($tag);
                } elseif ($isLastForRequest) {
                    unset($this->callbacks[$tag]);
                }
            } else {
                $this->responseBuffer[$tag][] = $response;
            }
        }
        return $response;
    }

}