Source for file GameServerQuery.php

<?php
// +----------------------------------------------------------------------+
// | PHP Version 4                                                        |
// +----------------------------------------------------------------------+
// | Copyright (c) 1997-2004 The PHP Group                                |
// +----------------------------------------------------------------------+
// | This source file is subject to version 2 of the PHP license,         |
// | that is bundled with this package in the file LICENSE, and is        |
// | available at through the world-wide-web at                           |
// | http://au.php.net/license/3_0.txt.                                    |
// | If you did not receive a copy of the PHP license and are unable to   |
// | obtain it through the world-wide-web, please send a note to          |
// | license@php.net so we can mail you a copy immediately.               |
// +----------------------------------------------------------------------+
// | Author: Aidan Lister <aidan@virtualexplorer.com.au>                  |
// +----------------------------------------------------------------------+
 
require_once ('PEAR.php');
require_once ('function.microtime_str.php');
 
 
/**
* Error Constants
*/
define('NET_GAMESERVERQUERY_ERROR_INVALIDPROTOCOL',      0);
define('NET_GAMESERVERQUERY_ERROR_COULDNOTCONNECT',      1);
define('NET_GAMESERVERQUERY_ERROR_NOREPLY',              2);
define('NET_GAMESERVERQUERY_ERROR_COULDNOTSEND',         3);
 
 
/**
* Net_GameServerQuery
*
* Communicate with a Half-Life server.
*
* @version        0.1
* @package        Net_GameServerQuery
*/
class Net_GameServerQuery
{
    /**
    * The resource ID of the connection
    *
    * @var          resource 
    * @access       private
    */
    private $_socket;
 
    /**
    * True if we have a udp "connection" open.
    *
    * @var          bool 
    * @access       private
    */
    private $_connected;
 
     /**
    * The IP we're connecting to
    *
    * @var          string 
    * @access       private
    */
    private $_ip;
 
    /**
    * The port we wish to query
    *
    * @var          string 
    * @access       private
    */
    private $_port;
 
    /**
    * Max time in seconds to send data for
    *
    * @var          int 
    * @access       private
    */
    private $_timeout_stream;
 
    /**
    * Max time in seconds to attempt connection
    *
    * @var          int 
    * @access       private
    */
    private $_timeout_connect;
 
    /**
    * What packet protocol we are using
    *
    * @var          string 
    * @access       private
    */
    private $_protocol;
 
    /**
    * Ping from the server
    *
    * @var          string 
    * @access       private
    */
    private $_ping;
 
