PEAR2/Net/RouterOS/Communicator.php

Go to the documentation of this file.

<?php

namespace PEAR2\Net\RouterOS;

use PEAR2\Net\Transmitter as T;

class Communicator
{
    const CHARSET_ALL = -1;
    
    const CHARSET_REMOTE = 0;
    
    const CHARSET_LOCAL = 1;
    
    protected static $defaultCharsets = array(
        self::CHARSET_REMOTE => null,
        self::CHARSET_LOCAL  => null
    );
    
    protected $charsets = array();

    protected $trans;

    public function __construct($host, $port = 8728, $persist = false,
        $timeout = null, $key = '', $context = null
    ) {
        $this->trans = new T\SocketClientTransmitter(
            $host, $port, $persist, $timeout, $key, $context
        );
        $this->setCharset(
            self::getDefaultCharset(self::CHARSET_ALL), self::CHARSET_ALL
        );
    }
    
    public static function iconvStream($in_charset, $out_charset, $stream)
    {
        $bytes = 0;
        $result = fopen('php://temp', 'r+b');
        $iconvFilter = stream_filter_append(
            $result, 'convert.iconv.' . $in_charset . '.' . $out_charset,
            STREAM_FILTER_WRITE
        );
        
        flock($stream, LOCK_SH);
        while (!feof($stream)) {
            $bytes += stream_copy_to_stream($stream, $result, 0xFFFFF);
        }
        fseek($stream, -$bytes, SEEK_CUR);
        flock($stream, LOCK_UN);
        
        stream_filter_remove($iconvFilter);
        rewind($result);
        return $result;
    }
    
    public static function setDefaultCharset(
        $charset, $charsetType = self::CHARSET_ALL
    ) {
        if (array_key_exists($charsetType, self::$defaultCharsets)) {
             $oldCharset = self::$defaultCharsets[$charsetType];
             self::$defaultCharsets[$charsetType] = $charset;
             return $oldCharset;
        } else {
            $oldCharsets = self::$defaultCharsets;
            self::$defaultCharsets = is_array($charset) ? $charset : array_fill(
                0, count(self::$defaultCharsets), $charset
            );
            return $oldCharsets;
        }
    }
    
    public static function getDefaultCharset($charsetType)
    {
        return array_key_exists($charsetType, self::$defaultCharsets)
            ? self::$defaultCharsets[$charsetType] : self::$defaultCharsets;
    }
    
    public function setCharset($charset, $charsetType = self::CHARSET_ALL)
    {
        if (array_key_exists($charsetType, $this->charsets)) {
             $oldCharset = $this->charsets[$charsetType];
             $this->charsets[$charsetType] = $charset;
             return $oldCharset;
        } else {
            $oldCharsets = $this->charsets;
            $this->charsets = is_array($charset) ? $charset : array_fill(
                0, count($this->charsets), $charset
            );
            return $oldCharsets;
        }
    }
    
    public function getCharset($charsetType)
    {
        return array_key_exists($charsetType, $this->charsets)
            ? $this->charsets[$charsetType] : $this->charsets;
    }

    public function getTransmitter()
    {
        return $this->trans;
    }

    public function sendWord($word)
    {
        if (null !== ($remoteCharset = $this->getCharset(self::CHARSET_REMOTE))
            && null !== ($localCharset = $this->getCharset(self::CHARSET_LOCAL))
        ) {
            $word = iconv(
                $localCharset,
                $remoteCharset . '//IGNORE//TRANSLIT',
                $word
            );
        }
        $length = strlen($word);
        static::verifyLengthSupport($length);
        return $this->trans->send(self::encodeLength($length) . $word);
    }

