497 lines
15 KiB
PHP
Executable file
497 lines
15 KiB
PHP
Executable file
<?php
|
|
/**
|
|
* This file is part of GameQ.
|
|
*
|
|
* GameQ is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License as published by
|
|
* the Free Software Foundation; either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* GameQ 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 Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/**
|
|
* Valve Source Engine Protocol Class
|
|
*
|
|
* This class is used as the basis for all other source based servers
|
|
* that rely on the source protocol for game querying
|
|
*
|
|
* @author Austin Bischoff <austin@codebeard.com>
|
|
*/
|
|
class GameQ_Protocols_Source extends GameQ_Protocols
|
|
{
|
|
|
|
/*
|
|
* Source engine type constants
|
|
*/
|
|
const SOURCE_ENGINE = 0;
|
|
|
|
const GOLDSOURCE_ENGINE = 1;
|
|
|
|
/**
|
|
* Array of packets we want to look up.
|
|
* Each key should correspond to a defined method in this or a parent class
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $packets = [
|
|
self::PACKET_CHALLENGE => "\xFF\xFF\xFF\xFF\x56\x00\x00\x00\x00",
|
|
self::PACKET_DETAILS => "\xFF\xFF\xFF\xFFTSource Engine Query\x00",
|
|
self::PACKET_PLAYERS => "\xFF\xFF\xFF\xFF\x55%s",
|
|
self::PACKET_RULES => "\xFF\xFF\xFF\xFF\x56%s",
|
|
];
|
|
|
|
/**
|
|
* Methods to be run when processing the response(s)
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $process_methods = [
|
|
"process_details",
|
|
"process_players",
|
|
"process_rules",
|
|
];
|
|
|
|
/**
|
|
* Default port for this server type
|
|
*
|
|
* @var int
|
|
*/
|
|
protected $port = 27015; // Default port, used if not set when instanced
|
|
|
|
/**
|
|
* The query protocol used to make the call
|
|
*
|
|
* @var string
|
|
*/
|
|
protected $protocol = 'source';
|
|
|
|
/**
|
|
* String name of this protocol class
|
|
*
|
|
* @var string
|
|
*/
|
|
protected $name = 'source';
|
|
|
|
/**
|
|
* Longer string name of this protocol class
|
|
*
|
|
* @var string
|
|
*/
|
|
protected $name_long = "Source Server";
|
|
|
|
/**
|
|
* Define the Source engine type. By default it is assumed to be Source
|
|
*
|
|
* @var int
|
|
*/
|
|
protected $source_engine = self::SOURCE_ENGINE;
|
|
|
|
protected $join_link = "steam://connect/%s:%d/";
|
|
|
|
/**
|
|
* Parse the challenge response and apply it to all the packet types
|
|
* that require it.
|
|
*
|
|
* @see GameQ_Protocols_Core::parseChallengeAndApply()
|
|
*/
|
|
protected function parseChallengeAndApply()
|
|
{
|
|
|
|
// Skip the header
|
|
$this->challenge_buffer->skip(5);
|
|
|
|
// Apply the challenge and return
|
|
return $this->challengeApply($this->challenge_buffer->read(4));
|
|
}
|
|
|
|
/*
|
|
* Internal methods
|
|
*/
|
|
|
|
/**
|
|
* Pre-process the server details data that was returned.
|
|
*
|
|
* @param array $packets
|
|
*/
|
|
protected function preProcess_details($packets)
|
|
{
|
|
|
|
// Process the packets
|
|
return $this->process_packets($packets);
|
|
}
|
|
|
|
/**
|
|
* Handles processing the details data into a usable format
|
|
*
|
|
* @throws GameQ_ProtocolsException
|
|
*/
|
|
protected function process_details()
|
|
{
|
|
|
|
// Make sure we have a valid response
|
|
if (!$this->hasValidResponse(self::PACKET_DETAILS)) {
|
|
return [ ];
|
|
}
|
|
|
|
// Set the result to a new result instance
|
|
$result = new GameQ_Result();
|
|
|
|
// Let's preprocess the rules
|
|
$data = $this->preProcess_details($this->packets_response[self::PACKET_DETAILS]);
|
|
|
|
// Create a new buffer
|
|
$buf = new GameQ_Buffer($data);
|
|
|
|
// Skip the header (0xFF0xFF0xFF0xFF)
|
|
$buf->skip(4);
|
|
|
|
// Get the type
|
|
$type = $buf->read(1);
|
|
|
|
// Make sure the data is formatted properly
|
|
// Source is 0x49, Goldsource is 0x6d, 0x44 I am not sure about
|
|
if (!in_array($type, [ "\x49", "\x44", "\x6d" ])) {
|
|
throw new GameQ_ProtocolsException("Data for " . __METHOD__
|
|
. " does not have the proper header type (should be 0x49|0x44|0x6d). Header type: 0x"
|
|
. bin2hex($type));
|
|
return [ ];
|
|
}
|
|
|
|
// Update the engine type for other calls and other methods, if necessary
|
|
if (bin2hex($type) == '6d') {
|
|
$this->source_engine = self::GOLDSOURCE_ENGINE;
|
|
}
|
|
|
|
// Check engine type
|
|
if ($this->source_engine == self::GOLDSOURCE_ENGINE) {
|
|
$result->add('address', $buf->readString());
|
|
} else {
|
|
$result->add('protocol', $buf->readInt8());
|
|
}
|
|
|
|
$result->add('hostname', $buf->readString());
|
|
$result->add('map', $buf->readString());
|
|
$result->add('game_dir', $buf->readString());
|
|
$result->add('game_descr', $buf->readString());
|
|
|
|
// Check engine type
|
|
if ($this->source_engine != self::GOLDSOURCE_ENGINE) {
|
|
$result->add('steamappid', $buf->readInt16());
|
|
}
|
|
|
|
$result->add('num_players', $buf->readInt8());
|
|
$result->add('max_players', $buf->readInt8());
|
|
|
|
// Check engine type
|
|
if ($this->source_engine == self::GOLDSOURCE_ENGINE) {
|
|
$result->add('version', $buf->readInt8());
|
|
} else {
|
|
$result->add('num_bots', $buf->readInt8());
|
|
}
|
|
|
|
$result->add('dedicated', $buf->read());
|
|
$result->add('os', $buf->read());
|
|
$result->add('password', $buf->readInt8());
|
|
|
|
// Check engine type
|
|
if ($this->source_engine == self::GOLDSOURCE_ENGINE) {
|
|
$result->add('ismod', $buf->readInt8());
|
|
|
|
if ($result->get('ismod')) {
|
|
$result->add('mod_urlinfo', $buf->readString());
|
|
$result->add('mod_urldl', $buf->readString());
|
|
$buf->skip();
|
|
$result->add('mod_version', $buf->readInt32Signed());
|
|
$result->add('mod_size', $buf->readInt32Signed());
|
|
$result->add('mod_type', $buf->readInt8());
|
|
$result->add('mod_cldll', $buf->readInt8());
|
|
}
|
|
}
|
|
|
|
$result->add('secure', $buf->readInt8());
|
|
|
|
if ($this->source_engine == self::SOURCE_ENGINE) {
|
|
if ($result->get('steamappid') == 2400) {
|
|
$result->add('game_mode', $buf->readInt8());
|
|
$result->add('witness_count', $buf->readInt8());
|
|
$result->add('witness_time', $buf->readInt8());
|
|
}
|
|
}
|
|
|
|
// Check engine type
|
|
if ($this->source_engine == self::GOLDSOURCE_ENGINE) {
|
|
$result->add('num_bots', $buf->readInt8());
|
|
} else {
|
|
$result->add('version', $buf->readString());
|
|
}
|
|
|
|
// Extra data flag
|
|
if ($buf->lookAhead(1) !== false) {
|
|
// Extra data flag
|
|
$edf = $buf->readInt8();
|
|
|
|
if ($edf & 0x80) {
|
|
$result->add('port', $buf->readInt16Signed());
|
|
}
|
|
|
|
if ($edf & 0x10) {
|
|
$a = $buf->readInt32();
|
|
$b = $buf->readInt32();
|
|
|
|
$result->add('steam_id', ($b << 32) | $a);
|
|
unset($a, $b);
|
|
}
|
|
|
|
if ($edf & 0x40) {
|
|
$result->add('sourcetv_port', $buf->readInt16Signed());
|
|
$result->add('sourcetv_name', $buf->readString());
|
|
}
|
|
|
|
if ($edf & 0x20) {
|
|
$result->add('keywords', $buf->readString());
|
|
}
|
|
|
|
if ($edf & 0x01) {
|
|
$a = $buf->readInt32();
|
|
$b = $buf->readInt32();
|
|
|
|
$result->add('game_id', ($b << 32) | $a);
|
|
unset($a, $b);
|
|
}
|
|
|
|
unset($edf);
|
|
}
|
|
|
|
unset($buf);
|
|
|
|
return $result->fetch();
|
|
}
|
|
|
|
/**
|
|
* Pre-process the player data sent
|
|
*
|
|
* @param array $packets
|
|
*/
|
|
protected function preProcess_players($packets)
|
|
{
|
|
|
|
// Process the packets
|
|
return $this->process_packets($packets);
|
|
}
|
|
|
|
/**
|
|
* Handles processing the player data into a useable format
|
|
*
|
|
* @throws GameQ_ProtocolsException
|
|
*/
|
|
protected function process_players()
|
|
{
|
|
|
|
// Make sure we have a valid response
|
|
if (!$this->hasValidResponse(self::PACKET_PLAYERS)) {
|
|
return [ ];
|
|
}
|
|
|
|
// Set the result to a new result instance
|
|
$result = new GameQ_Result();
|
|
|
|
// Let's preprocess the rules
|
|
$data = $this->preProcess_players($this->packets_response[self::PACKET_PLAYERS]);
|
|
|
|
// Create a new buffer
|
|
$buf = new GameQ_Buffer($data);
|
|
|
|
// Make sure the data is formatted properly
|
|
if (($header = $buf->read(5)) != "\xFF\xFF\xFF\xFF\x44") {
|
|
throw new GameQ_ProtocolsException("Data for " . __METHOD__
|
|
. " does not have the proper header (should be 0xFF0xFF0xFF0xFF0x44). Header: "
|
|
. bin2hex($header));
|
|
return [ ];
|
|
}
|
|
|
|
// Pull out the number of players
|
|
$num_players = $buf->readInt8();
|
|
|
|
// Player count
|
|
$result->add('num_players', $num_players);
|
|
|
|
// No players so no need to look any further
|
|
if ($num_players == 0) {
|
|
return $result->fetch();
|
|
}
|
|
|
|
// Players list
|
|
while ($buf->getLength()) {
|
|
$result->addPlayer('id', $buf->readInt8());
|
|
$result->addPlayer('name', $buf->readString());
|
|
$result->addPlayer('score', $buf->readInt32Signed());
|
|
$result->addPlayer('time', $buf->readFloat32());
|
|
}
|
|
|
|
unset($buf);
|
|
|
|
return $result->fetch();
|
|
}
|
|
|
|
/**
|
|
* Pre process the rules data that was returned. Make sure the return
|
|
* data is in a single string
|
|
*
|
|
* @param array $packets
|
|
*/
|
|
protected function preProcess_rules($packets)
|
|
{
|
|
|
|
// Process the packets
|
|
return $this->process_packets($packets);
|
|
}
|
|
|
|
/**
|
|
* Handles processing the rules data into a usable format
|
|
*
|
|
* @throws GameQ_ProtocolsException
|
|
*/
|
|
protected function process_rules()
|
|
{
|
|
|
|
// Make sure we have a valid response
|
|
if (!$this->hasValidResponse(self::PACKET_RULES)) {
|
|
return [ ];
|
|
}
|
|
|
|
// Set the result to a new result instance
|
|
$result = new GameQ_Result();
|
|
|
|
// Let's preprocess the rules
|
|
$data = $this->preProcess_rules($this->packets_response[self::PACKET_RULES]);
|
|
|
|
$buf = new GameQ_Buffer($data);
|
|
|
|
// Make sure the data is formatted properly
|
|
if (($header = $buf->read(5)) != "\xFF\xFF\xFF\xFF\x45") {
|
|
throw new GameQ_ProtocolsException("Data for " . __METHOD__
|
|
. " does not have the proper header (should be 0xFF0xFF0xFF0xFF0x45). Header: "
|
|
. bin2hex($header));
|
|
return [ ];
|
|
}
|
|
|
|
// Count the number of rules
|
|
$num_rules = $buf->readInt16Signed();
|
|
|
|
// Add the count of the number of rules this server has
|
|
$result->add('num_rules', $num_rules);
|
|
|
|
// Rules
|
|
while ($buf->getLength()) {
|
|
$result->add($buf->readString(), $buf->readString());
|
|
}
|
|
|
|
unset($buf);
|
|
|
|
return $result->fetch();
|
|
}
|
|
|
|
/**
|
|
* Process the packets to make sure we combine and decompress as needed
|
|
*
|
|
* @param array $packets
|
|
*
|
|
* @throws GameQ_ProtocolsException
|
|
* @return string
|
|
*/
|
|
protected function process_packets($packets)
|
|
{
|
|
|
|
// Make a buffer to see if we should have multiple packets
|
|
$buffer = new GameQ_Buffer($packets[0]);
|
|
|
|
// First we need to see if the packet is split
|
|
// -2 = split packets
|
|
// -1 = single packet
|
|
$packet_type = $buffer->readInt32Signed();
|
|
|
|
// This is one packet so just return the rest of the buffer
|
|
if ($packet_type == -1) {
|
|
// Free some memory
|
|
unset($buffer);
|
|
|
|
// We always return the packet as expected, with null included
|
|
return $packets[0];
|
|
}
|
|
|
|
// Free some memory
|
|
unset($buffer);
|
|
|
|
// Init array so we can order
|
|
$packs = [ ];
|
|
|
|
// We have multiple packets so we need to get them and order them
|
|
foreach ($packets AS $packet) {
|
|
// Make a buffer so we can read this info
|
|
$buffer = new GameQ_Buffer($packet);
|
|
|
|
// Pull some info
|
|
$packet_type = $buffer->readInt32Signed();
|
|
$request_id = $buffer->readInt32Signed();
|
|
|
|
// Check to see if this is compressed
|
|
if ($request_id & 0x80000000) {
|
|
// Check to see if we have Bzip2 installed
|
|
if (!function_exists('bzdecompress')) {
|
|
throw new GameQ_ProtocolsException('Bzip2 is not installed. See http://www.php.net/manual/en/book.bzip2.php for more info.',
|
|
0);
|
|
return false;
|
|
}
|
|
|
|
// Get some info
|
|
$num_packets = $buffer->readInt8();
|
|
$cur_packet = $buffer->readInt8();
|
|
$packet_length = $buffer->readInt32();
|
|
$packet_checksum = $buffer->readInt32();
|
|
|
|
// Try to decompress
|
|
$result = bzdecompress($buffer->getBuffer());
|
|
|
|
// Now verify the length
|
|
if (strlen($result) != $packet_length) {
|
|
throw new GameQ_ProtocolsException("Checksum for compressed packet failed! Length expected: {$packet_length}, length returned: "
|
|
. strlen($result));
|
|
}
|
|
|
|
// Set the new packs
|
|
$packs[$cur_packet] = $result;
|
|
} else // Normal packet
|
|
{
|
|
// Gold source does things a bit different
|
|
if ($this->source_engine == self::GOLDSOURCE_ENGINE) {
|
|
$packet_number = $buffer->readInt8();
|
|
} else // New source
|
|
{
|
|
$packet_number = $buffer->readInt16Signed();
|
|
$split_length = $buffer->readInt16Signed();
|
|
}
|
|
|
|
// Now add the rest of the packet to the new array with the packet_number as the id so we can order it
|
|
$packs[$packet_number] = $buffer->getBuffer();
|
|
}
|
|
|
|
unset($buffer);
|
|
}
|
|
|
|
// Free some memory
|
|
unset($packets, $packet);
|
|
|
|
// Sort the packets by packet number
|
|
ksort($packs);
|
|
|
|
// Now combine the packs into one and return
|
|
return implode("", $packs);
|
|
}
|
|
}
|