alx-web-0_7_0_20171218_1/include/ppping.inc.php

<?php
/* -------------------------------------------------------------
This file is part of PurplePixie Ping (PPPing)

PPPing is (C) Copyright 2010 PurplePixie Systems

PPPing 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.

PPPing 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 PPPing.  If not, see www.gnu.org/licenses

For more information see www.purplepixie.org/phpping
-------------------------------------------------------------- */

/**
 * PPPing PHP Ping Utility
 * @package PPPing PHP Ping Utility
 * @author David Cutting
 * @version 0.01
**/

/**
 * Main PPPing Class
 * @package PPPing PHP Ping Utility
**/
class PPPing
{
/**
 * Time-to-Live for IP Packet (DO NOT USE)
 *
 * -1 Uses system default (usually 64). Please note that this is currently
 * not functional.
**/
var $ttl=-1;

/**
 * Hostname to ping (resolvable host or IP address)
**/
var $hostname="";

/**
 * Identifier - will fill with random content (16 bits)
**/
var $identity=0;

/**
 * Sequence number in decimal (16 bits)
**/
var $sequence=0;

/**
 * Timeout in seconds - maximum wait for a response before timeout
**/
var $timeout=10;

/**
 * Timer start seconds
**/
var $timer_start_sec=0;

/**
 * Timer start mseconds
**/
var $timer_start_msec=0;

/**
 * Data package for the ping
**/
var $data_package = "PPPing";

/**
 * Debug - prints output to the screen
**/
var $debug=false;

/**
 * Holds information on last result
**/
var $Last = array();

/**
 * Clears last data
**/
function clearLast()
	{
	$this->last = array(
		"set" => false,
		"result" => 0,
		"ttl" => 0,
		"hops" => 0,
		"source" => "",
		"destination" => "" );
	}
/**
 * Get a padded hex identifier
**/
function getIdentity()
	{
	if ( (is_numeric($this->identity)) && ($this->identity>=0) && ($this->identity<65535) )
		$id=$this->identity;
	else $id=0;
	
	$id=dechex($id);
	$id=str_pad($id,4,"0",STR_PAD_LEFT);
	$id=pack("H*",$id);
	
	return $id;
	}

/**
 * Get a padded hex sequence
**/
function getSequence()
	{
	if ( (is_numeric($this->sequence)) && ($this->sequence>=0) && ($this->sequence<65535) )
		$seq=$this->sequence;
	else $seq=0;
	$seq=dechex($seq);
	$seq=str_pad($seq,4,"0",STR_PAD_LEFT);
	$seq=pack("H*",$seq);
	
	return $seq;
	}
	
/**
 * Returns a hex string of the binary data for debug purposes
**/
function getHex($data)
	{
	$parts=unpack("H*",$data);
	return $parts[1];
	}
	
/**
 * Randomise identity and/or sequence within 16 bit parameters
**/
function Randomise($identity=true,$sequence=false)
	{
	mt_srand(microtime()*1000000);
	if ($identity) $this->identity=mt_rand(0,65534);
	if ($sequence) $this->sequence=mt_rand(0,65534);
	}
	
/**
 * Start timer (reset values)
**/
function startTimer()
	{
	$now=microtime();
	$timearray=explode(" ",$now);
	$this->timer_start_sec=$timearray[1];
	$this->timer_start_msec=$timearray[0];
	}
	
/**
 * Stop timer (return result)
**/
function stopTimer()
	{
	$now=microtime();
	$timearray=explode(" ",$now);
	
	$finish_secs=$timearray[1];
	$finish_msecs=$timearray[0];
	
	$elapsed_seconds = $finish_secs - $this->timer_start_sec;
	$elapsed_time = $elapsed_seconds + $finish_msecs - $this->timer_start_msec;
	
	$elapsed_ms = $elapsed_time * 1000;
	
	$elapsed_ms = round($elapsed_ms,3);
	
	return $elapsed_ms;
	}
	
	
/**
 * Constructor - randomises ID
**/
function PPPing()
	{
	$this->Randomise();
	}
	
/**
 * Returns a dotted quad from hex format IPv4 address
**/
function ipAddress($hexip)
	{
	$quad="";
	for($a=0; $a<=6; $a+=2)
		{
		$portion=substr($hexip,$a,2);
		$decimal=hexdec($portion);
		if ($quad!="") $quad.=".";
		$quad.=$decimal;
		}
	return $quad;
	}
	
/**
 * Generate an ICMP checksum
**/
function Checksum($data)
    {
    if (strlen($data)%2)
		$data .= "\x00";
    
    $bit = unpack('n*', $data);
    $sum = array_sum($bit);
    
    while ($sum >> 16)
    $sum = ($sum >> 16) + ($sum & 0xffff);
    
    return pack('n*', ~$sum);
    }

/**
 * Do a ping of the set hostname
 *
 * @return float
 * Returns a negative number of failure which can be turned into text with
 * the strError method. A positive number is a response in milliseconds (ms)
**/
function Ping()
	{
	$this->clearLast();
    $type = "\x08"; // icmp echo
    $code = "\x00"; 
    $checksum = "\x00\x00"; // initial
    $identifier = $this->getIdentity();
	$dec_identity = $this->identity;
	//$identifier = "\x00\x00";
	//$seqNumber = "\x00\x00";
    $seqNumber = $this->getSequence();
	$dec_sequence = $this->sequence;
    $data = $this->data_package;
    $package = $type.$code.$checksum.$identifier.$seqNumber.$data;
    $checksum = $this->Checksum($package); // proper checksum
    $package = $type.$code.$checksum.$identifier.$seqNumber.$data;
	
	$ip_protocol_code = getprotobyname("ip");
	$ip_ttl_code = 7;
    
	// Lookup hostname
	$ips=str_replace(".","",$this->hostname);
	if (!is_numeric($ips))
		{
		$host=gethostbyname($this->hostname);
		if ($host==$this->hostname) return -5;
		}
	else $host=$this->hostname;
    
    // Create Socket
    $socket = socket_create(AF_INET, SOCK_RAW, 1); // @
    	//or die(socket_strerror(socket_last_error()));
    if (!$socket) return -3;
    
    // Set Non-Blocking
    socket_set_nonblock($socket); // @
	
	$socket_ttl = socket_get_option($socket,$ip_protocol_code,$ip_ttl_code);
	
	//for ($a=0; $a<64; $a++)
	//	echo $a." - ".@socket_get_option($socket,$ip_protocol_code,$a)."\n";
	
	if ($this->ttl>0)
		{
		socket_set_option($socket,$ip_protocol_code,$ip_ttl_code,128);
		$socket_ttl = socket_get_option($socket,$ip_protocol_code,$ip_ttl_code);
		//socket_set_option($socket,Socket::IPPROTO_IP,Socket::IP_TTL,128);
		//$socket_ttl = socket_get_option($socket,Socket::IPPROTO_IP,Socket::IP_TTL);
		
		}
	else $socket_ttl = 64; // standard TTL
		
    	
    // Connect Socket
    $sconn=socket_connect($socket, $host, null); // @
    if (!$sconn) return 0;
    
	// Package Size
	//$package_size = 8+strlen($data);
	$package_size = strlen($package);
	
    // Send Data
    socket_send($socket, $package, $package_size, 0); // @
        
    // Start Timer
    $this->startTimer();
    $startTime = microtime(true); // need this for the looping section
    

    // Read Data
    $keepon=true;

    while( (false===($echo_reply=socket_read($socket, 255))) && $keepon) // @socket_read
    	{ 
    	
    	if ( (microtime(true) - $startTime) > $this->timeout )
    		$keepon=false;
			
		}
    	
		
	if ($keepon) // didn't time out - read data
    	{
	    $elapsed=$this->stopTimer();
		
		socket_close($socket); // @
		
		if ( $echo_reply === false ) return -4;
		else if (strlen($echo_reply)<2) return -2;
	
		$rx_parts = unpack("C*",$echo_reply);
		$tx_parts = unpack("C*",$package);
		$ipheader="";
		$ipheader_hex="";
		
		if ($rx_parts[1] == 0x45) // IP Header Information
			{
			$ipheader=substr($echo_reply,0,20);
			$ipheader_hex = $this->getHex($ipheader);
			$echo_reply=substr($echo_reply,20);
			$rx_parts = unpack("C*",$echo_reply);
			}
			
		if ($this->debug)
			{
			echo "\n";
			echo "    TyCoChksIdenSequData\n";
			echo "TX: ".$this->getHex($package)."\n";
			echo "RX: ".$this->getHex($echo_reply)."\n";
			if ($ipheader!="") echo "HR: ".$ipheader_hex."\n";
			}
			
		$echo_reply_hex = $this->getHex($echo_reply);
		$reply_type = $rx_parts[1];
		$reply_code = $rx_parts[2];
		$reply_identity = hexdec(substr($echo_reply_hex,8,4));
		$reply_sequence = hexdec(substr($echo_reply_hex,12,4));
			
		$match=true;
		if ($ipheader!="")
			{
			$source=substr($ipheader_hex,24,8);
			$dest=substr($ipheader_hex,32,8);
			$ttl=hexdec(substr($ipheader_hex,16,2));
			if ($this->debug) echo $this->ipAddress($source)." => ".$this->ipAddress($dest)." | ttl: ".$ttl."\n";
			if ($source==$dest) $match=true;
			else $match=false;
			
			$this->last["set"]=true;
			$this->last["source"]=$this->ipAddress($source);
			$this->last["destination"]=$this->ipAddress($dest);
			$this->last["ttl"]=$ttl;
			$this->last["hops"]=$socket_ttl - $ttl;
			
			
			}
	
		if ( (($rx_parts[1]==0) || (($rx_parts[1]==8)&&($match))) && ($rx_parts[2]==0) )
			{ // is echo_reply (0) or is echo_request (8) AND match (from same host)
			  // and has code of 0
			// valid response
			if ($reply_identity != $dec_identity) return -8; // ID mismatch
			else if ($reply_sequence != $dec_sequence) return -7; // sequence mismatch
			else
				{
				$this->last["result"]=$elapsed;
				return $elapsed;
				}
			}
		else
			{ // ICMP Error
			return -9;
			}
	
		}
    socket_close($socket); // @
    return -1; // timeout
	}
	
/**
 * Returns textual error for code
**/
function strError($code)
	{
	switch($code)
		{
		case -1: return "Timed Out"; break;
		case -2: return "Reply Too Short"; break;
		case -3: return "Failed to Open Socket"; break;
		case -4: return "Invalid (false) Response"; break;
		case -5: return "Hostname Lookup Failed"; break;
		case -7: return "Sequence Mismatch"; break;
		case -8: return "Identity Mismatch"; break;
		case -9: return "ICMP Generic Error"; break;
		
		default: return "Unknown Error"; break;
		}
	}


}

