Gamespy3::cleanPackets() - Code Metrics - Inspection of "Changed how GameSpy3 processes the data. We no lo..." - Austinb/GameQ - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — v3 ( e9ba49...9aaf4b )

by Austin

created 2017-10-09 19:42 UTC

Gamespy3::cleanPackets() C

↳ Parent: Gamespy3

Complexity

Conditions	7
Paths	9

Size

Total Lines	46
Code Lines	18

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	56

Importance

Changes

Metric	Value
dl	0
loc	46
ccs	0
cts	18
cp	0
rs	6.7272
c	0
b	0
f	0
cc	7
eloc	18
nc	9
nop	1
crap	56

<?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/>.
 */

namespace GameQ\Protocols;

use GameQ\Protocol;
use GameQ\Buffer;
use GameQ\Result;

/**
 * GameSpy3 Protocol class
 *
 * Given the ability for non utf-8 characters to be used as hostnames, player names, etc... this
 * version returns all strings utf-8 encoded (utf8_encode).  To access the proper version of a
 * string response you must use utf8_decode() on the specific response.
 *
 * @author Austin Bischoff <[email protected]>
 */
class Gamespy3 extends Protocol
{

    /**
     * Array of packets we want to look up.
     * Each key should correspond to a defined method in this or a parent class
     *
     * @type array
     */
    protected $packets = [
        self::PACKET_CHALLENGE => "\xFE\xFD\x09\x10\x20\x30\x40",
        self::PACKET_ALL       => "\xFE\xFD\x00\x10\x20\x30\x40%s\xFF\xFF\xFF\x01",
    ];

    /**
     * The query protocol used to make the call
     *
     * @type string
     */
    protected $protocol = 'gamespy3';

    /**
     * String name of this protocol class
     *
     * @type string
     */
    protected $name = 'gamespy3';

    /**
     * Longer string name of this protocol class
     *
     * @type string
     */
    protected $name_long = "GameSpy3 Server";

    /**
     * The client join link
     *
     * @type string
     */
    protected $join_link = null;

    /**
     * This defines the split between the server info and player/team info.
     * This value can vary by game. This value is the default split.
     *
     * @var string
     */
    protected $packetSplit = "/\\x00\\x00\\x01/m";

    /**
     * Parse the challenge response and apply it to all the packet types
     *
     * @param \GameQ\Buffer $challenge_buffer
     *
     * @return bool
     * @throws \GameQ\Exception\Protocol
     */
    public function challengeParseAndApply(Buffer $challenge_buffer)
    {

        // Pull out the challenge
        $challenge = substr(preg_replace("/[^0-9\-]/si", "", $challenge_buffer->getBuffer()), 1);
        $challenge_result = sprintf(
            "%c%c%c%c",
            ($challenge >> 24),
            ($challenge >> 16),
            ($challenge >> 8),
            ($challenge >> 0)
        );

        // Apply the challenge and return
        return $this->challengeApply($challenge_result);
    }

    /**
     * Process the response
     *
     * @return array
     */
    public function processResponse()
    {

        // Holds the processed packets
        $processed = [];

        // Iterate over the packets
        foreach ($this->packets_response as $response) {
            // Make a buffer
            $buffer = new Buffer($response, Buffer::NUMBER_TYPE_BIGENDIAN);

            // Packet type = 0
            $buffer->readInt8();

            // Session Id
            $buffer->readInt32();

            // We need to burn the splitnum\0 because it is not used
            $buffer->skip(9);

            // Get the id
            $id = $buffer->readInt8();

            // Burn next byte not sure what it is used for
            $buffer->skip(1);

            // Add this packet to the processed
            $processed[$id] = $buffer->getBuffer();

            unset($buffer, $id);
        }

        // Sort packets, reset index
        ksort($processed);

        // Offload cleaning up the packets if they happen to be split
        $packets = $this->cleanPackets(array_values($processed));

        // Split the packets by type general and the rest (i.e. players & teams)
        $split = preg_split($this->packetSplit, implode('', $packets));

        // Create a new result
        $result = new Result();

        // First key should be server details and rules
        $this->processDetails(new Buffer($split[0], Buffer::NUMBER_TYPE_BIGENDIAN), $result);

        // The rest should be the player and team information, if it exists
        if (array_key_exists(1, $split)) {
            $this->processPlayersAndTeams(new Buffer($split[1], Buffer::NUMBER_TYPE_BIGENDIAN), $result);
        }

        return $result->fetch();
    }

