Merge pull request #24 from xp-framework/refactor/simplify-network

Simplify peer.net API

Author: thekid

src/main/php/peer/net/Inet4Address.class.php

@@ -5,67 +5,71 @@
 /**
  * IPv4 address
  *
- * @test  xp://peer.unittest.Inet4AddressTest
- * @see   php://ip2long
+ * @test peer.unittest.Inet4AddressTest
  */
-class Inet4Address implements InetAddress {
+class Inet4Address extends InetAddress {
   private $addr;
 
   /**
-   * Convert IPv4 address from dotted form into a long. Supports hexadecimal and
+   * Constructor
+   *
+   * Converts IPv4 address from dotted form into a long. Supports hexadecimal and
    * octal notations. Yes, 0177.0.0.1 and 0x7F.0.0.1 are both equivalent with
    * 127.0.0.1 - localhost!
    *
-   * @param  string $ip
-   * @return int
+   * @param  string|int $address
+   * @throws lang.FormatException in case address is illegal
+   */
+  public function __construct($address) {
+    if (is_int($address)) {
+      $this->addr= $address;
+    } else {
+      $this->addr= self::parse($address);
+    }
+  }
+
+  /**
+   * Parse a given input string, either raising exceptions or silently returning NULL.
+   *
+   * @see    https://www.php.net/ip2long (doesn't support hexadecimal and octal representations)
+   * @param  string $input
+   * @param  bool $throw
+   * @return ?int
    * @throws lang.FormatException
    */
-  protected static function ip2long($ip) {
-    $i= 0; $addr= 0; $count= 0;
-    foreach (explode('.', $ip) as $byte) {
-      if (++$count > 4) {
-        throw new FormatException('Given IP string has more than 4 blocks: ['.$ip.']');
-      }
+  public static function parse($input, $throw= true) {
+    $blocks= explode('.', $input);
+    if (sizeof($blocks) > 4) {
+      if ($throw) throw new FormatException('Given IP string has more than 4 blocks: '.$input);
+      return null;
+    }
 
-      $l= strlen($byte);
+    $r= 0;
+    foreach ($blocks as $i => $block) {
+      $l= strlen($block);
       $n= -1;
-      if ($l > 1 && '0' === $byte[0]) {
-        if (('x' === $byte[1] || 'X' === $byte[1]) && $l === strspn($byte, '0123456789aAbBcCdDeEfF', 2) + 2) {
-          $n= hexdec($byte);
-        } else if ($l === strspn($byte, '0123456789')) {
-          $n= octdec($byte);
+      if ($l > 1 && '0' === $block[0]) {
+        if (('x' === $block[1] || 'X' === $block[1]) && $l === strspn($block, '0123456789aAbBcCdDeEfF', 2) + 2) {
+          $n= hexdec($block);
+        } else if ($l === strspn($block, '01234567')) {
+          $n= octdec($block);
         }
-      } else if ($l > 0 && $l === strspn($byte, '0123456789')) {
-        $n= (int)$byte;
+      } else if ($l > 0 && $l === strspn($block, '0123456789')) {
+        $n= (int)$block;
       }
 
       if ($n < 0 || $n > 255) {
-        throw new FormatException('Invalid format of IP address: ['.$ip.']'); 
+        if ($throw) throw new FormatException('Invalid format of IP address: '.$input);
+        return null;
       }
 
-      $addr|= ($n << (8 * (3 - $i++)));
+      $r|= $n << (8 * (3 - $i));
     }
-    return $addr;
-  }
-  
-  /**
-   * Constructor
-   *
-   * @param  string $address
-   * @throws lang.FormatException in case address is illegal
-   */
-  public function __construct($address) {
-    $this->addr= self::ip2long($address);
+    return $r;
   }
 
-  /**
-   * Retrieve size of ips of this kind in bits.
-   *
-   * @return  int
-   */
-  public function  sizeInBits() {
-    return 32;
-  }
+  /** @return int */
+  public function sizeInBits() { return 32; }
 
   /**
    * Retrieve IP address notation for DNS reverse query
@@ -97,11 +101,12 @@ public function isLoopback() {
   /**
    * Determine whether address is in the given subnet
    *
-   * @param   string net
-   * @return  bool
-   * @throws  lang.FormatException in case net has invalid format
+   * @param  string|peer.net.Network $subnet
+   * @return bool
+   * @throws lang.FormatException in case net has invalid format
    */
-  public function inSubnet(Network $net) {
+  public function inSubnet($subnet) {
+    $net= $subnet instanceof Network ? $subnet : new Network($subnet);
     if (!$net->getAddress() instanceof self) return false;
 
     $addrn= $net->getAddress()->addr;

src/main/php/peer/net/Inet6Address.class.php

@@ -8,68 +8,68 @@
  *
  * @test  xp://peer.unittest.net.Inet6AddressTest
  */
-class Inet6Address implements InetAddress {
-  protected $addr;
-  
+class Inet6Address extends InetAddress {
+  private $addr;
+
   /**
    * Constructor
    *
-   * @param   string addr
-   * @param   bool   binary
+   * @param  string $addr
+   * @param  bool $binary
+   * @throws lang.FormatException in case address is illegal
    */
   public function __construct($addr, $binary= false) {
     if ($binary) {
       $this->addr= $addr;
     } else {
-      $this->addr= pack('H*', self::normalize($addr));
+      $this->addr= self::parse($addr);
     }
   }
 
-  /**
-   * Retrieve size of ips of this kind in bits.
-   *
-   * @return  int
-   */
-  public function sizeInBits() {
-    return 128;
-  }
+  /** @return int */
+  public function sizeInBits() { return 128; }
 
   /**
-   * Normalize address
+   * Parse a given input string, either raising exceptions or silently returning NULL.
    *
-   * @param   string addr
-   * @return  string
+   * @param  string $input
+   * @param  bool $throw
+   * @return ?string
+   * @throws lang.FormatException
    */
-  public static function normalize($addr) {
+  public static function parse($input, $throw= true) {
     $out= '';
-    $hexquads= explode(':', $addr);
+    $quads= explode(':', $input);
 
     // Shortest address is ::1, this results in 3 parts...
-    if (sizeof($hexquads) < 3) {
-      throw new FormatException('Address contains less than 1 hexquad part: ['.$addr.']');
+    if (sizeof($quads) < 3) {
+      if ($throw) throw new FormatException('Address contains less than 1 hexquad part: '.$input);
+      return null;
     }
 
-    if ('' == $hexquads[0]) array_shift($hexquads);
-    foreach ($hexquads as $hq) {
-      if ('' == $hq) {
-        $out.= str_repeat('0000', 8 - (sizeof($hexquads)- 1));
+    if ('' === $quads[0]) array_shift($quads);
+    foreach ($quads as $hq) {
+      if ('' === $hq) {
+        $out.= str_repeat('0000', 8 - (sizeof($quads) - 1));
         continue;
       }
 
       // Catch cases like ::ffaadd00::
       if (strlen($hq) > 4) {
-        throw new FormatException('Detected hexquad w/ more than 4 digits in ['.$addr.']');
+        if ($throw) throw new FormatException('Detected hexquad w/ more than 4 digits in '.$input);
+        return null;
       }
 
       // Not hex
       if (strspn($hq, '0123456789abcdefABCDEF') < strlen($hq)) {
-        throw new FormatException('Illegal digits in ['.$addr.']');
+        if ($throw) throw new FormatException('Illegal digits in '.$input);
+        return null;
       }
 
-      $out.= str_repeat('0', 4- strlen($hq)).$hq;
+      $out.= str_repeat('0', 4 - strlen($hq)).$hq;
     }
-    
-    return $out;
+
+    return pack('H*', $out);
   }
 
   /**
@@ -131,26 +131,27 @@ public function reversedNotation() {
   /**
    * Determine whether address is in the given subnet
    *
-   * @param   string net
-   * @return  bool
-   * @throws  lang.FormatException in case net has invalid format
+   * @param  string|peer.net.Network $subnet
+   * @return bool
+   * @throws lang.FormatException in case net has invalid format
    */
-  public function inSubnet(Network $net) {
+  public function inSubnet($subnet) {
+    $net= $subnet instanceof Network ? $subnet : new Network($subnet);
+    if (!$net->getAddress() instanceof self) return false;
+
     $addr= $net->getAddress();
     $mask= $net->getNetmask();
-    
     $position= 0;
     while ($mask > 8) {
-      if ($addr->addr[$position] != $this->addr[$position]) return false;
+      if ($addr->addr[$position] !== $this->addr[$position]) return false;
       $position++;
       $mask-= 8;
     }
 
-    if ($mask > 0) {
-      return ord($addr->addr[$position]) >> (8 - $mask) == ord($this->addr[$position]) >> (8 - $mask);
-    }
-    
-    return true;
+    return $mask > 0
+      ? ord($addr->addr[$position]) >> (8 - $mask) === ord($this->addr[$position]) >> (8 - $mask)
+      : true
+    ;
   }
 
   /**

src/main/php/peer/net/InetAddress.class.php

@@ -1,55 +1,72 @@
 <?php namespace peer\net;
 
-use lang\Value;
+use lang\{Value, FormatException, IllegalArgumentException};
 
 /**
  * Common ancestor for IPv4 and IPv6
+ *
+ * @test  peer.unittest.net.InetAddressTest
  */
-interface InetAddress extends Value {
+abstract class InetAddress implements Value {
 
   /**
    * Retrieve "human-readable" address
    *
-   * @return  string
+   * @return string
    */
-  public function asString();
+  public abstract function asString();
 
   /**
    * Check whether this address is a loopback address
    *
-   * @return  bool
+   * @return bool
    */
-  public function isLoopback();
+  public abstract function isLoopback();
 
   /**
    * Determine whether this address is in the given network.
    *
-   * @param   peer.net.Network net
-   * @return  bool
-   * @throws  lang.FormatException in case net has invalid format
+   * @param  string|peer.net.Network $subnet
+   * @return bool
+   * @throws lang.FormatException in case net has invalid format
    */
-  public function inSubnet(Network $net);
+  public abstract function inSubnet($subnet);
 
   /**
    * Create a subnet of this address, with the specified size.
    *
-   * @param   int subnetSize
-   * @return  peer.net.Network
-   * @throws  lang.IllegalArgumentException in case the subnetSize is not correct
+   * @param  int $size
+   * @return peer.net.Network
+   * @throws lang.IllegalArgumentException in case the $size is not correct
    */
-  public function createSubnet($subnetSize);
+  public abstract function createSubnet($size);
 
   /**
    * Retrieve size of address in bits
    *
-   * @return  int
+   * @return int
    */
-  public function sizeInBits();
+  public abstract function sizeInBits();
 
   /**
    * Retrieve reversed notation for reverse DNS lookups
    *
-   * @return  string
+   * @return string
    */
-  public function reversedNotation();
+  public abstract function reversedNotation();
+
+  /**
+   * Returns an IPv4 or IPv6 address based on the given input
+   *
+   * @throws lang.FormatException
+   */
+  public static function new(string $arg): self {
+    if (preg_match('/^[a-fA-F0-9x\.]+$/', $arg)) {
+      return new Inet4Address($arg);
+    } else if (preg_match('/^[a-f0-9\:]+$/', $arg)) {
+      return new Inet6Address($arg);
+    } else {
+      throw new FormatException('Given argument does not look like an IP address: '.$arg);
+    }
+  }
 }