├── .github
    ├── FUNDING.yml
    └── workflows
    │   └── stale.yml
├── .gitignore
├── .travis.yml
├── JJG
    ├── Ping.php
    └── PingTest.php
├── LICENSE.md
├── README.md
├── Resources
    ├── Ping-Logo.png
    └── Ping-Logo.svg
└── composer.json


/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | # These are supported funding model platforms
2 | 
3 | github: geerlingguy
4 | patreon: geerlingguy
5 | 


--------------------------------------------------------------------------------
/.github/workflows/stale.yml:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Close inactive issues
 3 | 'on':
 4 |   schedule:
 5 |     - cron: "55 10 * * 4"  # semi-random time
 6 | 
 7 | jobs:
 8 |   close-issues:
 9 |     runs-on: ubuntu-latest
10 |     permissions:
11 |       issues: write
12 |       pull-requests: write
13 |     steps:
14 |       - uses: actions/stale@v8
15 |         with:
16 |           days-before-stale: 120
17 |           days-before-close: 60
18 |           exempt-issue-labels: bug,pinned,security,planned
19 |           exempt-pr-labels: bug,pinned,security,planned
20 |           stale-issue-label: "stale"
21 |           stale-pr-label: "stale"
22 |           stale-issue-message: |
23 |             This issue has been marked 'stale' due to lack of recent activity. If there is no further activity, the issue will be closed in another 30 days. Thank you for your contribution!
24 |             
25 |             Please read [this blog post](https://www.jeffgeerling.com/blog/2020/enabling-stale-issue-bot-on-my-github-repositories) to see the reasons why I mark issues as stale.
26 |           close-issue-message: |
27 |             This issue has been closed due to inactivity. If you feel this is in error, please reopen the issue or file a new issue with the relevant details.
28 |           stale-pr-message: |
29 |             This pr has been marked 'stale' due to lack of recent activity. If there is no further activity, the issue will be closed in another 30 days. Thank you for your contribution!
30 |             
31 |             Please read [this blog post](https://www.jeffgeerling.com/blog/2020/enabling-stale-issue-bot-on-my-github-repositories) to see the reasons why I mark issues as stale.
32 |           close-pr-message: |
33 |             This pr has been closed due to inactivity. If you feel this is in error, please reopen the issue or file a new issue with the relevant details.
34 |           repo-token: ${{ secrets.GITHUB_TOKEN }}
35 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | vendor
2 | /.buildpath
3 | /.project
4 | /.settings
5 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | ---
 2 | # See: http://about.travis-ci.org/docs/user/languages/php/
 3 | language: php
 4 | 
 5 | php:
 6 |   - 7.2
 7 |   - 7.3
 8 |   - nightly
 9 | 
10 | matrix:
11 |   fast_finish: true
12 |   allow_failures:
13 |     - php: nightly
14 | 
15 | script:
16 |   - sudo /home/travis/.phpenv/shims/phpunit --coverage-text JJG/PingTest.php
17 | 


--------------------------------------------------------------------------------
/JJG/Ping.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /**
  4 |  * Ping for PHP.
  5 |  *
  6 |  * This class pings a host.
  7 |  *
  8 |  * The ping() method pings a server using 'exec', 'socket', or 'fsockopen', and
  9 |  * and returns FALSE if the server is unreachable within the given ttl/timeout,
 10 |  * or the latency in milliseconds if the server is reachable.
 11 |  *
 12 |  * Quick Start:
 13 |  * @code
 14 |  *   include 'path/to/Ping/JJG/Ping.php';
 15 |  *   use \JJG\Ping as Ping;
 16 |  *   $ping = new Ping('www.example.com');
 17 |  *   $latency = $ping->ping();
 18 |  * @endcode
 19 |  *
 20 |  * @version 1.2.1
 21 |  * @author Jeff Geerling.
 22 |  */
 23 | 
 24 | namespace JJG;
 25 | 
 26 | class Ping {
 27 | 
 28 |   private $host;
 29 |   private $ttl;
 30 |   private $timeout;
 31 |   private $port = 80;
 32 |   private $data = 'Ping';
 33 |   private $commandOutput;
 34 | 
 35 |   /**
 36 |    * Called when the Ping object is created.
 37 |    *
 38 |    * @param string $host
 39 |    *   The host to be pinged.
 40 |    * @param int $ttl
 41 |    *   Time-to-live (TTL) (You may get a 'Time to live exceeded' error if this
 42 |    *   value is set too low. The TTL value indicates the scope or range in which
 43 |    *   a packet may be forwarded. By convention:
 44 |    *     - 0 = same host
 45 |    *     - 1 = same subnet
 46 |    *     - 32 = same site
 47 |    *     - 64 = same region
 48 |    *     - 128 = same continent
 49 |    *     - 255 = unrestricted
 50 |    * @param int $timeout
 51 |    *   Timeout (in seconds) used for ping and fsockopen().
 52 |    * @throws \Exception if the host is not set.
 53 |    */
 54 |   public function __construct($host, $ttl = 255, $timeout = 10) {
 55 |     if (!isset($host)) {
 56 |       throw new \Exception("Error: Host name not supplied.");
 57 |     }
 58 | 
 59 |     $this->host = $host;
 60 |     $this->ttl = $ttl;
 61 |     $this->timeout = $timeout;
 62 |   }
 63 | 
 64 |   /**
 65 |    * Set the ttl (in hops).
 66 |    *
 67 |    * @param int $ttl
 68 |    *   TTL in hops.
 69 |    */
 70 |   public function setTtl($ttl) {
 71 |     $this->ttl = $ttl;
 72 |   }
 73 | 
 74 |   /**
 75 |    * Get the ttl.
 76 |    *
 77 |    * @return int
 78 |    *   The current ttl for Ping.
 79 |    */
 80 |   public function getTtl() {
 81 |     return $this->ttl;
 82 |   }
 83 | 
 84 |   /**
 85 |    * Set the timeout.
 86 |    *
 87 |    * @param int $timeout
 88 |    *   Time to wait in seconds.
 89 |    */
 90 |   public function setTimeout($timeout) {
 91 |     $this->timeout = $timeout;
 92 |   }
 93 | 
 94 |   /**
 95 |    * Get the timeout.
 96 |    *
 97 |    * @return int
 98 |    *   Current timeout for Ping.
 99 |    */
100 |   public function getTimeout() {
101 |     return $this->timeout;
102 |   }
103 | 
104 |   /**
105 |    * Set the host.
106 |    *
107 |    * @param string $host
108 |    *   Host name or IP address.
109 |    */
110 |   public function setHost($host) {
111 |     $this->host = $host;
112 |   }
113 | 
114 |   /**
115 |    * Get the host.
116 |    *
117 |    * @return string
118 |    *   The current hostname for Ping.
119 |    */
120 |   public function getHost() {
121 |     return $this->host;
122 |   }
123 | 
124 |   /**
125 |    * Set the port (only used for fsockopen method).
126 |    *
127 |    * Since regular pings use ICMP and don't need to worry about the concept of
128 |    * 'ports', this is only used for the fsockopen method, which pings servers by
129 |    * checking port 80 (by default).
130 |    *
131 |    * @param int $port
132 |    *   Port to use for fsockopen ping (defaults to 80 if not set).
133 |    */
134 |   public function setPort($port) {
135 |     $this->port = $port;
136 |   }
137 | 
138 |   /**
139 |    * Get the port (only used for fsockopen method).
140 |    *
141 |    * @return int
142 |    *   The port used by fsockopen pings.
143 |    */
144 |   public function getPort() {
145 |     return $this->port;
146 |   }
147 | 
148 |   /**
149 |    * Return the command output when method=exec.
150 |    * @return string
151 |    */
152 |   public function getCommandOutput(){
153 |     return $this->commandOutput;
154 |   }
155 | 
156 |   /**
157 |    * Matches an IP on command output and returns.
158 |    * @return string
159 |    */
160 |   public function getIpAddress() {
161 |     $out = array();
162 |     if (preg_match('/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/', $this->commandOutput, $out)){
163 |       return $out[0];
164 |     }
165 |     return null;
166 |   }
167 | 
168 |   /**
169 |    * Ping a host.
170 |    *
171 |    * @param string $method
172 |    *   Method to use when pinging:
173 |    *     - exec (default): Pings through the system ping command. Fast and
174 |    *       robust, but a security risk if you pass through user-submitted data.
175 |    *     - fsockopen: Pings a server on port 80.
176 |    *     - socket: Creates a RAW network socket. Only usable in some
177 |    *       environments, as creating a SOCK_RAW socket requires root privileges.
178 |    *
179 |    * @throws InvalidArgumentException if $method is not supported.
180 |    *
181 |    * @return mixed
182 |    *   Latency as float, in ms, if host is reachable or FALSE if host is down.
183 |    */
184 |   public function ping($method = 'exec') {
185 |     $latency = false;
186 | 
187 |     switch ($method) {
188 |       case 'exec':
189 |         $latency = $this->pingExec();
190 |         break;
191 | 
192 |       case 'fsockopen':
193 |         $latency = $this->pingFsockopen();
194 |         break;
195 | 
196 |       case 'socket':
197 |         $latency = $this->pingSocket();
198 |         break;
199 | 
200 |       default:
201 |         throw new \InvalidArgumentException('Unsupported ping method.');
202 |     }
203 | 
204 |     // Return the latency.
205 |     return $latency;
206 |   }
207 | 
208 |   /**
209 |    * The exec method uses the possibly insecure exec() function, which passes
210 |    * the input to the system. This is potentially VERY dangerous if you pass in
211 |    * any user-submitted data. Be SURE you sanitize your inputs!
212 |    *
213 |    * @return float
214 |    *   Latency, in ms.
215 |    */
216 |   private function pingExec() {
217 |     $latency = false;
218 | 
219 |     $ttl = escapeshellcmd($this->ttl);
220 |     $timeout = escapeshellcmd($this->timeout);
221 |     $host = escapeshellcmd($this->host);
222 | 
223 |     // Exec string for Windows-based systems.
224 |     if (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') {
225 |       // -n = number of pings; -i = ttl; -w = timeout (in milliseconds).
226 |       $exec_string = 'ping -n 1 -i ' . $ttl . ' -w ' . ($timeout * 1000) . ' ' . $host;
227 |     }
228 |     // Exec string for Darwin based systems (OS X).
229 |     else if(strtoupper(PHP_OS) === 'DARWIN') {
230 |       // -n = numeric output; -c = number of pings; -m = ttl; -t = timeout.
231 |       $exec_string = 'ping -n -c 1 -m ' . $ttl . ' -t ' . $timeout . ' ' . $host;
232 |     }
233 |     // Exec string for other UNIX-based systems (Linux).
234 |     else {
235 |       // -n = numeric output; -c = number of pings; -t = ttl; -W = timeout
236 |       $exec_string = 'ping -n -c 1 -t ' . $ttl . ' -W ' . $timeout . ' ' . $host . ' 2>&1';
237 |     }
238 | 
239 |     exec($exec_string, $output, $return);
240 | 
241 |     // Strip empty lines and reorder the indexes from 0 (to make results more
242 |     // uniform across OS versions).
243 |     $this->commandOutput = implode('', $output);
244 |     $output = array_values(array_filter($output));
245 | 
246 |     // If the result line in the output is not empty, parse it.
247 |     if (!empty($output[1])) {
248 |       // Search for a 'time' value in the result line.
249 |       $response = preg_match("/time(?:=|<)(?<time>[\.0-9]+)(?:|\s)ms/", $output[1], $matches);
250 | 
251 |       // If there's a result and it's greater than 0, return the latency.
252 |       if ($response > 0 && isset($matches['time'])) {
253 |         $latency = round($matches['time'], 4);
254 |       }
255 |     }
256 | 
257 |     return $latency;
258 |   }
259 | 
260 |   /**
261 |    * The fsockopen method simply tries to reach the host on a port. This method
262 |    * is often the fastest, but not necessarily the most reliable. Even if a host
263 |    * doesn't respond, fsockopen may still make a connection.
264 |    *
265 |    * @return float
266 |    *   Latency, in ms.
267 |    */
268 |   private function pingFsockopen() {
269 |     $start = microtime(true);
270 |     // fsockopen prints a bunch of errors if a host is unreachable. Hide those
271 |     // irrelevant errors and deal with the results instead.
272 |     $fp = @fsockopen($this->host, $this->port, $errno, $errstr, $this->timeout);
273 |     if (!$fp) {
274 |       $latency = false;
275 |     }
276 |     else {
277 |       $latency = microtime(true) - $start;
278 |       $latency = round($latency * 1000, 4);
279 |     }
280 |     return $latency;
281 |   }
282 | 
283 |   /**
284 |    * The socket method uses raw network packet data to try sending an ICMP ping
285 |    * packet to a server, then measures the response time. Using this method
286 |    * requires the script to be run with root privileges, though, so this method
287 |    * only works reliably on Windows systems and on Linux servers where the
288 |    * script is not being run as a web user.
289 |    *
290 |    * @return float
291 |    *   Latency, in ms.
292 |    */
293 |   private function pingSocket() {
294 |     // Create a package.
295 |     $type = "\x08";
296 |     $code = "\x00";
297 |     $checksum = "\x00\x00";
298 |     $identifier = "\x00\x00";
299 |     $seq_number = "\x00\x00";
300 |     $package = $type . $code . $checksum . $identifier . $seq_number . $this->data;
301 | 
302 |     // Calculate the checksum.
303 |     $checksum = $this->calculateChecksum($package);
304 | 
305 |     // Finalize the package.
306 |     $package = $type . $code . $checksum . $identifier . $seq_number . $this->data;
307 | 
308 |     // Create a socket, connect to server, then read socket and calculate.
309 |     if ($socket = socket_create(AF_INET, SOCK_RAW, 1)) {
310 |       socket_set_option($socket, SOL_SOCKET, SO_RCVTIMEO, array(
311 |         'sec' => 10,
312 |         'usec' => 0,
313 |       ));
314 |       // Prevent errors from being printed when host is unreachable.
315 |       @socket_connect($socket, $this->host, null);
316 |       $start = microtime(true);
317 |       // Send the package.
318 |       @socket_send($socket, $package, strlen($package), 0);
319 |       if (socket_read($socket, 255) !== false) {
320 |         $latency = microtime(true) - $start;
321 |         $latency = round($latency * 1000, 4);
322 |       }
323 |       else {
324 |         $latency = false;
325 |       }
326 |     }
327 |     else {
328 |       $latency = false;
329 |     }
330 |     // Close the socket.
331 |     socket_close($socket);
332 |     return $latency;
333 |   }
334 | 
335 |   /**
336 |    * Calculate a checksum.
337 |    *
338 |    * @param string $data
339 |    *   Data for which checksum will be calculated.
340 |    *
341 |    * @return string
342 |    *   Binary string checksum of $data.
343 |    */
344 |   private function calculateChecksum($data) {
345 |     if (strlen($data) % 2) {
346 |       $data .= "\x00";
347 |     }
348 | 
349 |     $bit = unpack('n*', $data);
350 |     $sum = array_sum($bit);
351 | 
352 |     while ($sum >> 16) {
353 |       $sum = ($sum >> 16) + ($sum & 0xffff);
354 |     }
355 | 
356 |     return pack('n*', ~$sum);
357 |   }
358 | }
359 | 


--------------------------------------------------------------------------------
/JJG/PingTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /**
  4 |  * @file
  5 |  * Tests for Ping.
  6 |  */
  7 | 
  8 | use PHPUnit\Framework\TestCase;
  9 | 
 10 | // TODO - Use autoloading someday.
 11 | include_once('Ping.php');
 12 | use JJG\Ping as Ping;
 13 | 
 14 | class PingTest extends TestCase {
 15 |   private $reachable_host = 'www.google.com';
 16 |   private $unreachable_host = '254.254.254.254';
 17 |   private $low_latency_host = '127.0.0.1';
 18 | 
 19 |   public function testHost() {
 20 |     $first = $this->reachable_host;
 21 |     $ping = new Ping($first);
 22 |     $this->assertEquals($first, $ping->getHost());
 23 | 
 24 |     $second = 'www.apple.com';
 25 |     $ping->setHost($second);
 26 |     $this->assertEquals($second, $ping->getHost());
 27 |   }
 28 | 
 29 |   public function testTtl() {
 30 |     $first = 220;
 31 |     $ping = new Ping($this->reachable_host, $first);
 32 |     $this->assertEquals($first, $ping->getTtl());
 33 | 
 34 |     $second = 128;
 35 |     $ping->setTtl($second);
 36 |     $this->assertEquals($second, $ping->getTtl());
 37 |   }
 38 | 
 39 |   public function testTimeout() {
 40 |     $timeout = 5;
 41 |     $startTime = microtime(true);
 42 |     $ping = new Ping($this->unreachable_host, 255, $timeout);
 43 |     $ping->ping('exec');
 44 |     $time = floor(microtime(true) - $startTime);
 45 |     $this->assertEquals($timeout, $time);
 46 |   }
 47 | 
 48 |   public function testLowLatencyHost() {
 49 |     $low_latency = $this->low_latency_host;
 50 |     $ping = new Ping($low_latency);
 51 |     $ping->ping('exec');
 52 |     $latency = $ping->ping();
 53 |     $this->assertGreaterThan(0, $latency);
 54 |   }
 55 | 
 56 |   public function testPort() {
 57 |     $port = 2222;
 58 |     $ping = new Ping($this->reachable_host);
 59 |     $ping->setPort($port);
 60 |     $this->assertEquals($port, $ping->getPort());
 61 |   }
 62 | 
 63 |   public function testGetCommandOutput() {
 64 |     $ping = new Ping('127.0.0.1');
 65 |     $latency = $ping->ping('exec');
 66 |     $this->assertNotNull($ping->getCommandOutput());
 67 |   }
 68 | 
 69 |   public function testIpAddress() {
 70 |     $ping = new Ping('127.0.0.1');
 71 |     $latency = $ping->ping('exec');
 72 |     $this->assertEquals('127.0.0.1', $ping->getIpAddress());
 73 |   }
 74 | 
 75 |   public function testPingExec() {
 76 |     $ping = new Ping($this->reachable_host);
 77 |     $latency = $ping->ping('exec');
 78 |     $this->assertNotEquals(FALSE, $latency);
 79 | 
 80 |     $ping->setHost($this->unreachable_host);
 81 |     $latency = $ping->ping('exec');
 82 |     $this->assertEquals(FALSE, $latency);
 83 |   }
 84 | 
 85 |   public function testPingFsockopen() {
 86 |     $ping = new Ping($this->reachable_host);
 87 |     $latency = $ping->ping('fsockopen');
 88 |     $this->assertNotEquals(FALSE, $latency);
 89 | 
 90 |     $ping = new Ping($this->unreachable_host);
 91 |     $latency = $ping->ping('fsockopen');
 92 |     $this->assertEquals(FALSE, $latency);
 93 |   }
 94 | 
 95 |   /**
 96 |    * These tests require sudo/root so socket can be opened.
 97 |    */
 98 |   public function testPingSocket() {
 99 |     $ping = new Ping($this->reachable_host);
100 |     $latency = $ping->ping('socket');
101 |     $this->assertNotEquals(FALSE, $latency);
102 | 
103 |     $ping = new Ping($this->unreachable_host);
104 |     $latency = $ping->ping('socket');
105 |     $this->assertEquals(FALSE, $latency);
106 |   }
107 | }
108 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | 
 2 | Copyright (c) 2011 by Jeff Geerling.
 3 | 
 4 | Permission is hereby granted, free of charge, to any person obtaining a copy
 5 | of this software and associated documentation files (the "Software"), to deal
 6 | in the Software without restriction, including without limitation the rights
 7 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 8 | copies of the Software, and to permit persons to whom the Software is
 9 | furnished to do so, subject to the following conditions:
10 | 
11 | The above copyright notice and this permission notice shall be included in
12 | all copies or substantial portions of the Software.
13 | 
14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
20 | THE SOFTWARE.
21 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | <img src="https://raw.githubusercontent.com/geerlingguy/Ping/1.x/Resources/Ping-Logo.png" alt="Ping for PHP Logo" />
 2 | 
 3 | # Ping
 4 | 
 5 | [![Build Status](https://travis-ci.org/geerlingguy/Ping.svg?branch=1.x)](https://travis-ci.org/geerlingguy/Ping)
 6 | 
 7 | A PHP class to ping hosts.
 8 | 
 9 | There are a ton of different methods of pinging a server using PHP, and I've found most to be poorly documented or downright dangerous in their implementation.
10 | 
11 | Therefore, I've created this simple class, which incorporates the three most popular ping methods (`exec()` with the system's `ping` utility, `fsockopen()`, and `socket_create()`). Each method has its benefits and drawbacks, and may work better or worse on a particular system.
12 | 
13 | ## Installation
14 | 
15 | ```
16 | $ composer require geerlingguy/ping
17 | ```
18 | 
19 | ## Usage
20 | 
21 | This is a very simple class. Just create an instance, and run `ping()`.
22 | 
23 | ```php
24 | $host = 'www.example.com';
25 | $ping = new \JJG\Ping($host);
26 | $latency = $ping->ping();
27 | if ($latency !== false) {
28 |   print 'Latency is ' . $latency . ' ms';
29 | }
30 | else {
31 |   print 'Host could not be reached.';
32 | }
33 | ```
34 | 
35 | You can also specify the ttl (maximum hops) and timeout when creating the instance:
36 | 
37 | ```php
38 | $ttl = 128;
39 | $timeout = 5;
40 | $ping = new \JJG\Ping($host, $ttl, $timeout);
41 | ```
42 | 
43 | ...or using the `setTtl()` or `setTimeout()` methods:
44 | 
45 | ```php
46 | $ping = new \JJG\Ping($host);
47 | $ping->setTtl(128);
48 | $ping->setTimeout(5);
49 | ```
50 | 
51 | You can change the host using the `setHost()` method:
52 | 
53 | ```php
54 | $ping = new \JJG\Ping($host);
55 | ...
56 | $ping->setHost('www.anotherexample.com');
57 | ```
58 | 
59 | ## License
60 | 
61 | Ping is licensed under the MIT (Expat) license. See included LICENSE.md.
62 | 
63 | ## Author
64 | 
65 | Ping is maintained by [Jeff Geerling](https://www.jeffgeerling.com), and is used to check servers for [Server Check.in](https://servercheck.in), an inexpensive website and server uptime monitoring service.
66 | 


--------------------------------------------------------------------------------
/Resources/Ping-Logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/geerlingguy/Ping/8dafcf70c63827d1e6e73d85b4635d920590bd80/Resources/Ping-Logo.png


--------------------------------------------------------------------------------
/Resources/Ping-Logo.svg:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!-- Generator: Adobe Illustrator 15.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
 3 | <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
 4 | <svg version="1.1"
 5 | 	 id="svg3239" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:cc="http://creativecommons.org/ns#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" inkscape:version="0.48.2 r9819" xmlns:svg="http://www.w3.org/2000/svg" xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd" sodipodi:docname="New document 12"
 6 | 	 xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="227px" height="100px"
 7 | 	 viewBox="0 0 227 100" enable-background="new 0 0 227 100" xml:space="preserve">
 8 | <sodipodi:namedview  inkscape:window-maximized="0" inkscape:window-y="49" inkscape:window-x="4" inkscape:window-height="419" inkscape:window-width="496" fit-margin-bottom="0" fit-margin-right="0" fit-margin-left="0" fit-margin-top="0" showgrid="false" inkscape:current-layer="layer1" inkscape:document-units="px" inkscape:cy="49.999998" inkscape:cx="50.000002" inkscape:zoom="0.35" inkscape:pageshadow="2" inkscape:pageopacity="0.0" borderopacity="1.0" bordercolor="#666666" pagecolor="#ffffff" id="base">
 9 | 	</sodipodi:namedview>
10 | <path id="path4018" sodipodi:cx="244.28572" sodipodi:cy="553.79077" sodipodi:type="arc" sodipodi:rx="127.14286" sodipodi:ry="127.14286" fill="#333333" d="
11 | 	M90.244,49.481c0,21.95-17.794,39.744-39.744,39.744c-21.949,0-39.744-17.794-39.744-39.744S28.551,9.737,50.5,9.737
12 | 	C72.45,9.737,90.244,27.531,90.244,49.481z"/>
13 | <text transform="matrix(1 0 0 1 94.5 68.5)" font-family="'OCRAStd'" font-size="49" letter-spacing="-3">PING</text>
14 | <text transform="matrix(1 0 0 1 163.9385 83)" fill="#333333" font-family="'OCRAStd'" font-size="12">for PHP</text>
15 | <g>
16 | 	<polyline fill="none" stroke="#FFFFFF" stroke-width="4" stroke-linecap="round" stroke-linejoin="round" points="71.712,37.319 
17 | 		54.663,52.519 46.538,44.394 29.288,61.644 	"/>
18 | 	
19 | 		<circle fill="#333333" stroke="#FFFFFF" stroke-width="4" stroke-linecap="round" stroke-linejoin="round" cx="71.712" cy="37.319" r="7.55"/>
20 | 	
21 | 		<circle fill="#333333" stroke="#FFFFFF" stroke-width="4" stroke-linecap="round" stroke-linejoin="round" cx="29.287" cy="61.644" r="7.55"/>
22 | </g>
23 | </svg>
24 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "geerlingguy/ping",
 3 |     "description": "A PHP class to ping hosts.",
 4 |     "license": "MIT",
 5 |     "authors": [
 6 |         {
 7 |             "name": "Jeff Geerling",
 8 |             "email": "jeff@jeffgeerling.com"
 9 |         }
10 |     ],
11 |     "autoload": {
12 |         "classmap": [ "JJG/Ping.php" ]
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------