    /*
     * Internal methods
     */

    /**
     * Handles cleaning up packets since the responses can be a bit "dirty"
     *
     * @param array $packets
     *
     * @return array
     */
    protected function cleanPackets(array $packets = [])
    {

        // Get the number of packets
        $packetCount = count($packets);

        // Compare last var of current packet with first var of next packet
        // On a partial match, remove last var from current packet,
        // variable header from next packet
        for ($i = 0, $x = $packetCount; $i < $x - 1; $i++) {
            // First packet
            $fst = substr($packets[$i], 0, -1);
            // Second packet
            $snd = $packets[$i + 1];
            // Get last variable from first packet
            $fstvar = substr($fst, strrpos($fst, "\x00") + 1);
            // Get first variable from last packet
            $snd = substr($snd, strpos($snd, "\x00") + 2);
            $sndvar = substr($snd, 0, strpos($snd, "\x00"));
            // Check if fstvar is a substring of sndvar
            // If so, remove it from the first string
            if (!empty($fstvar) && strpos($sndvar, $fstvar) !== false) {
                $packets[$i] = preg_replace("#(\\x00[^\\x00]+\\x00)$#", "\x00", $packets[$i]);
            }
        }

        // Now let's loop the return and remove any dupe prefixes
        for ($x = 1; $x < $packetCount; $x++) {
            $buffer = new Buffer($packets[$x], Buffer::NUMBER_TYPE_BIGENDIAN);

            $prefix = $buffer->readString();

            // Check to see if the return before has the same prefix present
            if ($prefix != null && strstr($packets[($x - 1)], $prefix)) {
                // Update the return by removing the prefix plus 2 chars
                $packets[$x] = substr(str_replace($prefix, '', $packets[$x]), 2);
            }

            unset($buffer);
        }

        unset($x, $i, $snd, $sndvar, $fst, $fstvar);

        // Return cleaned packets
        return $packets;
    }

    /**
     * Handles processing the details data into a usable format
     *
     * @param \GameQ\Buffer $buffer
     * @param \GameQ\Result $result
     */
    protected function processDetails(Buffer &$buffer, Result &$result)
    {

        // We go until we hit an empty key
        while ($buffer->getLength()) {
            $key = $buffer->readString();
            if (strlen($key) == 0) {
                break;
            }
            $result->add($key, utf8_encode($buffer->readString()));
        }
    }

