RawIpAddress.java

Go to the documentation of this file.

import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 *  Encapsulates arithmetics on raw IP addresses (see RawIpAddress.addr).
 *  
 *  @author Mikica B Kocic
 *
 */
public class RawIpAddress
{
    /**
     *  Raw IP address (IPv4 or IPv6) in network byte (MSB) order where
     *  the highest order byte of the address is in addr[0].
     *  
     *  IPv4 address byte array must be 4 bytes long and IPv6 byte array must be 
     *  16 bytes long.
     *
     *  See: <code>InetAddress.getByAddress()</code>
     *  in http://download.oracle.com/javase/6/docs/api/java/net/InetAddress.html
     */
    private byte[] addr = null;

    /**
     *  Creates instance from a copy of the existing IP address. 
     */
    public RawIpAddress( RawIpAddress original )
    {
        this.addr = new byte[ original.addr.length ];
        this.set( original );
    }

    /**
     *  Creates instance from the determined IP address of a host, given the host's name. 
     *
     *  See: <code>InetAddress.getByName()</code>
     *  in http://download.oracle.com/javase/6/docs/api/java/net/InetAddress.html
     *
     *  @throws UnknownHostException if no IP address for the host could be found,
     *                    or if a scope_id was specified for a global IPv6 address. 
     */
    public RawIpAddress( String hostname ) throws UnknownHostException
    {
        this.addr = InetAddress.getByName( hostname ).getAddress ();
    }
    
    /**
     *  Returns a new instance of <code>InetAddress</code> given the raw IP address. 
     *  This method doesn't block, i.e. no reverse name service lookup is performed.
     *  
     *  @throws UnknownHostException  if IP address is of illegal length
     */
    public InetAddress getInetAddress () throws UnknownHostException
    {
        return InetAddress.getByAddress( this.addr );
    }

    /**
     *  Returns true if two IP addresses belongs to the same version
     */
    public boolean isSameVersion( RawIpAddress a2 )
    {
        return this.addr.length == a2.addr.length;
    }
    
    /**
     *  Sets the IP address from the value of other IP address. 
     */
    public void set( RawIpAddress a2 )
    {
        assert ! isSameVersion( a2 ) 
            : "We can do arithmetics only with addresses of the same IP version!";

        System.arraycopy( a2.addr, 0, this.addr, 0, a2.addr.length );
    }

    /**
     *  Increases the IP address by one. 
     */
    public void increase ()
    {
        int carry = 1; // initial carry is 1 meaning increment by one
        
        for ( int i = addr.length - 1; i >= 0 && carry > 0; --i )
        {
            int sum = ( ( addr[i] + 0x100 ) & 0xFF ) + carry; // add carry to current
            carry = sum >> 8; // carry is overflow over 0x100
            addr[i] = (byte)( ( sum & 0xFF ) - 0x100 ); 
        }
    }
    
    /**
     *  Returns difference of two IP addresses. 
     *  
     *  \warning { Caveats:
     *  
     *  IPv6 addresses are 16 octets long, but this function returns
     *  primitive type <code>long</code> that is 8 octets long, so
     *  it will give wrong result if upper 8 octets of two IPv6 addresses
     *  are different.
     *  
     *  However, the meaning of this procedure was to calculate the span
     *  of the range between two IP addresses that will be scanned, so it
     *  will actually fail if we wanted to scan more than 2^64 hosts.
     *  
     *  Maybe it would be better to specify <em>start IP address</em> 
     *  and <em>count of IP addresses</em> instead of start and stop IP addresses as
     *  input parameters? }
     *  
     *  @param a2   the second IP address
     */
    public long subtract( RawIpAddress a2 )
    {
        assert ! isSameVersion( a2 ) 
            : "We can do arithmetics only with addresses of the same IP version!";

        long delta = 0;
        
        for ( int i = 0; i < this.addr.length; ++i ) 
        {
            int b1 = ( this.addr[i] + 0x100 ) & 0xFF;
            int b2 = ( a2.addr[i] + 0x100 ) & 0xFF;

            delta <<= 8;
            delta += ( b1 - b2 );
        }

        return delta;
    }
    
    /**
     *  Compares two IP addresses. 
     *  
     *  @param a2   the second IP address
     *  @return -1 if first < second, 0 if first == second, 1 if first > second address
     */
    public int compare( RawIpAddress a2 )
    {
        assert ! isSameVersion( a2 ) 
            : "We can do arithmetics only with addresses of the same IP version!";

        for ( int i = 0; i < this.addr.length; ++i )
        {
            int b1 = ( this.addr[i] + 0x100 ) & 0xFF;
            int b2 = ( a2.addr[i] + 0x100 ) & 0xFF;

            if ( b1 < b2 ) {
                return -1;
            } else if ( b1 > b2 ) {
                return +1;
            } else {
                /* equal; continue */
            }
        }
        
        return 0;
    }
    
    /**
     *  Returns standard decimal dotted representation of the IP address  
     */
    public String toString () 
    {
        StringBuffer result = new StringBuffer ();

        for( int i = 0; i < this.addr.length; i++ )
        {
            if ( i != 0 ) {
                result.append( "." );
            }
            result.append( ( this.addr[i] + 0x100 ) & 0xFF );
        }

        return result.toString ();
    }
}