LineIO.php

<?php
/*
    This file is part of Erebot, a modular IRC bot written in PHP.

    Copyright © 2010 François Poirotte

    Erebot is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Erebot 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 General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Erebot.  If not, see <http://www.gnu.org/licenses/>.
*/

namespace Erebot;

class LineIO
{
    const EOL_WIN       = "\r\n";

    const EOL_OLD_MAC   = "\r";

    const EOL_UNIX      = "\n";

    const EOL_NEW_MAC   = "\n";

    const EOL_ANY       = null;

    protected $eol;

    protected $socket;

    protected $sndQueue;

    protected $rcvQueue;

    protected $incomingData;

    public function __construct($eol, $socket = null)
    {
        $this->setSocket($socket);
        $this->setEOL($eol);
    }

    public function setSocket($socket)
    {
        $this->socket          = $socket;
        $this->incomingData    = "";
        $this->rcvQueue        = array();
        $this->sndQueue        = array();
    }

    public function getSocket()
    {
        return $this->socket;
    }

    public function setEOL($eol)
    {
        $eols = array(
            self::EOL_WIN,
            self::EOL_OLD_MAC,
            self::EOL_UNIX,
            self::EOL_ANY,
        );
        if (!in_array($eol, $eols)) {
            throw new \Erebot\InvalidValueException('Invalid EOL mode');
        }
        if ($eol === self::EOL_ANY) {
            $eol = array("\r\n", "\r", "\n");
        } else {
            $eol = array($eol);
        }

        $this->eol     = $eol;
    }

    public function getEOL()
    {
        return $this->eol;
    }

    protected function getLine()
    {
        $pos = false;
        foreach ($this->eol as $eol) {
            $pos = strpos($this->incomingData, $eol);
            if ($pos !== false) {
                break;
            }
        }
        if ($pos === false) {
            return false;
        }

        $len    = strlen($eol);
        $line   = \Erebot\Utils::toUTF8(substr($this->incomingData, 0, $pos));
        $this->incomingData    = substr($this->incomingData, $pos + $len);
        $this->rcvQueue[]      = $line;

        $logger = \Plop\Plop::getInstance();
        $logger->debug(
            '%(line)s',
            array('line' => addcslashes($line, "\000..\037"))
        );
        return true;
    }

    public function read()
    {
        if ($this->socket === null) {
            return false;
        }

        if (feof($this->socket)) {
            return false;
        }

        $received = fread($this->socket, 4096);
        if ($received === false) {
            return false;
        }
        $this->incomingData .= $received;

        // Workaround for issue #8.
        $metadata = stream_get_meta_data($this->socket);
        if ($metadata['stream_type'] == 'tcp_socket/ssl' && !feof($this->socket)) {
            $blocking = (int) $metadata['blocked'];
            stream_set_blocking($this->socket, 0);
            $received = fread($this->socket, 4096);
            stream_set_blocking($this->socket, $blocking);

            if ($received !== false) {
                $this->incomingData .= $received;
            }
        }

        // Read all messages currently in the input buffer.
        while ($this->getLine()) {
            ; // Nothing more to do.
        }
        return true;
    }

    public function pop()
    {
        if (count($this->rcvQueue)) {
            return array_shift($this->rcvQueue);
        }
        return null;
    }

    public function push($line)
    {
        if ($this->socket === null) {
            throw new \Erebot\IllegalActionException('Uninitialized socket');
        }

        if (strcspn($line, "\r\n") != strlen($line)) {
            throw new \Erebot\InvalidValueException(
                'Line contains forbidden characters'
            );
        }
        $this->sndQueue[] = $line;
    }

    public function write()
    {
        if (!count($this->sndQueue)) {
            return false;
        }

        $line   = array_shift($this->sndQueue);
        $logger = \Plop\Plop::getInstance();

        // Make sure we send the whole line,
        // with a trailing CR LF sequence.
        $eol    = $this->eol[count($this->eol) - 1];
        $line  .= $eol;
        $len    = strlen($line);
        for ($written = 0; $written < $len; $written += $fwrite) {
            $fwrite = @fwrite($this->socket, substr($line, $written));
            if ($fwrite === false) {
                return false;
            }
        }
        $line = substr($line, 0, -strlen($eol));
        $logger->debug(
            '%(line)s',
            array('line' => addcslashes($line, "\000..\037"))
        );
        return $written;
    }

    public function inReadQueue()
    {
        return count($this->rcvQueue);
    }

    public function inWriteQueue()
    {
        return count($this->sndQueue);
    }
}