    /**
     * Handles processing the player and team data into a usable format
     *
     * @param \GameQ\Buffer $buffer
     * @param \GameQ\Result $result
     */
    protected function processPlayersAndTeams(Buffer &$buffer, Result &$result)
    {

        /*
         * Explode the data into groups. First is player, next is team (item_t)
         * Each group should be as follows:
         *
         * [0] => item_
         * [1] => information for item_
         * ...
         */
        $data = explode("\x00\x00", $buffer->getBuffer());

        // By default item_group is blank, this will be set for each loop thru the data
        $item_group = '';
        // By default the item_type is blank, this will be set on each loop
        $item_type = '';
        // Loop through all of the $data for information and pull it out into the result
        for ($x = 0; $x < count($data) - 1; $x++) {
            // Pull out the item
            $item = $data[$x];
            // If this is an empty item, move on
            if ($item == '' || $item == "\x00") {
                continue;
            }
            /*
            * Left as reference:
            *
            * Each block of player_ and team_t have preceding junk chars
            *
            * player_ is actually \x01player_
            * team_t is actually \x00\x02team_t
            *
            * Probably a by-product of the change to exploding the data from the original.
            *
            * For now we just strip out these characters
            */
            // Check to see if $item has a _ at the end, this is player info
            if (substr($item, -1) == '_') {
                // Set the item group
                $item_group = 'players';
                // Set the item type, rip off any trailing stuff and bad chars
                $item_type = rtrim(str_replace("\x01", '', $item), '_');
            } elseif (substr($item, -2) == '_t') {
                // Check to see if $item has a _t at the end, this is team info
                // Set the item group
                $item_group = 'teams';
                // Set the item type, rip off any trailing stuff and bad chars
                $item_type = rtrim(str_replace(["\x00", "\x02"], '', $item), '_t');
            } else {
                // We can assume it is data belonging to a previously defined item

                // Make a temp buffer so we have easier access to the data
                $buf_temp = new Buffer($item, Buffer::NUMBER_TYPE_BIGENDIAN);
                // Get the values
                while ($buf_temp->getLength()) {
                    // No value so break the loop, end of string
                    if (($val = $buf_temp->readString()) === '') {
                        break;
                    }
                    // Add the value to the proper item in the correct group
                    $result->addSub($item_group, $item_type, utf8_encode(trim($val)));
                }
                // Unset our buffer
                unset($buf_temp);
            }
        }
        // Free up some memory
        unset($data, $item, $item_group, $item_type, $val);
    }
}


