websocket.class.php

<?php

/**
 * Simple implementation of HTML5 WebSocket server-side.
 *
 * PHP versions 5
 *
 * This program 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.
 *
 * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * @package    WebSocket
 * @author     George Nava <georgenava@gmail.com>
 * @author     Vincenzo Ferrari <wilk3ert@gmail.com>
 * @copyright  2010-2011
 * @license    http://www.gnu.org/licenses/gpl.txt GNU GPLv3
 * @version    1.1.0
 * @link       http://code.google.com/p/phpwebsocket/
 */

    /**
     * @usage $master = new WebSocket ("localhost", 12345);
     */
    class WebSocket {
        var $master;
        var $sockets = array ();
        var $users = array ();
        // true to debug
        var $debug = false;
        // frame mask
        var $masks;
        // initial frames
        var $initFrame;

        function __construct ($address, $port) {
            error_reporting (E_ALL);
            set_time_limit (0);
            ob_implicit_flush ();

            // Socket creation
            $this->master = socket_create (AF_INET, SOCK_STREAM, SOL_TCP) or die("socket_create() failed");
            socket_set_option ($this->master, SOL_SOCKET, SO_REUSEADDR, 1) or die("socket_option() failed");
            socket_bind ($this->master, $address, $port) or die("socket_bind() failed");
            socket_listen ($this->master, 20) or die("socket_listen() failed");
            $this->sockets[] = $this->master;
            $this->say ("Server Started : " . date ('Y-m-d H:i:s'));
            $this->say ("Listening on   : {$address} {$port}");
            $this->say ("Master socket  : {$this->master}\n");

            // Main loop
            while (true) {
                $changed = $this->sockets;
                socket_select ($changed, $write = NULL, $except = NULL, NULL);

                foreach ($changed as $socket) {
                    if ($socket == $this->master) {
                        $client = socket_accept ($this->master);

                        if ($client < 0) {
                            $this->log ("socket_accept() failed");
                            continue;
                        }
                        else {
                            // Connects the socket
                            $this->connect ($client);
                        }
                    }
                    else {
                        $bytes = @socket_recv ($socket, $buffer, 2048, 0);
                        if ($bytes == 0) {
                            // On socket.close ();
                            $this->disconnect ($socket);
                        }
                        else {
                            // Retrieve the user from his socket
                            $user = $this->getuserbysocket ($socket);

                            if (!$user->handshake) {
                                $this->dohandshake ($user, $buffer);
                            }
                            else {
                                $this->process ($user, $this->decode ($buffer));
                            }
                        }
                    }
                }
            }
        }

        /**
         * @brief Echo incoming messages back to the client
         * @note Extend and modify this method to suit your needs
         * @param $user {User} : owner of the message
         * @param $msg {String} : the message to echo
         * @return void
         */
        function process ($user, $msg) {
            $this->send ($user->socket, $msg);
        }

        /**
         * @brief Send a message to a client
         * @param $client {Socket} : socket to send the message
         * @param $msg {String} : the message to send
         * @return void
         */
        function send ($client, $send_msg) {
            $this->say ("> {$send_msg}");
            $send_msg = $this->encode ($send_msg);
            socket_write ($client, $send_msg, strlen ($send_msg));
        }

        /**
         * @brief Connect a new client (socket)
         * @param $socket {Socket} : socket to connect
         * @return void
         */
        function connect ($socket) {
            $user = new User ();
            $user->id = uniqid ();
            $user->socket = $socket;

            array_push ($this->users, $user);
            array_push ($this->sockets, $socket);

            $this->log ("{$socket} CONNECTED!");
            $this->log (date ("d/n/Y ") . "at " . date ("H:i:s T"));
        }

        /**
         * @brief Disconnect a client (socket)
         * @param $socket {Socket} : socket to disconnect
         * @return void
         */
        function disconnect ($socket) {
            $found = null;
            $n = count ($this->users);

            // Finds the right user index from the given socket
            for ($i = 0; $i < $n; $i++) {
                if ($this->users[$i]->socket == $socket) {
                    $found = $i;
                    break;
                }
            }

            if (!is_null ($found)) {
                array_splice ($this->users, $found, 1);
            }

            $index = array_search ($socket, $this->sockets);
            socket_close ($socket);
            $this->log ("{$socket} DISCONNECTED!");

            if ($index >= 0) {
                array_splice ($this->sockets, $index, 1);
            }
        }

        /**
         * @brief Do the handshake between server and client
         * @param $user {User} : user to handshake
         * @param $buffer {String} : user's request
         * @return Boolean
         */
        function dohandshake ($user, $buffer) {
            $this->log ("\nRequesting handshake...");
            $this->log ($buffer);

            list ($resource, $host, $connection, $version, $origin, $key, $upgrade) = $this->getheaders ($buffer);

            $this->log ("Handshaking...");
            $reply  =
                "HTTP/1.1 101 Switching Protocols\r\n" .
                "Upgrade: {$upgrade}\r\n" .
                "Connection: {$connection}\r\n" .
                "Sec-WebSocket-Version: {$version}\r\n" .
                "Sec-WebSocket-Origin: {$origin}\r\n" .
                "Sec-WebSocket-Location: ws://{$host}{$resource}\r\n" .
                "Sec-WebSocket-Accept: " . $this->calcKey ($key) . "\r\n" .
                "\r\n";

            // Closes the handshake
            socket_write ($user->socket, $reply, strlen ($reply));

            $user->handshake = true;
            $this->log ($reply);
            $this->log ("Done handshaking...");

            return true;
        }

        /**
         * @brief Calculate Sec-WebSocket-Accept
         * @note For more info look at: http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17
         * @param $key {String} : key to calculate
         * @return Calculated key
         */
        function calcKey ($key) {
            // Constant string as specified in the ietf-hybi-17 draft
            $key .= "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
                $key = sha1 ($key);
                $key = pack ('H*', $key);
                $key = base64_encode ($key);

                return $key;
        }

        /**
         * @brief Get the client request headers
         * @param $buffer {String} : buffer from which to draw the headers.
         * @return Array
         */
        function getheaders ($buffer) {
            $resource = $host = $connection = $version = $origin = $key = $upgrade = null;

            preg_match ('#GET (.*?) HTTP#', $buffer, $match) && $resource = $match[1];
            preg_match ("#Host: (.*?)\r\n#", $buffer, $match) && $host = $match[1];
            preg_match ("#Connection: (.*?)\r\n#", $buffer, $match) && $connection = $match[1];
            preg_match ("#Sec-WebSocket-Version: (.*?)\r\n#", $buffer, $match) && $version = $match[1];
            preg_match ("#Sec-WebSocket-Origin: (.*?)\r\n#", $buffer, $match) && $origin = $match[1];
            preg_match ("#Sec-WebSocket-Key: (.*?)\r\n#", $buffer, $match) && $key = $match[1];
            preg_match ("#Upgrade: (.*?)\r\n#", $buffer, $match) && $upgrade = $match[1];

            return array ($resource, $host, $connection, $version, $origin, $key, $upgrade);
        }

        /**
         * @brief Retrieve an user from his socket
         * @param $socket {Socket} : socket of the user to search
         * @return User or null
         */
        function getuserbysocket ($socket) {
            $found = null;

            foreach ($this->users as $user) {
                if ($user->socket == $socket) {
                    $found = $user;
                    break;
                }
            }

            return $found;
        }

        /**
         * @brief Decode messages as specified in the ietf-hybi-17 draft
         * @param $msg {String} : message to decode
         * @return Message decoded
         */
        function decode ($msg) {
            $len = $data = $decoded = $index = null;
            $len = $msg[1] & 127;

            if ($len === 126) {
                $this->masks = substr ($msg, 4, 4);
                $data = substr ($msg, 8);
                $this->initFrame = substr ($msg, 0, 4);
            }
            else if ($len === 127) {
                $this->masks = substr ($msg, 10, 4);
                $data = substr ($msg, 14);
                $this->initFrame = substr ($msg, 0, 10);
            }
            else {
                $this->masks = substr ($msg, 2, 4);
                $data = substr ($msg, 6);
                $this->initFrame = substr ($msg, 0, 2);
            }

            for ($index = 0; $index < strlen ($data); $index++) {
                $decoded .= $data[$index] ^ $this->masks[$index % 4];
            }

            return $decoded;
        }

        /**
         * @brief Encode messages
         * @param $msg {String} : message to encode
         * @return Message encoded
         */
        function encode ($send_msg) {
            $index = $encoded = null;

            for ($index = 0; $index < strlen ($send_msg); $index++) {
                $encoded .= $send_msg[$index] ^ $this->masks[$index % 4];
            }

            $encoded = $this->initFrame . $this->masks . $encoded;

            return $encoded;
        }

        /**
         * @brief Local echo messages
         * @param $msg {String} : message to echo
         * @return void
         */
        function say ($msg = "") {
            echo "{$msg}\n";
        }

        /**
         * @brief Log function
         * @param $msg {String} : message to log
         * @return void
         */
        function log ($msg = "") {
            if ($this->debug) {
                echo "{$msg}\n";
            }
        }
    }

    class User {
        var $id;
        var $socket;
        var $handshake;
    }
?>