    /**
    * Constructor
    *
    * @version      0.1
    * @access       public
    */
    public function __construct ()
    {
        // Set some defaults
        $this->_timeout_stream = 1;
        $this->_timeout_connect = 1;
    }
 
 
    /**
    * Query a server
    *
    * @version      0.1
    * @param        string $protocol The protocol to use (name of the game)
    * @param        string $ip The address to connect to
    * @param        int $port The information port of the server
    * @return       mixed true if query was successful, or a PEAR_Error if not.
    * @access       public
    */
    public function query ($ip, $port, $protocol)
    {
        // Load the protocols ($games, $protcols)
        include_once ('GameServerQuery/protocols.php');
        
        // Check the protocol
        if (array_key_exists($protocol, $games)) {
            $this->_protocol = $protocols[$games[$protocol]['protocol']]; }
 
        else {
            // Throw error
            return new Net_GameServerQuery_Error (NET_GAMESERVERQUERY_ERROR_INVALIDPROTOCOL); }
 
        // Save IP/Port
        $this->_ip = $ip;
        $this->_port = $port;
 
        // Perform the actual query
        // $data is now the raw response from the server or an error
        $data = $this->_proceduralquery();
        
        // Check if there was an error
        // If there was, return the error obj
        if ($data instanceof Net_GameServerQuery_Error) {
            return $data; }
 
        // If there wasn't, return the result object
        else {
            // We parse a formatted associative array to the result object
            $info = $this->_format($data);
 
            return new Net_GameServerQuery_Result ($info, $this->_ping, $this->_protocol); }
    }
 
 
    /**
    * Connect, Query, Receive and Disconnect
    *
    * @version      0.1
    * @return       mixed true if query was successful, or a PEAR_Error if not.
    * @access       public
    */
    private function _proceduralquery ()
    {
        // Connect
        if (!$this->_connect($this->_ip, $this->_port)) {
            // Throw Error
            return new Net_GameServerQuery_Error(NET_GAMESERVERQUERY_ERROR_COULDNOTCONNECT);
        }
 
        // Build Packet
        $packet = $this->_build();
 
        // Start the timer
        $start = microtime_str();
 
        // Send Packet
        if (!$this->_send($packet)) {
            // Throw Error
            return new Net_GameServerQuery_Error(NET_GAMESERVERQUERY_ERROR_COULDNOTSEND);
        }
 
        // Receive
        $data = $this->_receive();
        if (empty($data)) {
            // Throw Error
            return new Net_GameServerQuery_Error(NET_GAMESERVERQUERY_ERROR_NOREPLY);
        }
 
        // When we recieve the reply, end the timer
        $stop = microtime_str();
        $this->_ping = round((($stop - $start) * 1000));
 
        // Disconnect
        $this->_disconnect();
 
        return $data;
    }
 
 
    /**
    * Select the packet to use
    *
    * @version      0.1
    * @return       string The packet
    * @access       private
    */
    private function _build ()
    {
        $packet = $this->_protocol['packet'];
        return $packet;
    }
 
 
    /**
    * Take the raw server response and extract
    *     the information into an assoc array
    *
    * @version      0.1
    * @param        string $data The string from which to parse the data
    * @access       private
    * @return       array Associative array of server data
    */  
    private function _format($data)
    {
        // Some games return the information in the second chunk
        // so we need to define the delimiters for the chunk segments
        $delimiter = $this->_protocol['delim'];
 
        // Get the second chunk if need be
        if ($delimiter !== null) {
            list(, $data) = explode($delimiter, $data); }
        
        // The data chunk is backslash delimited
        // Remove the first backslash, then explode
        $data = substr($data, 1);
        $data_arr = explode ('\\', $data);
 
        // Sort the data into an assoc array
        for ($i = 0, $x = count($data_arr); $i < $x; $i += 2) {
            $info[$data_arr[$i]] = $data_arr[$i+1]; }
 
        return $info;
    }
 
 
    /**
    * Connect
    *
    * @version      0.1
    * @param        string $ip IP of the server
    * @param        string $port Port of the server
    * @return       bool True if the connection is established
    * @access       private
    */
    private function _connect ($ip, $port)
    {
        // "Connect"
        $fp = fsockopen('udp://' . $ip, $port, $errno, $errstr, $this->_timeout_connect);
 
        // Check if connection was successful
        if (false !== $fp)
        {
            // Save the connection
            $this->_socket = $fp;
            $this->_connected = true;
 
            // Set stream options
            socket_set_timeout($this->_socket, $this->_timeout_stream, 0);
            socket_set_blocking($this->_socket, true);
 
            return true;
        }
        
        return false;
    }
 
 
    /**
    * Disconnect
    *
    * @version      0.1
    * @return       bool True if the connection was closed
    * @access       private
    */
    private function _disconnect ()
    {
        // Check if we're connected
        if ($this->_connected !== true) {
            return false; }
 
        fclose($this->_socket);
        return true;
    }
 
 
 