1			<?php
2			/**
3			* This file is part of GameQ.
4			*
5			* GameQ is free software; you can redistribute it and/or modify
6			* it under the terms of the GNU Lesser General Public License as published by
7			* the Free Software Foundation; either version 3 of the License, or
8			* (at your option) any later version.
9			*
10			* GameQ is distributed in the hope that it will be useful,
11			* but WITHOUT ANY WARRANTY; without even the implied warranty of
12			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13			* GNU Lesser General Public License for more details.
14			*
15			* You should have received a copy of the GNU Lesser General Public License
16			* along with this program. If not, see <http://www.gnu.org/licenses/>.
17			*/
18
19			namespace GameQ\Protocols;
20
21			use GameQ\Protocol;
22			use GameQ\Buffer;
23			use GameQ\Result;
24
25			/**
26			* GameSpy3 Protocol class
27			*
28			* Given the ability for non utf-8 characters to be used as hostnames, player names, etc... this
29			* version returns all strings utf-8 encoded (utf8_encode). To access the proper version of a
30			* string response you must use utf8_decode() on the specific response.
31			*
32			* @author Austin Bischoff <[email protected]>
33			*/
34			class Gamespy3 extends Protocol
35			{
36
37			/**
38			* Array of packets we want to look up.
39			* Each key should correspond to a defined method in this or a parent class
40			*
41			* @type array
42			*/
43			protected $packets = [
44			self::PACKET_CHALLENGE => "\xFE\xFD\x09\x10\x20\x30\x40",
45			self::PACKET_ALL => "\xFE\xFD\x00\x10\x20\x30\x40%s\xFF\xFF\xFF\x01",
46			];
47
48			/**
49			* The query protocol used to make the call
50			*
51			* @type string
52			*/
53			protected $protocol = 'gamespy3';
54
55			/**
56			* String name of this protocol class
57			*
58			* @type string
59			*/
60			protected $name = 'gamespy3';
61
62			/**
63			* Longer string name of this protocol class
64			*
65			* @type string
66			*/
67			protected $name_long = "GameSpy3 Server";
68
69			/**
70			* The client join link
71			*
72			* @type string
73			*/
74			protected $join_link = null;
75
76			/**
77			* This defines the split between the server info and player/team info.
78			* This value can vary by game. This value is the default split.
79			*
80			* @var string
81			*/
82			protected $packetSplit = "/\\x00\\x00\\x01/m";
83
84			/**
85			* Parse the challenge response and apply it to all the packet types
86			*
87			* @param \GameQ\Buffer $challenge_buffer
88			*
89			* @return bool
90			* @throws \GameQ\Exception\Protocol
91			*/
92			public function challengeParseAndApply(Buffer $challenge_buffer)
93			{
94
95			// Pull out the challenge
96			$challenge = substr(preg_replace("/[^0-9\-]/si", "", $challenge_buffer->getBuffer()), 1);
97			$challenge_result = sprintf(
98			"%c%c%c%c",
99			($challenge >> 24),
100			($challenge >> 16),
101			($challenge >> 8),
102			($challenge >> 0)
103			);
104
105			// Apply the challenge and return
106			return $this->challengeApply($challenge_result);
107			}
108
109			/**
110			* Process the response
111			*
112			* @return array
113			*/
114			public function processResponse()
115			{
116
117			// Holds the processed packets
118			$processed = [];
119
120			// Iterate over the packets
121			foreach ($this->packets_response as $response) {
122			// Make a buffer
123			$buffer = new Buffer($response, Buffer::NUMBER_TYPE_BIGENDIAN);
124
125			// Packet type = 0
126			$buffer->readInt8();
127
128			// Session Id
129			$buffer->readInt32();
130
131			// We need to burn the splitnum\0 because it is not used
132			$buffer->skip(9);
133
134			// Get the id
135			$id = $buffer->readInt8();
136
137			// Burn next byte not sure what it is used for
138			$buffer->skip(1);
139
140			// Add this packet to the processed
141			$processed[$id] = $buffer->getBuffer();
142
143			unset($buffer, $id);
144			}
145
146			// Sort packets, reset index
147			ksort($processed);
148
149			// Offload cleaning up the packets if they happen to be split
150			$packets = $this->cleanPackets(array_values($processed));
151
152			// Split the packets by type general and the rest (i.e. players & teams)
153			$split = preg_split($this->packetSplit, implode('', $packets));
154
155			// Create a new result
156			$result = new Result();
157
158			// First key should be server details and rules
159			$this->processDetails(new Buffer($split[0], Buffer::NUMBER_TYPE_BIGENDIAN), $result);
160
161			// The rest should be the player and team information, if it exists
162			if (array_key_exists(1, $split)) {
163			$this->processPlayersAndTeams(new Buffer($split[1], Buffer::NUMBER_TYPE_BIGENDIAN), $result);
164			}
165
166			return $result->fetch();
167			}
168
169			/*
170			* Internal methods
171			*/
172
173			/**
174			* Handles cleaning up packets since the responses can be a bit "dirty"
175			*
176			* @param array $packets
177			*
178			* @return array
179			*/
180			protected function cleanPackets(array $packets = [])
181			{
182
183			// Get the number of packets
184			$packetCount = count($packets);
185
186			// Compare last var of current packet with first var of next packet
187			// On a partial match, remove last var from current packet,
188			// variable header from next packet
189			for ($i = 0, $x = $packetCount; $i < $x - 1; $i++) {
190			// First packet
191			$fst = substr($packets[$i], 0, -1);
192			// Second packet
193			$snd = $packets[$i + 1];
194			// Get last variable from first packet
195			$fstvar = substr($fst, strrpos($fst, "\x00") + 1);
196			// Get first variable from last packet
197			$snd = substr($snd, strpos($snd, "\x00") + 2);
198			$sndvar = substr($snd, 0, strpos($snd, "\x00"));
199			// Check if fstvar is a substring of sndvar
200			// If so, remove it from the first string
201			if (!empty($fstvar) && strpos($sndvar, $fstvar) !== false) {
202			$packets[$i] = preg_replace("#(\\x00[^\\x00]+\\x00)$#", "\x00", $packets[$i]);
203			}
204			}
205
206			// Now let's loop the return and remove any dupe prefixes
207			for ($x = 1; $x < $packetCount; $x++) {
208			$buffer = new Buffer($packets[$x], Buffer::NUMBER_TYPE_BIGENDIAN);
209
210			$prefix = $buffer->readString();
211
212			// Check to see if the return before has the same prefix present
213			if ($prefix != null && strstr($packets[($x - 1)], $prefix)) {
214			// Update the return by removing the prefix plus 2 chars
215			$packets[$x] = substr(str_replace($prefix, '', $packets[$x]), 2);
216			}
217
218			unset($buffer);
219			}
220
221			unset($x, $i, $snd, $sndvar, $fst, $fstvar);
222
223			// Return cleaned packets
224			return $packets;
225			}
226
227			/**
228			* Handles processing the details data into a usable format
229			*
230			* @param \GameQ\Buffer $buffer
231			* @param \GameQ\Result $result
232			*/
233			protected function processDetails(Buffer &$buffer, Result &$result)
234			{
235
236			// We go until we hit an empty key
237			while ($buffer->getLength()) {
238			$key = $buffer->readString();
239			if (strlen($key) == 0) {
240			break;
241			}
242			$result->add($key, utf8_encode($buffer->readString()));
243			}
244			}
245
246			/**
247			* Handles processing the player and team data into a usable format
248			*
249			* @param \GameQ\Buffer $buffer
250			* @param \GameQ\Result $result
251			*/
252			protected function processPlayersAndTeams(Buffer &$buffer, Result &$result)
253			{
254
255			/*
256			* Explode the data into groups. First is player, next is team (item_t)
257			* Each group should be as follows:
258			*
259			* [0] => item_
260			* [1] => information for item_
261			* ...
262			*/
263			$data = explode("\x00\x00", $buffer->getBuffer());
264
265			// By default item_group is blank, this will be set for each loop thru the data
266			$item_group = '';
267			// By default the item_type is blank, this will be set on each loop
268			$item_type = '';
269			// Loop through all of the $data for information and pull it out into the result
270			for ($x = 0; $x < count($data) - 1; $x++) {
271			// Pull out the item
272			$item = $data[$x];
273			// If this is an empty item, move on
274			if ($item == '' \|\| $item == "\x00") {
275			continue;
276			}
277			/*
278			* Left as reference:
279			*
280			* Each block of player_ and team_t have preceding junk chars
281			*
282			* player_ is actually \x01player_
283			* team_t is actually \x00\x02team_t
284			*
285			* Probably a by-product of the change to exploding the data from the original.
286			*
287			* For now we just strip out these characters
288			*/
289			// Check to see if $item has a _ at the end, this is player info
290			if (substr($item, -1) == '_') {
291			// Set the item group
292			$item_group = 'players';
293			// Set the item type, rip off any trailing stuff and bad chars
294			$item_type = rtrim(str_replace("\x01", '', $item), '_');
295			} elseif (substr($item, -2) == '_t') {
296			// Check to see if $item has a _t at the end, this is team info
297			// Set the item group
298			$item_group = 'teams';
299			// Set the item type, rip off any trailing stuff and bad chars
300			$item_type = rtrim(str_replace(["\x00", "\x02"], '', $item), '_t');
301			} else {
302			// We can assume it is data belonging to a previously defined item
303
304			// Make a temp buffer so we have easier access to the data
305			$buf_temp = new Buffer($item, Buffer::NUMBER_TYPE_BIGENDIAN);
306			// Get the values
307			while ($buf_temp->getLength()) {
308			// No value so break the loop, end of string
309			if (($val = $buf_temp->readString()) === '') {
310			break;
311			}
312			// Add the value to the proper item in the correct group
313			$result->addSub($item_group, $item_type, utf8_encode(trim($val)));
314			}
315			// Unset our buffer
316			unset($buf_temp);
317			}
318			}
319			// Free up some memory
320			unset($data, $item, $item_group, $item_type, $val);
321			}
322			}
323

Austinb / GameQ

Push — v3 ( e9ba49...9aaf4b )

Gamespy3::cleanPackets() C

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like