    public function sendWordFromStream($prefix, $stream)
    {
        if (null !== ($remoteCharset = $this->getCharset(self::CHARSET_REMOTE))
            && null !== ($localCharset = $this->getCharset(self::CHARSET_LOCAL))
        ) {
            $prefix = iconv(
                $localCharset,
                $remoteCharset . '//IGNORE//TRANSLIT',
                $prefix
            );
            $stream = self::iconvStream(
                $localCharset,
                $remoteCharset . '//IGNORE//TRANSLIT',
                $stream
            );
        }
        
        flock($stream, LOCK_SH);
        
        $streamPosition = (double) sprintf('%u', ftell($stream));
        fseek($stream, 0, SEEK_END);
        $streamLength = ((double) sprintf('%u', ftell($stream)))
            - $streamPosition;
        fseek($stream, $streamPosition, SEEK_SET);
        $totalLength = strlen($prefix) + $streamLength;
        static::verifyLengthSupport($totalLength);

        $bytes = $this->trans->send(self::encodeLength($totalLength) . $prefix);
        $bytes += $this->trans->sendStream($stream);
        
        flock($stream, LOCK_UN);
        return $bytes;
    }

    protected static function verifyLengthSupport($length)
    {
        if ($length > 0xFFFFFFF) {
            throw new LengthException(
                'Words with length above 0xFFFFFFF are not supported.', 10,
                null, $length
            );
        }
    }

    public static function encodeLength($length)
    {
        if ($length < 0) {
            throw new LengthException(
                'Length must not be negative.', 11, null, $length
            );
        } elseif ($length < 0x80) {
            return chr($length);
        } elseif ($length < 0x4000) {
            return pack('n', $length |= 0x8000);
        } elseif ($length < 0x200000) {
            $length |= 0xC00000;
            return pack('n', $length >> 8) . chr($length & 0xFF);
        } elseif ($length < 0x10000000) {
            return pack('N', $length |= 0xE0000000);
        } elseif ($length <= 0xFFFFFFFF) {
            return chr(0xF0) . pack('N', $length);
        } elseif ($length <= 0x7FFFFFFFF) {
            $length = 'f' . base_convert($length, 10, 16);
            return chr(hexdec(substr($length, 0, 2))) .
                pack('N', hexdec(substr($length, 2)));
        }
        throw new LengthException(
            'Length must not be above 0x7FFFFFFFF.', 12, null, $length
        );
    }

    public function getNextWord()
    {
        $word = $this->trans->receive(self::decodeLength($this->trans), 'word');
        if (null !== ($remoteCharset = $this->getCharset(self::CHARSET_REMOTE))
            && null !== ($localCharset = $this->getCharset(self::CHARSET_LOCAL))
        ) {
            $word = iconv(
                $remoteCharset,
                $localCharset . '//IGNORE//TRANSLIT',
                $word
            );
        }
        return $word;
    }

    public function getNextWordAsStream()
    {
        $filters = array();
        if (null !== ($remoteCharset = $this->getCharset(self::CHARSET_REMOTE))
            && null !== ($localCharset = $this->getCharset(self::CHARSET_LOCAL))
        ) {
            $filters[
                'convert.iconv.' .
                $remoteCharset . '.' . $localCharset . '//IGNORE//TRANSLIT'
            ] = array();
        }
        $stream = $this->trans->receiveStream(
            self::decodeLength($this->trans), $filters, 'stream word'
        );
        return $stream;
    }

    public static function decodeLength(T\StreamTransmitter $trans)
    {
        $byte = ord($trans->receive(1, 'initial length byte'));
        if ($byte & 0x80) {
            if (($byte & 0xC0) === 0x80) {
                return (($byte & 077) << 8 ) + ord($trans->receive(1));
            } elseif (($byte & 0xE0) === 0xC0) {
                $u = unpack('n~', $trans->receive(2));
                return (($byte & 037) << 16 ) + $u['~'];
            } elseif (($byte & 0xF0) === 0xE0) {
                $u = unpack('n~/C~~', $trans->receive(3));
                return (($byte & 017) << 24 ) + ($u['~'] << 8) + $u['~~'];
            } elseif (($byte & 0xF8) === 0xF0) {
                $u = unpack('N~', $trans->receive(4));
                return (($byte & 007) * 0x100000000/* '<< 32' or '2^32' */)
                    + (double) sprintf('%u', $u['~']);
            }
            throw new NotSupportedException(
                'Unknown control byte encountered.', 13, null, $byte
            );
        } else {
            return $byte;
        }
    }

    public function close()
    {
        return $this->trans->close();
    }

}