    /**
    * Send packet
    *
    * @version      0.1
    * @param        string $packet The packet to send
    * @return       bool True if the packet was sent
    * @access       private
    */
    private function _send ($packet)
    {
        // Check if we're connected
        if ($this->_connected !== true) {
            return false; }
        
        // If we have multiple packets
        if (is_array($packet))
        {
            foreach ($packet as $pack)
            {
                if (!fwrite($this->_socket, $pack)) {
                    return false; }
            }
        }
        
        // If we have a single packet
        else
        {
            if (!fwrite($this->_socket, $packet)) {
                return false; }
        }
 
        return true;
    }
 
 
    /**
    * Receive packet
    *
    * @version      0.1
    * @access       private
    */    
    private function _receive()
    {
        // Read the first bit, this will tell us if we have a valid packet
        $data = fread($this->_socket, 1);
        $metadata = socket_get_status($this->_socket);
        $bytesleft = $metadata['unread_bytes'];
 
        // If we have a valid packet, read the rest of it
        while ($bytesleft > 0)
        {
            $data .= fread($this->_socket, $bytesleft);
            $metadata = socket_get_status($this->_socket);
            $bytesleft = $metadata['unread_bytes'];
        }
 
        return $data;
    }
 
 
    /**
    * Return microtime as a single string.
    *
    * @version        0.1
    */
    private function microtime_str()
    { 
        list ($msec, $sec) = explode (" ", microtime()); 
        $microtime = (float)$msec + (float)$sec;
        return $microtime; 
    }
 
}
 
 
/**
* Net_GameServerQuery_Result
*
* Result object for GameServerQuery.
*
* @version        0.1
* @package        Net_GameServerQuery
*/
class Net_GameServerQuery_Result
{
    /**
    * Hold the assoc. array from a query request
    *
    * @var          string 
    * @access       private
    */
    private $_data;
 
    /**
    * Ping
    *
    * @var          string 
    * @access       private
    */
    private $_ping;
 
 
    /**
    * Constructor
    *
    * @version      0.1
    * @param        string $data The raw array of packet data
    * @param        int $ping The ping in milliseconds
    * @param        array $prot The query protocol information
    * @access       public
    */
    public function __construct ($data, $ping, $prot)
    {
        $this->_data      = $data;
        $this->_ping      = $ping;
        $this->_protocol  = $prot;
    }
 
 
    /**
    * Basic "status" information
    *
    * @version      0.1
    * @return       array The associative array of server data
    * @access       public
    */
    public function status ()
    {
        // Get a list of the raw packet status keys
        $keys = $this->_protocol['keys'];
 
        // Normalise the raw packet
        // numplayers is not supported for all game protocols, yet
        $normal = array (
            'maxplayers'    => $this->_data[$keys[0]],
            'numplayers'    => @$this->_data[$keys[1]],
            'mapname'       => $this->_data[$keys[2]],
            'hostname'      => $this->_data[$keys[3]],
            );
 
        return $normal;
    }
 
 
    /**
    * Raw packet data
    *
    * @version      0.1
    * @return       array The associative array of server data
    * @access       public
    */
    public function raw ()
    {
        return $this->_data;
    }
 
 
    /**
    * Information about players on the server
    *
    * This function is not complete. It will return a dummy array of player information.
    *
    * @version      0.1
    * @return       array The associative array of server data
    * @access       public
    */
    public function players ()
    {
        return false;
    }
 
 
    /**
    * Rules listing
    * 
    * This function is not complete. It will return false.
    *
    * @version      0.1
    * @return       array The associative array of server data
    * @access       public
    */
    public function rules ()
    {
        return false;
    }
 
 
    /**
    * The time it took the server to respond to a request
    *
    * @version      0.1
    * @return       float Ping in milliseconds
    * @access       public
    */
    public function ping ()
    {
        return $this->_ping;
    }
 
}
 
 
/**
* Net_GameServerQuery_Error
*
* Error object for GameServerQuery.
*
* @version        0.1
* @package        Net_GameServerQuery
*/
class Net_GameServerQuery_Error
{
    /**
    * Error Number
    *
    * @var          string 
    * @access       private
    */
    private $_errno;
 
 
    /**
    * Constructor
    *
    * @version      0.1
    * @return       constant The error code
    * @access       public
    */
    function __construct($errno)
    {
        $this->_errno = $errno;
    }
 
 
    /**
    * Print an error
    *
    * @version      0.1
    * @return       constant The error code
    * @access       public
    */
    function printError()
    {
        $errors = array (
            NET_GAMESERVERQUERY_ERROR_INVALIDPROTOCOL        => 'Invalid Protocol',
            NET_GAMESERVERQUERY_ERROR_COULDNOTCONNECT        => 'Could not connect to specified server',
            NET_GAMESERVERQUERY_ERROR_NOREPLY                => 'Server did not reply to request',
            NET_GAMESERVERQUERY_ERROR_COULDNOTSEND           => 'Could not send packet'
        );
 
        print $errors[$this->_errno];
    }
 
}
 
?>