root/trunk/Phergie/Driver/Streams.php @ 60

<?php

/**
* @see Phergie_Driver_Abstract
*/
require_once 'Phergie/Driver/Abstract.php';

/**
* Provides a socket-based client driver.
*/
class Phergie_Driver_Streams extends Phergie_Driver_Abstract
{
    /**
    * Names of commands that can be issued by callbacks ordered by
    * priority of execution
    *
    * @var array
    */
    protected $priority = array(
        'pass',
        'user',
        'pong',
        'notice',
        'join',
        'list',
        'names',
        'version',
        'stats',
        'links',
        'time',
        'trace',
        'admin',
        'info',
        'who',
        'whois',
        'whowas',
        'mode',
        'privmsg',
        'nick',
        'topic',
        'invite',
        'kill',
        'part'
    );

    /**
    * Socket handler
    *
    * @var resource
    */
    protected $socket;

    /**
    * List of event handler instances
    *
    * @var array
    */
    protected $handlers;

    /**
    * Flag to indicate whether or not the callbacks are currently being
    * queued for execution rather than executed outright
    *
    * @var bool
    */
    protected $queueing;

    /**
    * Associative array mapping command names to queued sets of arguments
    * from commands queued by callbacks
    *
    * @var array
    */
    protected $queue;

    /**
    * Constructor to initialize instance properties.
    */
    public function __construct()
    {
        $this->handlers = array();
        $this->queueing = false;
        $this->queue = array();
    }

    /**
    * Adds a set of callbacks for events received from the server.
    *
    * @param Phergie_Event_Handler $handler
    */
    public function addEventHandler(Phergie_Event_Handler $handler)
    {
        $handler->init();

        $this->handlers[] = $handler;
    }

    /**
    * Executes a continuous loop in which the client listens for events from
    * the server and processes them until the connection is terminated.
    *
    * @return void
    */
    public function run()
    {
        $server = $this->getIni('server');
        $port = $this->getIni('port');
        if (!$port) {
            $port = 6667;
        }

        $this->socket = @stream_socket_client(
            'tcp://' . $server . ':' . $port,
            $errno,
            $errstr
        );

        if (!$this->socket) {
            $this->debug(rtrim('Unable to connect to server: socket error ' . $errno . ' ' . $errstr));
            return;
        }

        $password = $this->getIni('password');
        if ($password) {
            $this->send('PASS', array($password));
        }

        $this->send('USER', array($this->getIni('username'), $server, $server, $this->getIni('realname')));
        $this->doNick($this->getIni('nick'));

        unset($server, $port, $password, $errno, $errstr);

        while(true) {
            $this->queue = array();
            $this->queueing = true;

            $buffer = '';
            while (empty ($buffer)) {
                $buffer = fgets($this->socket, 512);
            }
            $buffer = rtrim($buffer);
            $this->debug('server -> ' . $buffer);

            if ($buffer[0] == ':') {
                list ($prefix, $cmd, $args) = explode(' ', substr($buffer, 1), 3);
                $this->parseHostmask($prefix, $nick, $user, $host);
            } else {
                list ($cmd, $args) = explode(' ', $buffer, 2);
            }

            $cmd = strtolower($cmd);

            switch ($cmd) {
                case 'names':
                case 'nick':
                case 'quit':
                case 'ping':
                case 'join':
                    $args = array(ltrim($args, ':'));
                    break;
                case 'notice':
                    $args = explode(' :', $args);
                    break;
                case 'oper':
                case 'topic':
                case 'mode':
                    $args = preg_split('/ :?/', $args);
                    break;
                case 'part':
                    $args = preg_split('/ :?/', $args, 2);
                    break;
                case 'kick':
                    $args = preg_split('/ :?/', $args, 3);
                    break;
                case 'privmsg':
                    if ($args[0] == chr(1)) {
                        /**
                        * This will likely need to be changed if support is added
                        * for CTCP commands other than ACTION.
                        */
                        list ($target, $args) = explode(' ', $args, 2);
                        $args = explode(' ', substr($args, 1, -1), 2);
                        $cmd = strtolower(array_shift($args));
                        array_unshift($args, $target);
                    } else {
                        $args = explode(' :', $args);
                    }
                    break;
            }

            if (preg_match('/^[0-9]+$/', $cmd) > 0) {
                $event = new Phergie_Event_Response();
                $event->setCode($cmd);
                $event->setDescription($args);
            } else {
                $event = new Phergie_Event_Request();
                $event->setType($cmd);
                $event->setArguments($args);
                if (isset ($user)) {
                    $event->setHost($host);
                    $event->setUsername($user);
                    $event->setNick($nick);
                }
            }

            foreach ($this->handlers as $handler) {
                $handler->setEvent($event);
                if ($event instanceof Phergie_Event_Response) {
                    $handler->onResponse();
                } else {
                    call_user_func(array($handler, 'on' . ucfirst($event->getType())));
                }
            }
            $this->queueing = false;
            foreach ($this->priority as $command) {
                if (isset($this->queue[$command])) {
                    foreach ($this->queue[$command] as $arguments) {
                        $this->send($command, $arguments);
                    }
                }
            }
            if (isset ($this->queue['quit'])) {
                if (count($this->queue['quit'][0]) > 0) {
                    $reason = $this->queue['quit'][0][0];
                } else {
                    $reason = null;
                }
                foreach ($this->handlers as $handler) {
                    $handler->shutdown();
                }
                $this->doQuit($reason);
                break;
            }
            unset($this->queue, $event, $command, $arguments);
        }

        fclose($this->socket);
    }