?>
1	niro	2195	<?php
2			/* -------------------------------------------------------------
3			This file is part of PurplePixie Ping (PPPing)
4
5			PPPing is (C) Copyright 2010 PurplePixie Systems
6
7			PPPing is free software: you can redistribute it and/or modify
8			it under the terms of the GNU General Public License as published by
9			the Free Software Foundation, either version 3 of the License, or
10			(at your option) any later version.
11
12			PPPing is distributed in the hope that it will be useful,
13			but WITHOUT ANY WARRANTY; without even the implied warranty of
14			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15			GNU General Public License for more details.
16
17			You should have received a copy of the GNU General Public License
18			along with PPPing. If not, see www.gnu.org/licenses
19
20			For more information see www.purplepixie.org/phpping
21			-------------------------------------------------------------- */
22
23			/**
24			* PPPing PHP Ping Utility
25			* @package PPPing PHP Ping Utility
26			* @author David Cutting
27			* @version 0.01
28			**/
29
30			/**
31			* Main PPPing Class
32			* @package PPPing PHP Ping Utility
33			**/
34			class PPPing
35			{
36			/**
37			* Time-to-Live for IP Packet (DO NOT USE)
38			*
39			* -1 Uses system default (usually 64). Please note that this is currently
40			* not functional.
41			**/
42			var $ttl=-1;
43
44			/**
45			* Hostname to ping (resolvable host or IP address)
46			**/
47			var $hostname="";
48
49			/**
50			* Identifier - will fill with random content (16 bits)
51			**/
52			var $identity=0;
53
54			/**
55			* Sequence number in decimal (16 bits)
56			**/
57			var $sequence=0;
58
59			/**
60			* Timeout in seconds - maximum wait for a response before timeout
61			**/
62			var $timeout=10;
63
64			/**
65			* Timer start seconds
66			**/
67			var $timer_start_sec=0;
68
69			/**
70			* Timer start mseconds
71			**/
72			var $timer_start_msec=0;
73
74			/**
75			* Data package for the ping
76			**/
77			var $data_package = "PPPing";
78
79			/**
80			* Debug - prints output to the screen
81			**/
82			var $debug=false;
83
84			/**
85			* Holds information on last result
86			**/
87			var $Last = array();
88
89			/**
90			* Clears last data
91			**/
92			function clearLast()
93			{
94			$this->last = array(
95			"set" => false,
96			"result" => 0,
97			"ttl" => 0,
98			"hops" => 0,
99			"source" => "",
100			"destination" => "" );
101			}
102			/**
103			* Get a padded hex identifier
104			**/
105			function getIdentity()
106			{
107			if ( (is_numeric($this->identity)) && ($this->identity>=0) && ($this->identity<65535) )
108			$id=$this->identity;
109			else $id=0;
110
111			$id=dechex($id);
112			$id=str_pad($id,4,"0",STR_PAD_LEFT);
113			$id=pack("H*",$id);
114
115			return $id;
116			}
117
118			/**
119			* Get a padded hex sequence
120			**/
121			function getSequence()
122			{
123			if ( (is_numeric($this->sequence)) && ($this->sequence>=0) && ($this->sequence<65535) )
124			$seq=$this->sequence;
125			else $seq=0;
126			$seq=dechex($seq);
127			$seq=str_pad($seq,4,"0",STR_PAD_LEFT);
128			$seq=pack("H*",$seq);
129
130			return $seq;
131			}
132
133			/**
134			* Returns a hex string of the binary data for debug purposes
135			**/
136			function getHex($data)
137			{
138			$parts=unpack("H*",$data);
139			return $parts[1];
140			}
141
142			/**
143			* Randomise identity and/or sequence within 16 bit parameters
144			**/
145			function Randomise($identity=true,$sequence=false)
146			{
147			mt_srand(microtime()*1000000);
148			if ($identity) $this->identity=mt_rand(0,65534);
149			if ($sequence) $this->sequence=mt_rand(0,65534);
150			}
151
152			/**
153			* Start timer (reset values)
154			**/
155			function startTimer()
156			{
157			$now=microtime();
158			$timearray=explode(" ",$now);
159			$this->timer_start_sec=$timearray[1];
160			$this->timer_start_msec=$timearray[0];
161			}
162
163			/**
164			* Stop timer (return result)
165			**/
166			function stopTimer()
167			{
168			$now=microtime();
169			$timearray=explode(" ",$now);
170
171			$finish_secs=$timearray[1];
172			$finish_msecs=$timearray[0];
173
174			$elapsed_seconds = $finish_secs - $this->timer_start_sec;
175			$elapsed_time = $elapsed_seconds + $finish_msecs - $this->timer_start_msec;
176
177			$elapsed_ms = $elapsed_time * 1000;
178
179			$elapsed_ms = round($elapsed_ms,3);
180
181			return $elapsed_ms;
182			}
183
184
185			/**
186			* Constructor - randomises ID
187			**/
188			function PPPing()
189			{
190			$this->Randomise();
191			}
192
193			/**
194			* Returns a dotted quad from hex format IPv4 address
195			**/
196			function ipAddress($hexip)
197			{
198			$quad="";
199			for($a=0; $a<=6; $a+=2)
200			{
201			$portion=substr($hexip,$a,2);
202			$decimal=hexdec($portion);
203			if ($quad!="") $quad.=".";
204			$quad.=$decimal;
205			}
206			return $quad;
207			}
208
209			/**
210			* Generate an ICMP checksum
211			**/
212			function Checksum($data)
213			{
214			if (strlen($data)%2)
215			$data .= "\x00";
216
217			$bit = unpack('n*', $data);
218			$sum = array_sum($bit);
219
220			while ($sum >> 16)
221			$sum = ($sum >> 16) + ($sum & 0xffff);
222
223			return pack('n*', ~$sum);
224			}
225
226			/**
227			* Do a ping of the set hostname
228			*
229			* @return float
230			* Returns a negative number of failure which can be turned into text with
231			* the strError method. A positive number is a response in milliseconds (ms)
232			**/
233			function Ping()
234			{
235			$this->clearLast();
236			$type = "\x08"; // icmp echo
237			$code = "\x00";
238			$checksum = "\x00\x00"; // initial
239			$identifier = $this->getIdentity();
240			$dec_identity = $this->identity;
241			//$identifier = "\x00\x00";
242			//$seqNumber = "\x00\x00";
243			$seqNumber = $this->getSequence();
244			$dec_sequence = $this->sequence;
245			$data = $this->data_package;
246			$package = $type.$code.$checksum.$identifier.$seqNumber.$data;
247			$checksum = $this->Checksum($package); // proper checksum
248			$package = $type.$code.$checksum.$identifier.$seqNumber.$data;
249
250			$ip_protocol_code = getprotobyname("ip");
251			$ip_ttl_code = 7;
252
253			// Lookup hostname
254			$ips=str_replace(".","",$this->hostname);
255			if (!is_numeric($ips))
256			{
257			$host=gethostbyname($this->hostname);
258			if ($host==$this->hostname) return -5;
259			}
260			else $host=$this->hostname;
261
262			// Create Socket
263			$socket = socket_create(AF_INET, SOCK_RAW, 1); // @
264			//or die(socket_strerror(socket_last_error()));
265			if (!$socket) return -3;
266
267			// Set Non-Blocking
268			socket_set_nonblock($socket); // @
269
270			$socket_ttl = socket_get_option($socket,$ip_protocol_code,$ip_ttl_code);
271
272			//for ($a=0; $a<64; $a++)
273			// echo $a." - ".@socket_get_option($socket,$ip_protocol_code,$a)."\n";
274
275			if ($this->ttl>0)
276			{
277			socket_set_option($socket,$ip_protocol_code,$ip_ttl_code,128);
278			$socket_ttl = socket_get_option($socket,$ip_protocol_code,$ip_ttl_code);
279			//socket_set_option($socket,Socket::IPPROTO_IP,Socket::IP_TTL,128);
280			//$socket_ttl = socket_get_option($socket,Socket::IPPROTO_IP,Socket::IP_TTL);
281
282			}
283			else $socket_ttl = 64; // standard TTL
284
285
286			// Connect Socket
287			$sconn=socket_connect($socket, $host, null); // @
288			if (!$sconn) return 0;
289
290			// Package Size
291			//$package_size = 8+strlen($data);
292			$package_size = strlen($package);
293
294			// Send Data
295			socket_send($socket, $package, $package_size, 0); // @
296
297			// Start Timer
298			$this->startTimer();
299			$startTime = microtime(true); // need this for the looping section
300
301
302			// Read Data
303			$keepon=true;
304
305			while( (false===($echo_reply=socket_read($socket, 255))) && $keepon) // @socket_read
306			{
307
308			if ( (microtime(true) - $startTime) > $this->timeout )
309			$keepon=false;
310
311			}
312
313
314			if ($keepon) // didn't time out - read data
315			{
316			$elapsed=$this->stopTimer();
317
318			socket_close($socket); // @
319
320			if ( $echo_reply === false ) return -4;
321			else if (strlen($echo_reply)<2) return -2;
322
323			$rx_parts = unpack("C*",$echo_reply);
324			$tx_parts = unpack("C*",$package);
325			$ipheader="";
326			$ipheader_hex="";
327
328			if ($rx_parts[1] == 0x45) // IP Header Information
329			{
330			$ipheader=substr($echo_reply,0,20);
331			$ipheader_hex = $this->getHex($ipheader);
332			$echo_reply=substr($echo_reply,20);
333			$rx_parts = unpack("C*",$echo_reply);
334			}
335
336			if ($this->debug)
337			{
338			echo "\n";
339			echo " TyCoChksIdenSequData\n";
340			echo "TX: ".$this->getHex($package)."\n";
341			echo "RX: ".$this->getHex($echo_reply)."\n";
342			if ($ipheader!="") echo "HR: ".$ipheader_hex."\n";
343			}
344
345			$echo_reply_hex = $this->getHex($echo_reply);
346			$reply_type = $rx_parts[1];
347			$reply_code = $rx_parts[2];
348			$reply_identity = hexdec(substr($echo_reply_hex,8,4));
349			$reply_sequence = hexdec(substr($echo_reply_hex,12,4));
350
351			$match=true;
352			if ($ipheader!="")
353			{
354			$source=substr($ipheader_hex,24,8);
355			$dest=substr($ipheader_hex,32,8);
356			$ttl=hexdec(substr($ipheader_hex,16,2));
357			if ($this->debug) echo $this->ipAddress($source)." => ".$this->ipAddress($dest)." \| ttl: ".$ttl."\n";
358			if ($source==$dest) $match=true;
359			else $match=false;
360
361			$this->last["set"]=true;
362			$this->last["source"]=$this->ipAddress($source);
363			$this->last["destination"]=$this->ipAddress($dest);
364			$this->last["ttl"]=$ttl;
365			$this->last["hops"]=$socket_ttl - $ttl;
366
367
368			}
369
370			if ( (($rx_parts[1]==0) \|\| (($rx_parts[1]==8)&&($match))) && ($rx_parts[2]==0) )
371			{ // is echo_reply (0) or is echo_request (8) AND match (from same host)
372			// and has code of 0
373			// valid response
374			if ($reply_identity != $dec_identity) return -8; // ID mismatch
375			else if ($reply_sequence != $dec_sequence) return -7; // sequence mismatch
376			else
377			{
378			$this->last["result"]=$elapsed;
379			return $elapsed;
380			}
381			}
382			else
383			{ // ICMP Error
384			return -9;
385			}
386
387			}
388			socket_close($socket); // @
389			return -1; // timeout
390			}
391
392			/**
393			* Returns textual error for code
394			**/
395			function strError($code)
396			{
397			switch($code)
398			{
399			case -1: return "Timed Out"; break;
400			case -2: return "Reply Too Short"; break;
401			case -3: return "Failed to Open Socket"; break;
402			case -4: return "Invalid (false) Response"; break;
403			case -5: return "Hostname Lookup Failed"; break;
404			case -7: return "Sequence Mismatch"; break;
405			case -8: return "Identity Mismatch"; break;
406			case -9: return "ICMP Generic Error"; break;
407
408			default: return "Unknown Error"; break;
409			}
410			}
411
412
413			}
414
415			?>