src/org/lwes/util/IPAddress.java

   1 package org.lwes.util;
   2
   3 import java.net.InetAddress;
   4 import java.net.UnknownHostException;
   5
   6 /**
   7  * This is a wrapper class for InetAddress, which allows the setting of
   8  * an InetAddress with a byte arrays.  As well as other useful functions.
   9  *
  10  * @author Anthony Molinaro
  11  */
  12 public class IPAddress implements java.io.Serializable {
  13     /* serializable UID */
  14     static final long serialVersionUID = -1;
  15
  16     /* inet address in network byte order */
  17     private byte[] inet_addr;
  18     private InetAddress java_inet_addr;
  19
  20     /**
  21      * Defaut constructor
  22      */
  23     public IPAddress() {
  24         inet_addr = new byte[4];
  25         inet_addr[0] = (byte) 0;
  26         inet_addr[1] = (byte) 0;
  27         inet_addr[2] = (byte) 0;
  28         inet_addr[3] = (byte) 0;
  29         java_inet_addr = null;
  30     }
  31
  32     /**
  33      * Construct an IPAddress object with a string of the form
  34      * "%d.%d.%d.%d" representing an InetAddress.
  35      * The address defaults to 0.0.0.0 if an invalid address is
  36      * given.
  37      *
  38      * @param anIPAddress the string representing the IPAddress
  39      */
  40     public IPAddress(String anIPAddress) {
  41         try {
  42             java_inet_addr = InetAddress.getByName(anIPAddress);
  43             inet_addr = java_inet_addr.getAddress();
  44         }
  45         catch (UnknownHostException e) {
  46             java_inet_addr = null;
  47             inet_addr = new byte[4];
  48             inet_addr[0] = (byte) 0;
  49             inet_addr[1] = (byte) 0;
  50             inet_addr[2] = (byte) 0;
  51             inet_addr[3] = (byte) 0;
  52         }
  53     }
  54
  55     /**
  56      * Construct an IPAddress object with a byte array containing
  57      * the InetAddress in little-endian notation.
  58      *
  59      * @param anIPAddress the byte array representing the IPAddress
  60      */
  61     public IPAddress(byte[] anIPAddress) {
  62         if (anIPAddress.length != 4) {
  63             System.err.println("ERROR : bad inet addr\n");
  64             throw new RuntimeException("Bad inet address");
  65         }
  66         inet_addr = anIPAddress;
  67     }
  68
  69     /**
  70      * Construct an IPAddress object with an InetAddress.
  71      *
  72      * @param anIPAddress the InetAddress to set this IPAddress to
  73      */
  74     public IPAddress(InetAddress anIPAddress) {
  75         java_inet_addr = anIPAddress;
  76         inet_addr = java_inet_addr.getAddress();
  77     }
  78
  79     /**
  80      * Get the InetAddress representing this IPAddress
  81      *
  82      * @return the InetAddress representing this IPAddress
  83      */
  84     public InetAddress toInetAddress() {
  85         if (java_inet_addr != null) {
  86             return java_inet_addr;
  87         }
  88         else {
  89             try {
  90                 return InetAddress.getByName(toString());
  91             }
  92             catch (UnknownHostException e) {
  93             }
  94             return null;
  95         }
  96     }
  97
  98     /**
  99      * Return the IPAddress in a byte array in network order
 100      *
 101      * @return a byte array containing the IPAddress in network order
 102      */
 103     public byte[] getInetAddressAsBytes() {
 104         return inet_addr;
 105     }
 106
 107     /**
 108      * Return the IPAddress in as an integer
 109      *
 110      * @return an integer representing the IPAddress in network order
 111      */
 112     public int toInt() {
 113         return (int) ((inet_addr[0] << 24)
 114                       | (inet_addr[1] << 16)
 115                       | (inet_addr[2] << 8)
 116                       | (inet_addr[3] << 0));
 117     }
 118
 119     /**
 120      * return a string representation of an IPAddress in the following
 121      * format "%d.%d.%d.%d".
 122      *
 123      * @return a string representation of an IPAddress.
 124      */
 125     public String toString() {
 126         return (((int) (inet_addr[0]) & 0xff)
 127                 + "." + ((int) (inet_addr[1]) & 0xff)
 128                 + "." + ((int) (inet_addr[2]) & 0xff)
 129                 + "." + ((int) (inet_addr[3]) & 0xff));
 130     }
 131
 132     /**
 133      * return the size that an IPAddress takes up in a serialized byte array
 134      */
 135     public int bytesStoreSize() {
 136         return 4;
 137     }
 138
 139     public boolean equals(Object o) {
 140         if (!(o instanceof IPAddress)) {
 141             /* "o" is not an IPAddress object (note: it may be null). */
 142             return false;
 143         }
 144         final IPAddress other = (IPAddress) o;
 145         final byte[] theseBytes = this.getInetAddressAsBytes();
 146         final byte[] otherBytes = other.getInetAddressAsBytes();
 147         if (theseBytes.length != otherBytes.length) {
 148             /* same length or else not equal */
 149             return false;
 150         }
 151         for (int i = 0; i < theseBytes.length; ++i) {
 152             if (theseBytes[i] != otherBytes[i]) {
 153                 /* found a difference; not equal. */
 154                 return false;
 155             }
 156         }
 157         return true; /* passed all tests; return true */
 158     }
 159
 160     public int hashCode() {
 161         int hash = 0;
 162         final byte[] theseBytes = this.getInetAddressAsBytes();
 163         for (int i = 0; i < theseBytes.length; ++i) {
 164             hash ^= theseBytes[i];
 165         }
 166         return hash;
 167     }
 168 }