    /**
    * Sends a client command with accompanying arguments to the server.
    *
    * @param string $command Command to send
    * @param array $arguments Ordered array of arguments to include
    *                         (optional)
    */
    public function send($command, array $arguments = array())
    {
        if ($this->queueing) {
            if (!isset($this->queue[$command])) {
                $this->queue[$command] = array();
            }
            $this->queue[$command][] = $arguments;
        } else {
            $buffer = strtoupper($command);
            if (count($arguments) > 0) {
                $end = count($arguments) - 1;
                $arguments[$end] = ':' . $arguments[$end];
                $buffer .= ' ' . implode(' ', $arguments);
            }
            fwrite($this->socket, $buffer . "\r\n");
            $this->debug('client -> ' . $buffer);
        }
    }

    /**
    * Terminates the connection with the server.
    *
    * @param string $reason Reason for connection termination (optional)
    */
    public function doQuit($reason = null)
    {
        $this->send(Phergie_Event_Request::TYPE_QUIT, array($reason));
    }

    /**
    * Joins a channel.
    *
    * @param string $channel Name of the channel to join
    * @param string $keys Channel key if needed (optional)
    */
    public function doJoin($channel, $key = null)
    {
        $arguments = array($channel);

        if ($key !== null) {
            $arguments[] = $key;
        }

        $this->send(Phergie_Event_Request::TYPE_JOIN, $arguments);
    }

    /**
    * Leaves a channel.
    *
    * @param string $channel Name of the channel to leave
    */
    public function doPart($channel)
    {
        $this->send(Phergie_Event_Request::TYPE_PART, array($channel));
    }

    /**
    * Invites a user to an invite-only channel.
    *
    * @param string $nick Nick of the user to invite
    * @param string $channel Name of the channel
    */
    public function doInvite($nick, $channel)
    {
        $this->send(Phergie_Event_Request::TYPE_INVITE, array($nick, $channel));
    }

    /**
    * Obtains a list of nicks of usrs in currently joined channels.
    *
    * @param string $channels Comma-delimited list of one or more channels
    */
    public function doNames($channels)
    {
        $this->send(Phergie_Event_Request::TYPE_NAMES, array($channels));
    }

    /**
    * Obtains a list of channel names and topics.
    *
    * @param string $channels Comma-delimited list of one or more channels
    *                         to which the response should be restricted
    *                         (optional)
    */
    public function doList($channels = null)
    {
        $arguments = array();

        if ($channels !== null) {
            $arguments[] = $channels;
        }

        $this->send(Phergie_Event_Request::TYPE_LIST, $arguments);
    }

    /**
    * Retrieves or changes a channel topic.
    *
    * @param string $channel Name of the channel
    * @param string $topic New topic to assign (optional)
    */
    public function doTopic($channel, $topic = null)
    {
        $arguments = array($channel);

        if ($topic !== null) {
            $arguments[] = $topic;
        }

        $this->send(Phergie_Event_Request::TYPE_TOPIC, $arguments);
    }

    /**
    * Retrieves or changes a channel or user mode.
    *
    * @param string $target Channel name or user nick
    * @param string $mode New mode to assign (optional)
    */
    public function doMode($target, $mode = null)
    {
        $arguments = array($target);

        if ($mode !== null) {
            $arguments[] = $mode;
        }

        $this->send(Phergie_Event_Request::TYPE_MODE, $arguments);
    }

    /**
    * Changes the client nick.
    *
    * @param string $nick New nick to assign
    */
    public function doNick($nick)
    {
        $this->send(Phergie_Event_Request::TYPE_NICK, array($nick));
    }

    /**
    * Retrieves information about a nick.
    *
    * @param string $nick
    */
    public function doWhois($nick)
    {
        $this->send(Phergie_Event_Requset::TYPE_WHOIS, array($nick));
    }

    /**
    * Sends a message to a nick or channel.
    *
    * @param string $target Channel name or user nick
    * @param string $text Text of the message to send
    */
    public function doPrivmsg($target, $text)
    {
        $this->send(Phergie_Event_Request::TYPE_PRIVMSG, array($target, $text));
    }

    /**
    * Sends a notice to a nick or channel.
    *
    * @param string $target Channel name or user nick
    * @param string $text Text of the notice to send
    */
    public function doNotice($target, $text)
    {
        $this->send(Phergie_Event_Request::TYPE_NOTICE, array($target, $text));
    }

    /**
    * Kicks a user from a channel.
    *
    * @param string $nick Nick of the user
    * @param string $channel Channel name
    * @param string $reason Reason for the kick (optional)
    */
    public function doKick($nick, $channel, $reason = null)
    {
        $arguments = array($nick, $channel);

        if ($reason !== null) {
            $arguments[] = $reason;
        }

        $this->send(Phergie_Event_Request::TYPE_KICK, $arguments);
    }

    /**
    * Responds to a server test of client responsiveness.
    *
    * @param string $daemon Daemon from which the original request originates
    */
    public function doPong($daemon)
    {
        $this->send(Phergie_Event_Request::TYPE_PONG, array($daemon));
    }

    /**
    * Sends a CTCP command to a nick or channel.
    *
    * @param string $target Channel name or user nick
    * @param string $command Command to send
    * @param array $arguments Ordered array of arguments to include
    *                         (optional)
    */
    protected function sendCtcp($target, $command, array $arguments = array())
    {
        $this->doPrivmsg($target, chr(1) . strtoupper($command) . ' ' . implode(' ', $arguments) . chr(1));
    }

    /**
    * Sends a /me action to a nick or channel.
    *
    * @param string $target Channel name or user nick
    * @param string $text Text of the action to perform
    */
    public function doAction($target, $text)
    {
        $this->sendCtcp($target, Phergie_Event_Request::TYPE_ACTION, array($text));
    }
}