Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

All the library in one file to facilitate ruby-stdlib integration

  • Loading branch information...
commit 9caa3c8505e0a3563f6e54077d9674628e04864c 1 parent c95e3e6
@bluemonk authored
View
87 CHANGELOG.rdoc
@@ -1,87 +0,0 @@
-== ipaddress 0.7.5
-
-CHANGED:: IPAddress::IPv4#each_host to improve speed
-FIXED:: IPAddress::IPv4::summarize bug (summarization should now work properly)
-NEW:: IPAddress::IPv4#include_all?
-NEW:: #ipv4? and #ipv6?
-
-== ipaddress 0.7.0
-
-NEW:: IPAddress::IPv6#include?
-NEW:: IPAddress::IPv6#network_u128
-NEW:: Modified IPAddress::IPv6::Mapped to accept IPv4 mapped addresses in IPv6 format
-NEW:: IPAddress::IPv4#private?
-NEW:: IPAddress::IPv4::parse_classful
-
-== ipaddress 0.6.0
-
-=== API changes
-* IPv4#to_s now returns the address portion only,
- to retain compatibility with IPAddr. Example:
-
- IPAddress("172.16.10.1/24").to_s
- #=> "172.16.10.1" # ipaddress 0.6.0
-
- IPAddress("172.16.10.1/24").to_s
- #=> "172.16.10.1/24" # ipaddress 0.5.0
-
-* IPv6#to_s now returns the address portion only,
- to retain compatibility with IPAddr. Example:
-
- IPAddress "2001:db8::8:800:200c:417a/64".to_s
- #=> "2001:db8::8:800:200c:417a" # ipaddress 0.6.0
-
- IPAddress "2001:db8::8:800:200c:417a/64".to_s
- #=> "2001:db8::8:800:200c:417a/64" # ipaddress 0.6.0
-
-* IPv6::Unspecified#to_s, IPv6::Loopback and
- IPv6::Mapped#to_s now return the address portion only,
- to retain compatibility with IPAddr.
-* IPv4::summarize now returns an array even if the
- result is a single subnet, to keep consistency
- and avoid confusion
-
-=== New methods
-* IPv4#to_string and IPv6#to_string: print the address
- with the prefix portion, like the #to_s method in
- ipaddress 0.5.0
-* IPAddress::parse, for those who don't like the wrapper
- method IPAddress()
-* IPv6#to_string_uncompressed, returns a string with the
- uncompressed IPv6 and the prefix
-* IPv6::Mapped#to_string, returns the IPv6 Mapped address
- with IPv4 notation and the prefix
-* IPv6#reverse, returns the ip6.arpa DNS reverse lookup
- string
-* IPv4#arpa and IPv6#arpa, alias of the respective #reverse
- methods
-* Prefix#+, Prefix#-
-
-=== Library structure
-* Moved all the IPAddress module methods from
- lib/ipaddress/ipbase.rb to lib/ipaddress.rb
-* Removed IPBase superclass
-* IPv4 and IPv6 classes no longer inherit from IPBase
-* Removed lib/ipaddress/ipbase.rb
-* Removed test/ipaddress/ipbase_test.rb
-
-=== Minor fixes
-* Replaced Ruby 1.9 deprecated Hash#index with Hash#key
-* Removed require ruby-prof from tests which was causing
- users to install ruby-prof or manually remove the line
-* Removed "must" method from tests, replaced by normal
- Test::Unit methods
-* Removed duplicate Jeweler entry in Rakefile
-* Made Integer#closest_power_of_2 more general by adding
- an optional limit parameter
-* Fixed summarization algorithm (thanks to nicolas fevrier)
-* Fixed bug in prefix_from_ip (thanks to jdpace)
-
-=== Documentation
-* Normalized README rdoc headers
-* Added documentation for IPAddress::Prefix
-* Added documentation for IPAddress::IPv4 and
- IPAddress::IPv6
-* Fixed formatting
-* Fixed lots of typos
-
View
20 LICENSE
@@ -1,20 +0,0 @@
-Copyright (c) 2009-2011 Marco Ceresa
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
View
935 README.rdoc
@@ -1,935 +0,0 @@
-= IPAddress
-
-IPAddress is a Ruby library designed to make the use of IPv4 and IPv6
-addresses simple, powerful and enjoyable. It provides a complete set of
-methods to handle IP addresses for any need, from simple scripting to
-full network design.
-
-IPAddress is written with a full OO interface, and its code is easy to
-read, maintain and extend. The documentation is full of examples, to
-let you start being productive immediately.
-
-This document provides a brief introduction to the library and
-examples of typical usage.
-
-== Requirements
-
-* Ruby >= 1.8.6 (not tested with previous versions)
-
-IPAddress works perfectly on:
-
-* Ruby 1.8.6 (2007-03-13 patchlevel 0)
-* Ruby 1.8.7
-* Ruby 1.9.1
-* Ruby 1.9.2dev (2010-06-08 revision 28230)
-* Ruby 1.9.2dev (2010-07-15 revision 28653)
-* Rubinius 1.0.1 (1.8.7 release 2010-06-03 JI)
-* Ironruby >= 1.0
-
-It hasn't yet been tested on any other platform, so if you want to collaborate feel
-free to send a small report to my email address, or
-{join the discussion}[http://groups.google.com/group/ruby-ipaddress].
-
-== Why not using IPAddr?
-
-IPAddr is the IP addresses library that comes with Ruby standard
-lib. We found this library, although very well written, not very
-suitable for all our needs, and not very flexible.
-
-Some quick examples of things you can't do with IPAddr:
-
-* store both the address and the prefix information
-* quickly find the broadcast address of a network
-* iterate over hosts
-* perform subnetting or network aggregation
-
-Many methods and procedures are so old that they have been
-declared deprecated by the IETF, and some others have bugs in their
-implementation.
-
-Moreover, IPAddress is more robust and is already around 50% faster than IPAddr,
-in addition to provide an organic API with logical separation and OO structure.
-
-We hope that IPAddress will address all these issues and meet all your
-needs in network programming.
-
-== Installation
-
-Install the library using rubygems
-
- $ gem install ipaddress
-
-You can then use it in your programs:
-
- require 'rubygems' # optional
- require 'ipaddress'
-
-Another way would be to clone the git repository
-
- $ git clone git://github.com/bluemonk/ipaddress.git
-
-And then install the library
-
- $ cd ipaddress
- ipaddress$ rake install
-
-== Documentation
-
-The code is fully documented with RDoc. You can generate the
-documentation with Rake:
-
- ipaddress$ rake rdoc
-
-The latest documentation can be found online at
-{this address}[http://rubydoc.info/gems/ipaddress/0.7.0/frames]
-
-== IPv4
-
-Class IPAddress::IPv4 is used to handle IPv4 type addresses. IPAddress
-is similar to other IP Addresses libraries, like Ruby's own
-IPAddr. However it works slightly different, as we will see.
-
-=== Create a new IPv4 address
-
-The usual way to express an IP Address is using its dotted decimal
-form, such as 172.16.10.1, and a prefix, such as 24, separated by a
-slash.
-
- 172.16.10.1/24
-
-To create a new IPv4 object, you can use IPv4 own class
-
- ip = IPAddress::IPv4.new "172.16.10.1/24"
-
-or, in a easier way, using the IPAddress parse method
-
- ip = IPAddress.parse "172.16.10.1/24"
-
-which accepts and parses any kind of IP (IPv4, IPV6 and
-IPv4 IPv6 Mapped addresses).
-
-If you like syntactic sugar, you can use the wrapper method
-IPAddress(), which is built around IPAddress::parse:
-
- ip = IPAddress "172.16.10.1/24"
-
-You can specify an IPv4 address in any of two ways:
-
- IPAddress "172.16.10.1/24"
- IPAddress "172.16.10.1/255.255.255.0"
-
-In this example, prefix /24 and netmask 255.255.255.0 are the same and
-you have the flexibility to use either one of them.
-
-If you don't explicitly specify the prefix (or the subnet mask),
-IPAddress thinks you're dealing with host addresses and not with
-networks. Therefore, the default prefix will be /32, or
-255.255.255.255. For example:
-
- # let's declare an host address
- host = IPAddress::IPv4.new "10.1.1.1."
-
-The new created object will have prefix /32, which is the same
-as we created the following:
-
- host = IPAddress::IPv4.new "10.1.1.1/32"
-
-=== Handling the IPv4 address
-
-Once created, you can obtain the attributes for an IPv4 object:
-
- ip = IPAddress("172.16.10.1/24")
-
- ip.address
- #=> "172.16.10.1"
- ip.prefix
- #=> 24
-
-In case you need to retrieve the netmask in IPv4 format, you can use
-the IPv4#netmask method:
-
- ip.netmask
- #=> "255.255.255.0"
-
-A special attribute, IPv4#octets, is available to get the four
-decimal octets from the IP address:
-
- ip.octets
- #=> [172,16,10,1]
-
-Shortcut method IPv4#[], provides access to a given octet whithin the
-range:
-
- ip[1]
- #=> 16
-
-If you need to print out the IPv4 address in a canonical form, you can
-use IPv4#to_string
-
- ip.to_string
- #=> "172.16.10.l/24"
-
-=== Changing netmask
-
-You can set a new prefix (netmask) after creating an IPv4
-object. For example:
-
- ip.prefix = 25
-
- ip.to_string
- #=> "172.16.10.l/25"
-
-If you need to use a netmask in IPv4 format, you can achive so by
-using the IPv4#netmask= method
-
- ip.netmask = "255.255.255.252"
-
- ip.to_string
- #=> "172.16.10.1/30"
-
-=== Working with networks, broadcasts and addresses
-
-Some very important topics in dealing with IP addresses are the
-concepts of +network+ and +broadcast+, as well as the addresses
-included in a range.
-
-When you specify an IPv4 address such as "172.16.10.1/24", you are
-actually handling two different information:
-
-* The IP address itself, "172.16.10.1"
-* The subnet mask which indicates the network
-
-The network number is the IP which has all zeroes in the host
-portion. In our example, because the prefix is 24, we identify our
-network number to have the last 8 (32-24) bits all zeroes. Thus, IP
-address "172.16.10.1/24" belongs to network "172.16.10.0/24".
-
-This is very important because, for instance, IP "172.16.10.1/16" is
-very different to the previous one, belonging to the very different
-network "172.16.0.0/16".
-
-==== Networks
-
-With IPAddress it's very easy to calculate the network for an IP
-address:
-
- ip = IPAddress "172.16.10.1/24"
-
- net = ip.network
- #=> #<IPAddress::IPv4:0xb7a5ab24 @octets=[172, 16, 10, 0],
- @prefix=24,
- @address="172.16.10.0">
- net.to_string
- #=> "172.16.10.0/24"
-
-The IPv4#network method creates a new IPv4 object from the network
-number, calculated after the original object. We want to outline here
-that the network address is a perfect legitimate IPv4 address, which
-just happen to have all zeroes in the host portion.
-
-You can use method IPv4#network? to check whether an IP address is a
-network or not:
-
- ip1 = IPAddress "172.16.10.1/24"
- ip2 = IPAddress "172.16.10.4/30"
-
- ip1.network?
- #=> false
- ip2.network?
- #=> true
-
-==== Broadcast
-
-The broadcast address is the contrary than the network number: where
-the network number has all zeroes in the host portion, the broadcast
-address has all one's. For example, ip "172.16.10.1/24" has broadcast
-"172.16.10.255/24", where ip "172.16.10.1/16" has broadcast
-"172.16.255.255/16".
-
-Method IPv4#broadcast has the same behavior as is #network
-counterpart: it creates a new IPv4 object to handle the broadcast
-address:
-
- ip = IPAddress "172.16.10.1/24"
-
- bcast = ip.broadcast
- #=> #<IPAddress::IPv4:0xb7a406fc @octets=[172, 16, 10, 255],
- @prefix=24,
- @address="172.16.10.255">
- bcast.to_string
- #=> "172.16.10.255/24"
-
-==== Addresses, ranges and iterators
-
-So we see that the netmask essentially specifies a range for IP
-addresses that are included in a network: all the addresses between
-the network number and the broadcast. IPAddress has many methods to
-iterate between those addresses. Let's start with IPv4#each, which
-iterates over all addresses in a range
-
- ip = IPAddress "172.16.10.1/24"
-
- ip.each do |addr|
- puts addr
- end
-
-It is important to note that it doesn't matter if the original IP is a
-host IP or a network number (or a broadcast address): the #each method
-only considers the range that the original IP specifies.
-
-If you only want to iterate over hosts IP, use the IPv4#each_host
-method:
-
- ip = IPAddress "172.16.10.1/24"
-
- ip.each_host do |host|
- puts host
- end
-
-Methods IPv4#first and IPv4#last return a new object containing
-respectively the first and the last host address in the range
-
- ip = IPAddress "172.16.10.100/24"
-
- ip.first.to_string
- #=> "172.16.10.1/24"
-
- ip.last.to_string
- #=> "172.16.10.254/24"
-
-=== IP special formats
-
-The IPAddress library provides a complete set of methods to access an
-IPv4 address in special formats, such as binary, 32 bits unsigned int,
-data and hexadecimal.
-
-Let's take the following IPv4 as an example:
-
- ip = IPAddress "172.16.10.1/24"
-
- ip.address
- #=> "172.16.10.1"
-
-The first thing to highlight here is that all these conversion methods
-only take into consideration the address portion of an IPv4 object and
-not the prefix (netmask).
-
-So, to express the address in binary format, use the IPv4#bits method:
-
- ip.bits
- #=> "10101100000100000000101000000001"
-
-To calculate the 32 bits unsigned int format of the ip address, use
-the IPv4#to_u32 method
-
- ip.to_u32
- #=> 2886732289
-
-This method is the equivalent of the Unix call pton(), expressing an
-IP address in the so called +network byte order+ notation. However, if
-you want to transmit your IP over a network socket, you might need to
-transform it in data format using the IPv4#data method:
-
- ip.data
- #=> "\254\020\n\001"
-
-Finally, you can transform an IPv4 address into a format which is
-suitable to use in IPv4-IPv6 mapped addresses:
-
- ip.to_ipv6
- #=> "ac10:0a01"
-
-=== Classful networks
-
-IPAddress allows you to create and manipulate objects using the old
-and deprecated (but apparently still popular) classful networks concept.
-
-Classful networks and addresses don't have a prefix: their subnet mask
-is univocally identified by their address, and therefore diveded in classes.
-As per RFC 791, these classes are:
-
-* Class A, from 0.0.0.0 to 127.255.255.255
-* Class B, from 128.0.0.0 to 191.255.255.255
-* Class C, from 192.0.0.0 to 255.255.255.255
-
-Since classful networks here are only considered to calculate the default
-prefix number, classes D and E are not considered.
-
-To create a classful IP and prefix from an IP address, use the
-IPv4::parse_classful method:
-
- # classful ip
- ip = IPAddress::IPv4::parse_classful "10.1.1.1"
-
- ip.prefix
- #=> 8
-
-The method automatically created a new IPv4 object and assigned it
-the correct prefix.
-
-You can easily check which CLASSFUL network an IPv4 object belongs:
-
- ip = IPAddress("10.0.0.1/24")
- ip.a?
- #=> true
-
- ip = IPAddress("172.16.10.1/24")
- ip.b?
- #=> true
-
- ip = IPAddress("192.168.1.1/30")
- ip.c?
- #=> true
-
-Remember that these methods are only checking the address portion of an IP, and are
-independent from its prefix, as classful networks have no concept of prefix.
-
-For more information on CLASSFUL networks visit the
-{Wikipedia page}[http://en.wikipedia.org/wiki/Classful_network]
-
-=== Network design with IPAddress
-
-IPAddress includes a lot of useful methods to manipulate IPv4 and IPv6
-networks and do some basic network design.
-
-==== Subnetting
-
-The process of subnetting is the division of a network into smaller
-(in terms of hosts capacity) networks, called subnets, so that they
-all share a common root, which is the starting network.
-
-For example, if you have network "172.16.10.0/24", we can subnet it
-into 4 smaller subnets. The new prefix will be /26, because 4 is 2^2
-and therefore we add 2 bits to the network prefix (24+2=26).
-
-Subnetting is easy with IPAddress. Let's work out the last example:
-
- network = IPAddress("172.16.10.0/24")
-
- subnets = network / 4
- #=> [#<IPAddress::IPv4:0xb7b10e10 @octets=[172,16,10,0] [...]
- #<IPAddress::IPv4:0xb7b0f1b4 @octets=[172,16,10,64] [...]
- #<IPAddress::IPv4:0xb7b0e5ac @octets=[172,16,10,128] [...]
- #<IPAddress::IPv4:0xb7b0e0c0 @octets=[172,16,10,192] [...]]
-
- subnets.map{|i| i.to_string}
- #=> ["172.16.10.0/26", "172.16.10.64/26", "172.16.10.128/26",
- "172.16.10.192/26"]
-
-You can also use method IPv4#subnets, which is an alias for
-IPv4#/. Please note that you don't have to specify a network to
-calculate a subnet: if the IPv4 object is a host IPv4, the method will
-calculate the network number for that network and then subnet it. For
-example:
-
- ip = IPAddress("172.16.10.58/24")
-
- ip.subnet(4).map{|i| i.to_string}
- #=> ["172.16.10.0/26", "172.16.10.64/26", "172.16.10.128/26",
- "172.16.10.192/26"]
-
-Usually, subnetting implies dividing a network to a number of subnets
-which is a power of two: in this way, you can be sure that the network
-will be divided evenly, and all the subnets will have the same number
-of hosts.
-
-==== Uneven subnetting
-
-IPAddress also handles un-even subnetting: if you specify any number
-(up to the prefix limit), the network will be divided so that the
-first power-of-two networks will be even, and all the rest will just
-fill out the space.
-
-As an example, let's divide network 172.16.10.0/24 into 3 different subnets:
-
- network = IPAddress("172.16.10.0/24")
-
- network.subnet(3).map{|i| i.to_string}
- #=> ["172.16.10.0/26",
- "172.16.10.64/26",
- "172.16.10.128/25"]
-
-We can go even further and divide into 11 subnets:
-
- network = IPAddress("172.16.10.0/24")
-
- network.subnet(11).map{|i| i.to_string}
- #=> ["172.16.10.0/28", "172.16.10.16/28", "172.16.10.32/28",
- "172.16.10.48/28", "172.16.10.64/28", "172.16.10.80/28",
- "172.16.10.96/28", "172.16.10.112/28", "172.16.10.128/27",
- "172.16.10.160/27", "172.16.10.192/26"]
-
-As you can see, most of the networks are /28, with a few /27 and one
-/26 to fill up the remaining space.
-
-==== Summarization
-
-Summarization (or aggregation) is the process when two or more
-networks are taken together to check if a supernet, including
-all and only these networks, exists. If it exists then this supernet
-is called the summarized (or aggregated) network.
-It is very important to understand that summarization can only
-occur if there are no holes in the aggregated network, or, in
-other words, if the given networks fill completely the address space
-of the supernet. So the two rules are:
-
-1) The aggregate network must contain +all+ the IP addresses of the
-original networks;
-
-2) The aggregate network must contain +only+ the IP addresses of the
-original networks;
-
-A few examples will help clarify the above. Let's consider for
-instance the following two networks:
-
- ip1 = IPAddress("172.16.10.0/24")
- ip2 = IPAddress("172.16.11.0/24")
-
-These two networks can be expressed using only one IP address
-network if we change the prefix. Let Ruby do the work:
-
- IPAddress::IPv4::summarize(ip1,ip2).to_string
- #=> "172.16.10.0/23"
-
-We note how the network "172.16.10.0/23" includes all the
-addresses specified in the above networks, and (more important) includes
-ONLY those addresses.
-
-If we summarized +ip1+ and +ip2+ with the following network:
-
- "172.16.0.0/16"
-
-we would have satisfied rule #1 above, but not rule #2. So
-
- "172.16.0.0/16"
-
-is not an aggregate network for +ip1+ and +ip2+.
-
-If it's not possible to compute a single aggregated network for
-all the original networks, the method returns an array with all the
-aggregate networks found. For example, the following four networks can be
-aggregated in a single /22:
-
- ip1 = IPAddress("10.0.0.1/24")
- ip2 = IPAddress("10.0.1.1/24")
- ip3 = IPAddress("10.0.2.1/24")
- ip4 = IPAddress("10.0.3.1/24")
-
- IPAddress::IPv4::summarize(ip1,ip2,ip3,ip4).map{|i| i.to_string}
- #=> ["10.0.0.0/22"]
-
-But the following networks can't be summarized in a single
-network:
-
- ip1 = IPAddress("10.0.1.1/24")
- ip2 = IPAddress("10.0.2.1/24")
- ip3 = IPAddress("10.0.3.1/24")
- ip4 = IPAddress("10.0.4.1/24")
-
- IPAddress::IPv4::summarize(ip1,ip2,ip3,ip4).map{|i| i.to_string}
- #=> ["10.0.1.0/24","10.0.2.0/23","10.0.4.0/24"]
-
-In this case, the two summarizables networks have been aggregated into
-a single /23, while the other two networks have been left untouched.
-
-==== Supernetting
-
-Supernetting is a different operation than aggregation, as it only
-works on a single network and returns a new single IPv4 object,
-representing the supernet.
-
-Supernetting is similar to subnetting, except that you getting as a
-result a network with a smaller prefix (bigger host space). For
-example, given the network
-
- ip = IPAddress("172.16.10.0/24")
-
-you can supernet it with a new /23 prefix
-
- ip.supernet(23).to_string
- #=> "172.16.10.0/23"
-
-However if you supernet it with a /22 prefix, the network address will
-change:
-
- ip.supernet(22).to_string
- #=> "172.16.8.0/22"
-
-This is because "172.16.10.0/22" is not a network anymore, but an host
-address.
-
-== IPv6
-
-IPAddress is not only fantastic for IPv4 addresses, it's also great to
-handle IPv6 addresses family! Let's discover together how to use it in
-our projects.
-
-=== IPv6 addresses
-
-IPv6 addresses are 128 bits long, in contrast with IPv4 addresses
-which are only 32 bits long. An IPv6 address is generally written as
-eight groups of four hexadecimal digits, each group representing 16
-bits or two octet. For example, the following is a valid IPv6
-address:
-
- 1080:0000:0000:0000:0008:0800:200c:417a
-
-Letters in an IPv6 address are usually written downcase, as per
-RFC. You can create a new IPv6 object using uppercase letters, but
-they will be converted.
-
-==== Compression
-
-Since IPv6 addresses are very long to write, there are some
-simplifications and compressions that you can use to shorten them.
-
-* Leading zeroes: all the leading zeroes within a group can be
- omitted: "0008" would become "8"
-
-* A string of consecutive zeroes can be replaced by the string
- "::". This can be only applied once.
-
-Using compression, the IPv6 address written above can be shorten into
-the following, equivalent, address
-
- 1080::8:800:200c:417a
-
-This short version is often used in human representation.
-
-==== Network Mask
-
-As we used to do with IPv4 addresses, an IPv6 address can be written
-using the prefix notation to specify the subnet mask:
-
- 1080::8:800:200c:417a/64
-
-The /64 part means that the first 64 bits of the address are
-representing the network portion, and the last 64 bits are the host
-portion.
-
-=== Using IPAddress with IPv6 addresses
-
-All the IPv6 representations we've just seen are perfectly fine when
-you want to create a new IPv6 address:
-
- ip6 = IPAddress "1080:0000:0000:0000:0008:0800:200C:417A"
-
- ip6 = IPAddress "1080:0:0:0:8:800:200C:417A"
-
- ip6 = IPAddress "1080::8:800:200C:417A"
-
-All three are giving out the same IPv6 object. The default subnet mask
-for an IPv6 is 128, as IPv6 addresses don't have classes like IPv4
-addresses. If you want a different mask, you can go ahead and explicit
-it:
-
- ip6 = IPAddress "2001:db8::8:800:200c:417a/64"
-
-Access the address portion and the prefix by using the respective
-methods:
-
- ip6 = IPAddress "2001:db8::8:800:200c:417a/64"
-
- ip6.address
- #=> "2001:0db8:0000:0000:0008:0800:200c:417a"
-
- ip6.prefix
- #=> 64
-
-A compressed version of the IPv6 address can be obtained with the
-IPv6#compressed method:
-
- ip6 = IPAddress "2001:0db8:0000:0000:0008:200c:417a:00ab/64"
-
- ip6.compressed
- #=> "2001:db8::8:800:200c:417a"
-
-=== Handling the IPv6 address
-
-Accessing the groups that form an IPv6 address is very easy with the
-IPv6#groups method:
-
- ip6 = IPAddress "2001:db8::8:800:200c:417a/64"
-
- ip6.groups
- #=> [8193, 3512, 0, 0, 8, 2048, 8204, 16762]
-
-As with IPv4 addresses, each individual group can be accessed using
-the IPv6#[] shortcut method:
-
- ip6[0]
- #=> 8193
- ip6[1]
- #=> 3512
- ip6[2]
- #=> 0
- ip6[3]
- #=> 0
-
-Note that each 16 bits group is expressed in its decimal form. You can
-also obtain the groups into hexadecimal format using the IPv6#hexs
-method:
-
- ip6.hexs
- #=> => ["2001", "0db8", "0000", "0000", "0008", "0800", "200c", "417a"]
-
-A few other methods are available to transform an IPv6 address into
-decimal representation, with IPv6.to_i
-
- ip6.to_i
- #=> 42540766411282592856906245548098208122
-
-or to hexadecimal representation
-
- ip6.to_hex
- #=> "20010db80000000000080800200c417a"
-
-To print out an IPv6 address in human readable form, use the IPv6#to_s, IPv6#to_string
-and IPv6#to_string_uncompressed methods
-
- ip6 = IPAddress "2001:db8::8:800:200c:417a/64"
-
- ip6.to_string
- #=> "2001:db8::8:800:200c:417a/96"
-
- ip6.to_string_uncompressed
- #=> "2001:0db8:0000:0000:0008:0800:200c:417a/96"
-
-As you can see, IPv6.to_string prints out the compressed form, while
-IPv6.to_string_uncompressed uses the expanded version.
-
-==== Compressing and uncompressing
-
-If you have a string representing an IPv6 address, you can easily
-compress it and uncompress it using the two class methods IPv6::expand
-and IPv6::compress.
-
-For example, let's say you have the following uncompressed IPv6
-address:
-
- ip6str = "2001:0DB8:0000:CD30:0000:0000:0000:0000"
-
-Here is the compressed version:
-
- IPAddress::IPv6.compress ip6str
- #=> "2001:db8:0:cd30::"
-
-The other way works as well:
-
- ip6str = "2001:db8:0:cd30::"
-
- IPAddress::IPv6.expand ip6str
- #=> "2001:0DB8:0000:CD30:0000:0000:0000:0000"
-
-These methods can be used when you don't want to create a new object
-just for expanding or compressing an address (although a new object is
-actually created internally).
-
-=== New IPv6 address from other formats
-
-You can create a new IPv6 address from different formats than just a
-string representing the colon-hex groups.
-
-For instance, if you have a data stream, you can use IPv6::parse_data,
-like in the following example:
-
- data = " \001\r\270\000\000\000\000\000\b\b\000 \fAz"
-
- ip6 = IPAddress::IPv6::parse_data data
- ip6.prefix = 64
-
- ip6.to_string
- #=> "2001:db8::8:800:200c:417a/64"
-
-A new IPv6 address can also be created from an unsigned 128 bits
-integer:
-
- u128 = 21932261930451111902915077091070067066
-
- ip6 = IPAddress::IPv6::parse_u128 u128
- ip6.prefix = 64
-
- ip6.to_string
- #=> "1080::8:800:200c:417a/64"
-
-Finally, a new IPv6 address can be created from an hex string:
-
- hex = "20010db80000000000080800200c417a"
-
- ip6 = IPAddress::IPv6::parse_hex hex
- ip6.prefix = 64
-
- ip6.to_string
- #=> "2001:db8::8:800:200c:417a/64"
-
-=== Special IPv6 addresses
-
-Some IPv6 have a special meaning and are expressed in a special form,
-quite different than an usual IPv6 address. IPAddress has built-in
-support for unspecified, loopback and mapped IPv6 addresses.
-
-==== Unspecified address
-
-The address with all zero bits is called the +unspecified+ address
-(corresponding to 0.0.0.0 in IPv4). It should be something like this:
-
- 0000:0000:0000:0000:0000:0000:0000:0000
-
-but, with the use of compression, it is usually written as just two
-colons:
-
- ::
-
-or, specifying the netmask:
-
- ::/128
-
-With IPAddress, create a new unspecified IPv6 address using its own
-subclass:
-
- ip = IPAddress::IPv6::Unspecified.new
-
- ip.to_string
- #=> "::/128"
-
-You can easily check if an IPv6 object is an unspecified address by
-using the IPv6#unspecified? method
-
- ip.unspecified?
- #=> true
-
-An unspecified IPv6 address can also be created with the wrapper
-method, like we've seen before
-
- ip = IPAddress "::"
-
- ip.unspecified?
- #=> true
-
-This address must never be assigned to an interface and is to be used
-only in software before the application has learned its host's source
-address appropriate for a pending connection. Routers must not forward
-packets with the unspecified address.
-
-==== Loopback address
-
-The loopback address is a unicast localhost address. If an
-application in a host sends packets to this address, the IPv6 stack
-will loop these packets back on the same virtual interface.
-
-Loopback addresses are expressed in the following form:
-
- ::1
-
-or, with their appropriate prefix,
-
- ::1/128
-
-As for the unspecified addresses, IPv6 loopbacks can be created with
-IPAddress calling their own class:
-
- ip = IPAddress::IPv6::Loopback.new
-
- ip.to_string
- #=> "::1/128"
-
-or by using the wrapper:
-
- ip = IPAddress "::1"
-
- ip.to_string
- #=> "::1/128"
-
-Checking if an address is loopback is easy with the IPv6#loopback?
-method:
-
- ip.loopback?
- #=> true
-
-The IPv6 loopback address corresponds to 127.0.0.1 in IPv4.
-
-==== Mapped address
-
-It is usually identified as a IPv4 mapped IPv6 address, a particular
-IPv6 address which aids the transition from IPv4 to IPv6. The
-structure of the address is
-
- ::ffff:w.y.x.z
-
-where w.x.y.z is a normal IPv4 address. For example, the following is
-a mapped IPv6 address:
-
- ::ffff:192.168.100.1
-
-IPAddress is very powerful in handling mapped IPv6 addresses, as the
-IPv4 portion is stored internally as a normal IPv4 object. Let's have
-a look at some examples. To create a new mapped address, just use the
-class builder itself
-
- ip6 = IPAddress::IPv6::Mapped.new "::ffff:172.16.10.1/128"
-
-or just use the wrapper method
-
- ip6 = IPAddress "::ffff:172.16.10.1/128"
-
-Let's check it's really a mapped address:
-
- ip6.mapped?
- #=> true
-
- ip6.to_string
- #=> "::ffff:172.16.10.1/128"
-
-Now with the +ipv4+ attribute, we can easily access the IPv4 portion
-of the mapped IPv6 address:
-
- ip6.ipv4.address
- #=> "172.16.10.1"
-
-Internally, the IPv4 address is stored as two 16 bits
-groups. Therefore all the usual methods for an IPv6 address are
-working perfectly fine:
-
- ip6.to_hex
- #=> "00000000000000000000ffffac100a01"
-
- ip6.address
- #=> "0000:0000:0000:0000:0000:ffff:ac10:0a01"
-
-A mapped IPv6 can also be created just by specify the address in the
-following format:
-
- ip6 = IPAddress "::172.16.10.1"
-
-That is, two colons and the IPv4 address. However, as by RFC, the ffff
-group will be automatically added at the beginning
-
- ip6.to_string
- => "::ffff:172.16.10.1/128"
-
-making it a mapped IPv6 compatible address.
-
-== Community
-
-Want to join the community?
-
-* {IPAddress google group}[http://groups.google.com/group/ruby-ipaddress]
-
-We've created a group to discuss about
-IPAddress future development, features and provide some kind of support.
-Feel free to join us and tell us what you think!
-
-== Thanks to
-
-Thanks to Luca Russo (vargolo) and Simone Carletti
-(weppos) for all the support and technical review. Thanks to Marco Beri,
-Bryan T. Richardson, Nicolas Fevrier, jdpace, Daniele Alessandri, jrdioko,
-Ghislain Charrier, Pawel Krzesniak, Mark Sullivan, Erik Ahlström and
-Steve Rawlinson for their support, feedback and bug reports.
-
-== Copyright
-
-Copyright (c) 2009-2011 Marco Ceresa. See LICENSE for details.
-
-
-
View
1  VERSION
@@ -1 +0,0 @@
-0.7.5
View
65 ipaddress.gemspec
@@ -1,65 +0,0 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
- s.name = %q{ipaddress}
- s.version = "0.7.5"
-
- s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
- s.authors = ["Marco Ceresa"]
- s.date = %q{2011-04-08}
- s.description = %q{ IPAddress is a Ruby library designed to make manipulation
- of IPv4 and IPv6 addresses both powerful and simple. It mantains
- a layer of compatibility with Ruby's own IPAddr, while
- addressing many of its issues.
-}
- s.email = %q{ceresa@gmail.com}
- s.extra_rdoc_files = [
- "LICENSE",
- "README.rdoc"
- ]
- s.files = [
- ".document",
- "CHANGELOG.rdoc",
- "LICENSE",
- "README.rdoc",
- "Rakefile",
- "VERSION",
- "lib/ipaddress.rb",
- "lib/ipaddress/extensions/extensions.rb",
- "lib/ipaddress/ipv4.rb",
- "lib/ipaddress/ipv6.rb",
- "lib/ipaddress/prefix.rb",
- "test/ipaddress/extensions/extensions_test.rb",
- "test/ipaddress/ipv4_test.rb",
- "test/ipaddress/ipv6_test.rb",
- "test/ipaddress/prefix_test.rb",
- "test/ipaddress_test.rb",
- "test/test_helper.rb"
- ]
- s.homepage = %q{http://github.com/bluemonk/ipaddress}
- s.require_paths = ["lib"]
- s.rubygems_version = %q{1.3.7}
- s.summary = %q{IPv4/IPv6 addresses manipulation library}
- s.test_files = [
- "test/ipaddress/extensions/extensions_test.rb",
- "test/ipaddress/ipv4_test.rb",
- "test/ipaddress/ipv6_test.rb",
- "test/ipaddress/prefix_test.rb",
- "test/ipaddress_test.rb",
- "test/test_helper.rb"
- ]
-
- if s.respond_to? :specification_version then
- current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
- s.specification_version = 3
-
- if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
- else
- end
- else
- end
-end
-
View
2,039 lib/ipaddress.rb
@@ -12,11 +12,6 @@
#
#++
-require 'ipaddress/ipv4'
-require 'ipaddress/ipv6'
-require 'ipaddress/extensions/extensions'
-
-
module IPAddress
NAME = "IPAddress"
@@ -185,4 +180,2038 @@ def IPAddress(str)
IPAddress::parse str
end
+module IPAddress
+
+ #
+ # =NAME
+ #
+ # IPAddress::Prefix
+ #
+ # =SYNOPSIS
+ #
+ # Parent class for Prefix32 and Prefix128
+ #
+ # =DESCRIPTION
+ #
+ # IPAddress::Prefix is the parent class for IPAddress::Prefix32
+ # and IPAddress::Prefix128, defining some modules in common for
+ # both the subclasses.
+ #
+ # IPAddress::Prefix shouldn't be accesses directly, unless
+ # for particular needs.
+ #
+ class Prefix
+
+ include Comparable
+
+ attr_reader :prefix
+
+ #
+ # Creates a new general prefix
+ #
+ def initialize(num)
+ @prefix = num.to_i
+ end
+
+ #
+ # Returns a string with the prefix
+ #
+ def to_s
+ "#@prefix"
+ end
+ alias_method :inspect, :to_s
+
+ #
+ # Returns the prefix
+ #
+ def to_i
+ @prefix
+ end
+
+ #
+ # Compare the prefix
+ #
+ def <=>(oth)
+ @prefix <=> oth.to_i
+ end
+
+ #
+ # Sums two prefixes or a prefix to a
+ # number, returns a Fixnum
+ #
+ def +(oth)
+ if oth.is_a? Fixnum
+ self.prefix + oth
+ else
+ self.prefix + oth.prefix
+ end
+ end
+
+ #
+ # Returns the difference between two
+ # prefixes, or a prefix and a number,
+ # as a Fixnum
+ #
+ def -(oth)
+ if oth.is_a? Fixnum
+ self.prefix - oth
+ else
+ (self.prefix - oth.prefix).abs
+ end
+ end
+
+ end # class Prefix
+
+
+ class Prefix32 < Prefix
+
+ IN4MASK = 0xffffffff
+
+ #
+ # Creates a new prefix object for 32 bits IPv4 addresses
+ #
+ # prefix = IPAddress::Prefix32.new 24
+ # #=> 24
+ #
+ def initialize(num)
+ unless (0..32).include? num
+ raise ArgumentError, "Prefix must be in range 0..32, got: #{num}"
+ end
+ super(num)
+ end
+
+ #
+ # Returns the length of the host portion
+ # of a netmask.
+ #
+ # prefix = Prefix32.new 24
+ #
+ # prefix.host_prefix
+ # #=> 8
+ #
+ def host_prefix
+ 32 - @prefix
+ end
+
+ #
+ # Transforms the prefix into a string of bits
+ # representing the netmask
+ #
+ # prefix = IPAddress::Prefix32.new 24
+ #
+ # prefix.bits
+ # #=> "11111111111111111111111100000000"
+ #
+ def bits
+ "%.32b" % to_u32
+ end
+
+ #
+ # Gives the prefix in IPv4 dotted decimal format,
+ # i.e. the canonical netmask we're all used to
+ #
+ # prefix = IPAddress::Prefix32.new 24
+ #
+ # prefix.to_ip
+ # #=> "255.255.255.0"
+ #
+ def to_ip
+ [bits].pack("B*").unpack("CCCC").join(".")
+ end
+
+ #
+ # An array of octets of the IPv4 dotted decimal
+ # format
+ #
+ # prefix = IPAddress::Prefix32.new 24
+ #
+ # prefix.octets
+ # #=> [255, 255, 255, 0]
+ #
+ def octets
+ to_ip.split(".").map{|i| i.to_i}
+ end
+
+ #
+ # Unsigned 32 bits decimal number representing
+ # the prefix
+ #
+ # prefix = IPAddress::Prefix32.new 24
+ #
+ # prefix.to_u32
+ # #=> 4294967040
+ #
+ def to_u32
+ (IN4MASK >> host_prefix) << host_prefix
+ end
+
+ #
+ # Shortcut for the octecs in the dotted decimal
+ # representation
+ #
+ # prefix = IPAddress::Prefix32.new 24
+ #
+ # prefix[2]
+ # #=> 255
+ #
+ def [](index)
+ octets[index]
+ end
+
+ #
+ # The hostmask is the contrary of the subnet mask,
+ # as it shows the bits that can change within the
+ # hosts
+ #
+ # prefix = IPAddress::Prefix32.new 24
+ #
+ # prefix.hostmask
+ # #=> "0.0.0.255"
+ #
+ def hostmask
+ [~to_u32].pack("N").unpack("CCCC").join(".")
+ end
+
+ #
+ # Creates a new prefix by parsing a netmask in
+ # dotted decimal form
+ #
+ # prefix = IPAddress::Prefix32::parse_netmask "255.255.255.0"
+ # #=> 24
+ #
+ def self.parse_netmask(netmask)
+ octets = netmask.split(".").map{|i| i.to_i}
+ num = octets.pack("C"*octets.size).unpack("B*").first.count "1"
+ return self.new(num)
+ end
+
+ end # class Prefix32 < Prefix
+
+ class Prefix128 < Prefix
+
+ #
+ # Creates a new prefix object for 128 bits IPv6 addresses
+ #
+ # prefix = IPAddress::Prefix128.new 64
+ # #=> 64
+ #
+ def initialize(num=128)
+ unless (1..128).include? num.to_i
+ raise ArgumentError, "Prefix must be in range 1..128, got: #{num}"
+ end
+ super(num.to_i)
+ end
+
+ #
+ # Transforms the prefix into a string of bits
+ # representing the netmask
+ #
+ # prefix = IPAddress::Prefix128.new 64
+ #
+ # prefix.bits
+ # #=> "1111111111111111111111111111111111111111111111111111111111111111"
+ # "0000000000000000000000000000000000000000000000000000000000000000"
+ #
+ def bits
+ "1" * @prefix + "0" * (128 - @prefix)
+ end
+
+ #
+ # Unsigned 128 bits decimal number representing
+ # the prefix
+ #
+ # prefix = IPAddress::Prefix128.new 64
+ #
+ # prefix.to_u128
+ # #=> 340282366920938463444927863358058659840
+ #
+ def to_u128
+ bits.to_i(2)
+ end
+
+ end # class Prefix123 < Prefix
+
+end # module IPAddress
+
+module IPAddress;
+ #
+ # =Name
+ #
+ # IPAddress::IPv4 - IP version 4 address manipulation library
+ #
+ # =Synopsis
+ #
+ # require 'ipaddress'
+ #
+ # =Description
+ #
+ # Class IPAddress::IPv4 is used to handle IPv4 type addresses.
+ #
+ class IPv4
+
+ include IPAddress
+ include Enumerable
+ include Comparable
+
+ #
+ # This Hash contains the prefix values for Classful networks
+ #
+ # Note that classes C, D and E will all have a default
+ # prefix of /24 or 255.255.255.0
+ #
+ CLASSFUL = {
+ /^0../ => 8, # Class A, from 0.0.0.0 to 127.255.255.255
+ /^10./ => 16, # Class B, from 128.0.0.0 to 191.255.255.255
+ /^110/ => 24 # Class C, D and E, from 192.0.0.0 to 255.255.255.254
+ }
+
+ #
+ # Regular expression to match an IPv4 address
+ #
+ REGEXP = Regexp.new(/((25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)\.){3}(25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)/)
+
+ #
+ # Creates a new IPv4 address object.
+ #
+ # An IPv4 address can be expressed in any of the following forms:
+ #
+ # * "10.1.1.1/24": ip +address+ and +prefix+. This is the common and
+ # suggested way to create an object .
+ # * "10.1.1.1/255.255.255.0": ip +address+ and +netmask+. Although
+ # convenient sometimes, this format is less clear than the previous
+ # one.
+ # * "10.1.1.1": if the address alone is specified, the prefix will be
+ # set as default 32, also known as the host prefix
+ #
+ # Examples:
+ #
+ # # These two are the same
+ # ip = IPAddress::IPv4.new("10.0.0.1/24")
+ # ip = IPAddress("10.0.0.1/24")
+ #
+ # # These two are the same
+ # IPAddress::IPv4.new "10.0.0.1/8"
+ # IPAddress::IPv4.new "10.0.0.1/255.0.0.0"
+ #
+ def initialize(str)
+ ip, netmask = str.split("/")
+
+ # Check the ip and remove white space
+ if IPAddress.valid_ipv4?(ip)
+ @address = ip.strip
+ else
+ raise ArgumentError, "Invalid IP #{ip.inspect}"
+ end
+
+ # Check the netmask
+ if netmask # netmask is defined
+ netmask.strip!
+ if netmask =~ /^\d{1,2}$/ # netmask in cidr format
+ @prefix = Prefix32.new(netmask.to_i)
+ elsif IPAddress.valid_ipv4_netmask?(netmask) # netmask in IP format
+ @prefix = Prefix32.parse_netmask(netmask)
+ else # invalid netmask
+ raise ArgumentError, "Invalid netmask #{netmask}"
+ end
+ else # netmask is nil, reverting to defaul classful mask
+ @prefix = Prefix32.new(32)
+ end
+
+ # Array formed with the IP octets
+ @octets = @address.split(".").map{|i| i.to_i}
+ # 32 bits interger containing the address
+ @u32 = (@octets[0]<< 24) + (@octets[1]<< 16) + (@octets[2]<< 8) + (@octets[3])
+
+ end # def initialize
+
+ #
+ # Returns the address portion of the IPv4 object
+ # as a string.
+ #
+ # ip = IPAddress("172.16.100.4/22")
+ #
+ # ip.address
+ # #=> "172.16.100.4"
+ #
+ def address
+ @address
+ end
+
+ #
+ # Returns the prefix portion of the IPv4 object
+ # as a IPAddress::Prefix32 object
+ #
+ # ip = IPAddress("172.16.100.4/22")
+ #
+ # ip.prefix
+ # #=> 22
+ #
+ # ip.prefix.class
+ # #=> IPAddress::Prefix32
+ #
+ def prefix
+ @prefix
+ end
+
+ #
+ # Set a new prefix number for the object
+ #
+ # This is useful if you want to change the prefix
+ # to an object created with IPv4::parse_u32 or
+ # if the object was created using the classful
+ # mask.
+ #
+ # ip = IPAddress("172.16.100.4")
+ #
+ # puts ip
+ # #=> 172.16.100.4/16
+ #
+ # ip.prefix = 22
+ #
+ # puts ip
+ # #=> 172.16.100.4/22
+ #
+ def prefix=(num)
+ @prefix = Prefix32.new(num)
+ end
+
+ #
+ # Returns the address as an array of decimal values
+ #
+ # ip = IPAddress("172.16.100.4")
+ #
+ # ip.octets
+ # #=> [172, 16, 100, 4]
+ #
+ def octets
+ @octets
+ end
+
+ #
+ # Returns a string with the address portion of
+ # the IPv4 object
+ #
+ # ip = IPAddress("172.16.100.4/22")
+ #
+ # ip.to_s
+ # #=> "172.16.100.4"
+ #
+ def to_s
+ @address
+ end
+
+ #
+ # Returns a string with the IP address in canonical
+ # form.
+ #
+ # ip = IPAddress("172.16.100.4/22")
+ #
+ # ip.to_string
+ # #=> "172.16.100.4/22"
+ #
+ def to_string
+ "#@address/#@prefix"
+ end
+
+ #
+ # Returns the prefix as a string in IP format
+ #
+ # ip = IPAddress("172.16.100.4/22")
+ #
+ # ip.netmask
+ # #=> "255.255.252.0"
+ #
+ def netmask
+ @prefix.to_ip
+ end
+
+ #
+ # Like IPv4#prefix=, this method allow you to
+ # change the prefix / netmask of an IP address
+ # object.
+ #
+ # ip = IPAddress("172.16.100.4")
+ #
+ # puts ip
+ # #=> 172.16.100.4/16
+ #
+ # ip.netmask = "255.255.252.0"
+ #
+ # puts ip
+ # #=> 172.16.100.4/22
+ #
+ def netmask=(addr)
+ @prefix = Prefix32.parse_netmask(addr)
+ end
+
+ #
+ # Returns the address portion in unsigned
+ # 32 bits integer format.
+ #
+ # This method is identical to the C function
+ # inet_pton to create a 32 bits address family
+ # structure.
+ #
+ # ip = IPAddress("10.0.0.0/8")
+ #
+ # ip.to_i
+ # #=> 167772160
+ #
+ def u32
+ @u32
+ end
+ alias_method :to_i, :u32
+ alias_method :to_u32, :u32
+
+ #
+ # Returns the address portion of an IPv4 object
+ # in a network byte order format.
+ #
+ # ip = IPAddress("172.16.10.1/24")
+ #
+ # ip.data
+ # #=> "\254\020\n\001"
+ #
+ # It is usually used to include an IP address
+ # in a data packet to be sent over a socket
+ #
+ # a = Socket.open(params) # socket details here
+ # ip = IPAddress("10.1.1.0/24")
+ # binary_data = ["Address: "].pack("a*") + ip.data
+ #
+ # # Send binary data
+ # a.puts binary_data
+ #
+ def data
+ [@u32].pack("N")
+ end
+
+ #
+ # Returns the octet specified by index
+ #
+ # ip = IPAddress("172.16.100.50/24")
+ #
+ # ip[0]
+ # #=> 172
+ # ip[1]
+ # #=> 16
+ # ip[2]
+ # #=> 100
+ # ip[3]
+ # #=> 50
+ #
+ def [](index)
+ @octets[index]
+ end
+ alias_method :octet, :[]
+
+ #
+ # Returns the address portion of an IP in binary format,
+ # as a string containing a sequence of 0 and 1
+ #
+ # ip = IPAddress("127.0.0.1")
+ #
+ # ip.bits
+ # #=> "01111111000000000000000000000001"
+ #
+ def bits
+ data.unpack("B*").first
+ end
+
+ #
+ # Returns the broadcast address for the given IP.
+ #
+ # ip = IPAddress("172.16.10.64/24")
+ #
+ # ip.broadcast.to_s
+ # #=> "172.16.10.255"
+ #
+ def broadcast
+ self.class.parse_u32(broadcast_u32, @prefix)
+ end
+
+ #
+ # Checks if the IP address is actually a network
+ #
+ # ip = IPAddress("172.16.10.64/24")
+ #
+ # ip.network?
+ # #=> false
+ #
+ # ip = IPAddress("172.16.10.64/26")
+ #
+ # ip.network?
+ # #=> true
+ #
+ def network?
+ @u32 | @prefix.to_u32 == @prefix.to_u32
+ end
+
+ #
+ # Returns a new IPv4 object with the network number
+ # for the given IP.
+ #
+ # ip = IPAddress("172.16.10.64/24")
+ #
+ # ip.network.to_s
+ # #=> "172.16.10.0"
+ #
+ def network
+ self.class.parse_u32(network_u32, @prefix)
+ end
+
+ #
+ # Returns a new IPv4 object with the
+ # first host IP address in the range.
+ #
+ # Example: given the 192.168.100.0/24 network, the first
+ # host IP address is 192.168.100.1.
+ #
+ # ip = IPAddress("192.168.100.0/24")
+ #
+ # ip.first.to_s
+ # #=> "192.168.100.1"
+ #
+ # The object IP doesn't need to be a network: the method
+ # automatically gets the network number from it
+ #
+ # ip = IPAddress("192.168.100.50/24")
+ #
+ # ip.first.to_s
+ # #=> "192.168.100.1"
+ #
+ def first
+ self.class.parse_u32(network_u32+1, @prefix)
+ end
+
+ #
+ # Like its sibling method IPv4#first, this method
+ # returns a new IPv4 object with the
+ # last host IP address in the range.
+ #
+ # Example: given the 192.168.100.0/24 network, the last
+ # host IP address is 192.168.100.254
+ #
+ # ip = IPAddress("192.168.100.0/24")
+ #
+ # ip.last.to_s
+ # #=> "192.168.100.254"
+ #
+ # The object IP doesn't need to be a network: the method
+ # automatically gets the network number from it
+ #
+ # ip = IPAddress("192.168.100.50/24")
+ #
+ # ip.last.to_s
+ # #=> "192.168.100.254"
+ #
+ def last
+ self.class.parse_u32(broadcast_u32-1, @prefix)
+ end
+
+ #
+ # Iterates over all the hosts IP addresses for the given
+ # network (or IP address).
+ #
+ # ip = IPAddress("10.0.0.1/29")
+ #
+ # ip.each_host do |i|
+ # p i.to_s
+ # end
+ # #=> "10.0.0.1"
+ # #=> "10.0.0.2"
+ # #=> "10.0.0.3"
+ # #=> "10.0.0.4"
+ # #=> "10.0.0.5"
+ # #=> "10.0.0.6"
+ #
+ def each_host
+ (network_u32+1..broadcast_u32-1).each do |i|
+ yield self.class.parse_u32(i, @prefix)
+ end
+ end
+
+ #
+ # Iterates over all the IP addresses for the given
+ # network (or IP address).
+ #
+ # The object yielded is a new IPv4 object created
+ # from the iteration.
+ #
+ # ip = IPAddress("10.0.0.1/29")
+ #
+ # ip.each do |i|
+ # p i.address
+ # end
+ # #=> "10.0.0.0"
+ # #=> "10.0.0.1"
+ # #=> "10.0.0.2"
+ # #=> "10.0.0.3"
+ # #=> "10.0.0.4"
+ # #=> "10.0.0.5"
+ # #=> "10.0.0.6"
+ # #=> "10.0.0.7"
+ #
+ def each
+ (network_u32..broadcast_u32).each do |i|
+ yield self.class.parse_u32(i, @prefix)
+ end
+ end
+
+ #
+ # Spaceship operator to compare IP addresses
+ #
+ # An IP address is considered to be minor if it
+ # has a greater prefix (thus smaller hosts
+ # portion) and a smaller u32 value.
+ #
+ # For example, "10.100.100.1/8" is smaller than
+ # "172.16.0.1/16", but it's bigger than "10.100.100.1/16".
+ #
+ # Example:
+ #
+ # ip1 = IPAddress "10.100.100.1/8"
+ # ip2 = IPAddress "172.16.0.1/16"
+ # ip3 = IPAddress "10.100.100.1/16"
+ #
+ # ip1 < ip2
+ # #=> true
+ # ip1 < ip3
+ # #=> false
+ #
+ def <=>(oth)
+ if to_u32 > oth.to_u32
+ return 1
+ elsif to_u32 < oth.to_u32
+ return -1
+ else
+ if prefix < oth.prefix
+ return 1
+ elsif prefix > oth.prefix
+ return -1
+ end
+ end
+ return 0
+ end
+
+ #
+ # Returns the number of IP addresses included
+ # in the network. It also counts the network
+ # address and the broadcast address.
+ #
+ # ip = IPAddress("10.0.0.1/29")
+ #
+ # ip.size
+ # #=> 8
+ #
+ def size
+ 2 ** @prefix.host_prefix
+ end
+
+ #
+ # Returns an array with the IP addresses of
+ # all the hosts in the network.
+ #
+ # ip = IPAddress("10.0.0.1/29")
+ #
+ # ip.hosts.map {|i| i.address}
+ # #=> ["10.0.0.1",
+ # #=> "10.0.0.2",
+ # #=> "10.0.0.3",
+ # #=> "10.0.0.4",
+ # #=> "10.0.0.5",
+ # #=> "10.0.0.6"]
+ #
+ def hosts
+ to_a[1..-2]
+ end
+
+ #
+ # Returns the network number in Unsigned 32bits format
+ #
+ # ip = IPAddress("10.0.0.1/29")
+ #
+ # ip.network_u32
+ # #=> 167772160
+ #
+ def network_u32
+ @u32 & @prefix.to_u32
+ end
+
+ #
+ # Returns the broadcast address in Unsigned 32bits format
+ #
+ # ip = IPaddress("10.0.0.1/29")
+ #
+ # ip.broadcast_u32
+ # #=> 167772167
+ #
+ def broadcast_u32
+ network_u32 + size - 1
+ end
+
+ #
+ # Checks whether a subnet includes the given IP address.
+ #
+ # Accepts an IPAddress::IPv4 object.
+ #
+ # ip = IPAddress("192.168.10.100/24")
+ #
+ # addr = IPAddress("192.168.10.102/24")
+ #
+ # ip.include? addr
+ # #=> true
+ #
+ # ip.include? IPAddress("172.16.0.48/16")
+ # #=> false
+ #
+ def include?(oth)
+ @prefix <= oth.prefix and network_u32 == (oth.to_u32 & @prefix.to_u32)
+ end
+
+ #
+ # Checks whether a subnet includes all the
+ # given IPv4 objects.
+ #
+ # ip = IPAddress("192.168.10.100/24")
+ #
+ # addr1 = IPAddress("192.168.10.102/24")
+ # addr2 = IPAddress("192.168.10.103/24")
+ #
+ # ip.include_all?(addr1,addr2)
+ # #=> true
+ #
+ def include_all?(*others)
+ others.all? {|oth| include?(oth)}
+ end
+
+ #
+ # True if the object is an IPv4 address
+ #
+ # ip = IPAddress("192.168.10.100/24")
+ #
+ # ip.ipv4?
+ # #-> true
+ #
+# def ipv4?
+# true
+# end
+
+ #
+ # True if the object is an IPv6 address
+ #
+ # ip = IPAddress("192.168.10.100/24")
+ #
+ # ip.ipv6?
+ # #-> false
+ #
+# def ipv6?
+# false
+# end
+
+ #
+ # Checks if an IPv4 address objects belongs
+ # to a private network RFC1918
+ #
+ # Example:
+ #
+ # ip = IPAddress "10.1.1.1/24"
+ # ip.private?
+ # #=> true
+ #
+ def private?
+ [self.class.new("10.0.0.0/8"),
+ self.class.new("172.16.0.0/12"),
+ self.class.new("192.168.0.0/16")].any? {|i| i.include? self}
+ end
+
+ #
+ # Returns the IP address in in-addr.arpa format
+ # for DNS lookups
+ #
+ # ip = IPAddress("172.16.100.50/24")
+ #
+ # ip.reverse
+ # #=> "50.100.16.172.in-addr.arpa"
+ #
+ def reverse
+ @octets.reverse.join(".") + ".in-addr.arpa"
+ end
+ alias_method :arpa, :reverse
+
+ #
+ # Subnetting a network
+ #
+ # If the IP Address is a network, it can be divided into
+ # multiple networks. If +self+ is not a network, the
+ # method will calculate the network from the IP and then
+ # subnet it.
+ #
+ # If +subnets+ is an power of two number, the resulting
+ # networks will be divided evenly from the supernet.
+ #
+ # network = IPAddress("172.16.10.0/24")
+ #
+ # network / 4 # implies map{|i| i.to_string}
+ # #=> ["172.16.10.0/26",
+ # "172.16.10.64/26",
+ # "172.16.10.128/26",
+ # "172.16.10.192/26"]
+ #
+ # If +num+ is any other number, the supernet will be
+ # divided into some networks with a even number of hosts and
+ # other networks with the remaining addresses.
+ #
+ # network = IPAddress("172.16.10.0/24")
+ #
+ # network / 3 # implies map{|i| i.to_string}
+ # #=> ["172.16.10.0/26",
+ # "172.16.10.64/26",
+ # "172.16.10.128/25"]
+ #
+ # Returns an array of IPAddress objects
+ #
+ def subnet(subnets=2)
+ unless (1..(2**@prefix.host_prefix)).include? subnets
+ raise ArgumentError, "Value #{subnets} out of range"
+ end
+ calculate_subnets(subnets)
+ end
+ alias_method :/, :subnet
+
+ #
+ # Returns a new IPv4 object from the supernetting
+ # of the instance network.
+ #
+ # Supernetting is similar to subnetting, except
+ # that you getting as a result a network with a
+ # smaller prefix (bigger host space). For example,
+ # given the network
+ #
+ # ip = IPAddress("172.16.10.0/24")
+ #
+ # you can supernet it with a new /23 prefix
+ #
+ # ip.supernet(23).to_string
+ # #=> "172.16.10.0/23"
+ #
+ # However if you supernet it with a /22 prefix, the
+ # network address will change:
+ #
+ # ip.supernet(22).to_string
+ # #=> "172.16.8.0/22"
+ #
+ def supernet(new_prefix)
+ raise ArgumentError, "Can't supernet a /1 network" if new_prefix < 1
+ raise ArgumentError, "New prefix must be smaller than existing prefix" if new_prefix >= @prefix.to_i
+ self.class.new(@address+"/#{new_prefix}").network
+ end
+
+ #
+ # Returns the difference between two IP addresses
+ # in unsigned int 32 bits format
+ #
+ # Example:
+ #
+ # ip1 = IPAddress("172.16.10.0/24")
+ # ip2 = IPAddress("172.16.11.0/24")
+ #
+ # puts ip1 - ip2
+ # #=> 256
+ #
+ def -(oth)
+ return (to_u32 - oth.to_u32).abs
+ end
+
+ #
+ # Returns a new IPv4 object which is the result
+ # of the summarization, if possible, of the two
+ # objects
+ #
+ # Example:
+ #
+ # ip1 = IPAddress("172.16.10.1/24")
+ # ip2 = IPAddress("172.16.11.2/24")
+ #
+ # p (ip1 + ip2).map {|i| i.to_string}
+ # #=> ["172.16.10.0/23"]
+ #
+ # If the networks are not contiguous, returns
+ # the two network numbers from the objects
+ #
+ # ip1 = IPAddress("10.0.0.1/24")
+ # ip2 = IPAddress("10.0.2.1/24")
+ #
+ # p (ip1 + ip2).map {|i| i.to_string}
+ # #=> ["10.0.0.0/24","10.0.2.0/24"]
+ #
+ def +(oth)
+ aggregate(*[self,oth].sort.map{|i| i.network})
+ end
+
+ #
+ # Checks whether the ip address belongs to a
+ # RFC 791 CLASS A network, no matter
+ # what the subnet mask is.
+ #
+ # Example:
+ #
+ # ip = IPAddress("10.0.0.1/24")
+ #
+ # ip.a?
+ # #=> true
+ #
+ def a?
+ CLASSFUL.key(8) === bits
+ end
+
+ #
+ # Checks whether the ip address belongs to a
+ # RFC 791 CLASS B network, no matter
+ # what the subnet mask is.
+ #
+ # Example:
+ #
+ # ip = IPAddress("172.16.10.1/24")
+ #
+ # ip.b?
+ # #=> true
+ #
+ def b?
+ CLASSFUL.key(16) === bits
+ end
+
+ #
+ # Checks whether the ip address belongs to a
+ # RFC 791 CLASS C network, no matter
+ # what the subnet mask is.
+ #
+ # Example:
+ #
+ # ip = IPAddress("192.168.1.1/30")
+ #
+ # ip.c?
+ # #=> true
+ #
+ def c?
+ CLASSFUL.key(24) === bits
+ end
+
+ #
+ # Return the ip address in a format compatible
+ # with the IPv6 Mapped IPv4 addresses
+ #
+ # Example:
+ #
+ # ip = IPAddress("172.16.10.1/24")
+ #
+ # ip.to_ipv6
+ # #=> "ac10:0a01"
+ #
+ def to_ipv6
+ "%.4x:%.4x" % [to_u32].pack("N").unpack("nn")
+ end
+
+ #
+ # Creates a new IPv4 object from an
+ # unsigned 32bits integer.
+ #
+ # ip = IPAddress::IPv4::parse_u32(167772160)
+ #
+ # ip.prefix = 8
+ # ip.to_string
+ # #=> "10.0.0.0/8"
+ #
+ # The +prefix+ parameter is optional:
+ #
+ # ip = IPAddress::IPv4::parse_u32(167772160, 8)
+ #
+ # ip.to_string
+ # #=> "10.0.0.0/8"
+ #
+ def self.parse_u32(u32, prefix=32)
+ self.new([u32].pack("N").unpack("C4").join(".")+"/#{prefix}")
+ end
+
+ #
+ # Creates a new IPv4 object from binary data,
+ # like the one you get from a network stream.
+ #
+ # For example, on a network stream the IP 172.16.0.1
+ # is represented with the binary "\254\020\n\001".
+ #
+ # ip = IPAddress::IPv4::parse_data "\254\020\n\001"
+ # ip.prefix = 24
+ #
+ # ip.to_string
+ # #=> "172.16.10.1/24"
+ #
+ def self.parse_data(str, prefix=32)
+ self.new(str.unpack("C4").join(".")+"/#{prefix}")
+ end
+
+ #
+ # Extract an IPv4 address from a string and
+ # returns a new object
+ #
+ # Example:
+ #
+ # str = "foobar172.16.10.1barbaz"
+ # ip = IPAddress::IPv4::extract str
+ #
+ # ip.to_s
+ # #=> "172.16.10.1"
+ #
+ def self.extract(str)
+ self.new REGEXP.match(str).to_s
+ end
+
+ #
+ # Summarization (or aggregation) is the process when two or more
+ # networks are taken together to check if a supernet, including all
+ # and only these networks, exists. If it exists then this supernet
+ # is called the summarized (or aggregated) network.
+ #
+ # It is very important to understand that summarization can only
+ # occur if there are no holes in the aggregated network, or, in other
+ # words, if the given networks fill completely the address space
+ # of the supernet. So the two rules are:
+ #
+ # 1) The aggregate network must contain +all+ the IP addresses of the
+ # original networks;
+ # 2) The aggregate network must contain +only+ the IP addresses of the
+ # original networks;
+ #
+ # A few examples will help clarify the above. Let's consider for
+ # instance the following two networks:
+ #
+ # ip1 = IPAddress("172.16.10.0/24")
+ # ip2 = IPAddress("172.16.11.0/24")
+ #
+ # These two networks can be expressed using only one IP address
+ # network if we change the prefix. Let Ruby do the work:
+ #
+ # IPAddress::IPv4::summarize(ip1,ip2).to_s
+ # #=> "172.16.10.0/23"
+ #
+ # We note how the network "172.16.10.0/23" includes all the addresses
+ # specified in the above networks, and (more important) includes
+ # ONLY those addresses.
+ #
+ # If we summarized +ip1+ and +ip2+ with the following network:
+ #
+ # "172.16.0.0/16"
+ #
+ # we would have satisfied rule #1 above, but not rule #2. So "172.16.0.0/16"
+ # is not an aggregate network for +ip1+ and +ip2+.
+ #
+ # If it's not possible to compute a single aggregated network for all the
+ # original networks, the method returns an array with all the aggregate
+ # networks found. For example, the following four networks can be
+ # aggregated in a single /22:
+ #
+ # ip1 = IPAddress("10.0.0.1/24")
+ # ip2 = IPAddress("10.0.1.1/24")
+ # ip3 = IPAddress("10.0.2.1/24")
+ # ip4 = IPAddress("10.0.3.1/24")
+ #
+ # IPAddress::IPv4::summarize(ip1,ip2,ip3,ip4).to_string
+ # #=> "10.0.0.0/22",
+ #
+ # But the following networks can't be summarized in a single network:
+ #
+ # ip1 = IPAddress("10.0.1.1/24")
+ # ip2 = IPAddress("10.0.2.1/24")
+ # ip3 = IPAddress("10.0.3.1/24")
+ # ip4 = IPAddress("10.0.4.1/24")
+ #
+ # IPAddress::IPv4::summarize(ip1,ip2,ip3,ip4).map{|i| i.to_string}
+ # #=> ["10.0.1.0/24","10.0.2.0/23","10.0.4.0/24"]
+ #
+ def self.summarize(*args)
+ # one network? no need to summarize
+ return [args.first.network] if args.size == 1
+
+ i = 0
+ result = args.dup.sort.map{|ip| ip.network}
+ while i < result.size-1
+ sum = result[i] + result[i+1]
+ result[i..i+1] = sum.first if sum.size == 1
+ i += 1
+ end
+
+ result.flatten!
+ if result.size == args.size
+ # nothing more to summarize
+ return result
+ else
+ # keep on summarizing
+ return self.summarize(*result)
+ end
+ end
+
+ #
+ # Creates a new IPv4 address object by parsing the
+ # address in a classful way.
+ #
+ # Classful addresses have a fixed netmask based on the
+ # class they belong to:
+ #
+ # * Class A, from 0.0.0.0 to 127.255.255.255
+ # * Class B, from 128.0.0.0 to 191.255.255.255
+ # * Class C, D and E, from 192.0.0.0 to 255.255.255.254
+ #
+ # Note that classes C, D and E will all have a default
+ # prefix of /24 or 255.255.255.0
+ #
+ # Example:
+ #
+ # ip = IPAddress::IPv4.parse_classful "10.0.0.1"
+ #
+ # ip.netmask
+ # #=> "255.0.0.0"
+ # ip.a?
+ # #=> true
+ #
+ def self.parse_classful(ip)
+ if IPAddress.valid_ipv4?(ip)
+ address = ip.strip
+ else
+ raise ArgumentError, "Invalid IP #{ip.inspect}"
+ end
+ prefix = CLASSFUL.find{|h,k| h === ("%.8b" % address.to_i)}.last
+ self.new "#{address}/#{prefix}"
+ end
+
+ #
+ # private methods
+ #
+ private
+
+ def calculate_subnets(subnets)
+ po2 = closest_power_of_2(subnets)
+ new_prefix = @prefix + log2(po2).to_i
+ networks = Array.new
+ (0..po2-1).each do |i|
+ mul = i * (2**(32-new_prefix))
+ networks << IPAddress::IPv4.parse_u32(network_u32+mul, new_prefix)
+ end
+ until networks.size == subnets
+ networks = sum_first_found(networks)
+ end
+ return networks
+ end
+
+ def sum_first_found(arr)
+ dup = arr.dup.reverse
+ dup.each_with_index do |obj,i|
+ a = [IPAddress::IPv4.summarize(obj,dup[i+1])].flatten
+ if a.size == 1
+ dup[i..i+1] = a
+ return dup.reverse
+ end
+ end
+ return dup.reverse
+ end
+
+ def aggregate(ip1,ip2)
+ return [ip1] if ip1.include? ip2
+
+ snet = ip1.supernet(ip1.prefix-1)
+ if snet.include_all?(ip1, ip2) && ((ip1.size + ip2.size) == snet.size)
+ return [snet]
+ else
+ return [ip1, ip2]
+ end
+ end
+
+ def log2(n); Math::log(n) / Math::log(2); end
+
+ def power_of_2?(int)
+ log2(int).to_i == log2(int)
+ end
+
+ def closest_power_of_2(int, limit=32)
+ int.upto(limit) do |i|
+ return i if power_of_2?(i)
+ end
+ end
+
+ end # class IPv4
+end # module IPAddress
+
+module IPAddress;
+ #
+ # =Name
+ #
+ # IPAddress::IPv6 - IP version 6 address manipulation library
+ #
+ # =Synopsis
+ #
+ # require 'ipaddress'
+ #
+ # =Description
+ #
+ # Class IPAddress::IPv6 is used to handle IPv6 type addresses.
+ #
+ # == IPv6 addresses
+ #
+ # IPv6 addresses are 128 bits long, in contrast with IPv4 addresses
+ # which are only 32 bits long. An IPv6 address is generally written as
+ # eight groups of four hexadecimal digits, each group representing 16
+ # bits or two octect. For example, the following is a valid IPv6
+ # address:
+ #
+ # 1080:0000:0000:0000:0008:0800:200c:417a
+ #
+ # Letters in an IPv6 address are usually written downcase, as per
+ # RFC. You can create a new IPv6 object using uppercase letters, but
+ # they will be converted.
+ #
+ # === Compression
+ #
+ # Since IPv6 addresses are very long to write, there are some
+ # semplifications and compressions that you can use to shorten them.
+ #
+ # * Leading zeroes: all the leading zeroes within a group can be
+ # omitted: "0008" would become "8"
+ #
+ # * A string of consecutive zeroes can be replaced by the string
+ # "::". This can be only applied once.
+ #
+ # Using compression, the IPv6 address written above can be shorten into
+ # the following, equivalent, address
+ #
+ # 1080::8:800:200c:417a
+ #
+ # This short version is often used in human representation.
+ #
+ # === Network Mask
+ #
+ # As we used to do with IPv4 addresses, an IPv6 address can be written
+ # using the prefix notation to specify the subnet mask:
+ #
+ # 1080::8:800:200c:417a/64
+ #
+ # The /64 part means that the first 64 bits of the address are
+ # representing the network portion, and the last 64 bits are the host
+ # portion.
+ #
+ #
+ class IPv6
+
+ include IPAddress
+ include Enumerable
+ include Comparable
+
+
+ #
+ # Format string to pretty print IPv6 addresses
+ #
+ IN6FORMAT = ("%.4x:"*8).chop
+
+ #
+ # Creates a new IPv6 address object.
+ #
+ # An IPv6 address can be expressed in any of the following forms:
+ #
+ # * "1080:0000:0000:0000:0008:0800:200C:417A": IPv6 address with no compression
+ # * "1080:0:0:0:8:800:200C:417A": IPv6 address with leading zeros compression
+ # * "1080::8:800:200C:417A": IPv6 address with full compression
+ #
+ # In all these 3 cases, a new IPv6 address object will be created, using the default
+ # subnet mask /128
+ #
+ # You can also specify the subnet mask as with IPv4 addresses:
+ #
+ # ip6 = IPAddress "2001:db8::8:800:200c:417a/64"
+ #
+ def initialize(str)
+ ip, netmask = str.split("/")
+
+ if str =~ /:.+\./
+ raise ArgumentError, "Please use #{self.class}::Mapped for IPv4 mapped addresses"
+ end
+
+ if IPAddress.valid_ipv6?(ip)
+ @groups = self.class.groups(ip)
+ @address = IN6FORMAT % @groups
+ @compressed = compress_address
+ else
+ raise ArgumentError, "Invalid IP #{ip.inspect}"
+ end
+
+ @prefix = Prefix128.new(netmask ? netmask : 128)
+
+ end # def initialize
+
+ #
+ # Returns the IPv6 address in uncompressed form:
+ #
+ # ip6 = IPAddress "2001:db8::8:800:200c:417a/64"
+ #
+ # ip6.address
+ # #=> "2001:0db8:0000:0000:0008:0800:200c:417a"
+ #
+ def address
+ @address
+ end
+
+ #
+ # Returns an array with the 16 bits groups in decimal
+ # format:
+ #
+ # ip6 = IPAddress "2001:db8::8:800:200c:417a/64"
+ #
+ # ip6.groups
+ # #=> [8193, 3512, 0, 0, 8, 2048, 8204, 16762]
+ #
+ def groups
+ @groups
+ end
+
+ #
+ # Returns an instance of the prefix object
+ #
+ # ip6 = IPAddress "2001:db8::8:800:200c:417a/64"
+ #
+ # ip6.prefix
+ # #=> 64
+ #
+ def prefix
+ @prefix
+ end
+
+ #
+ # Set a new prefix number for the object
+ #
+ # This is useful if you want to change the prefix
+ # to an object created with IPv6::parse_u128 or
+ # if the object was created using the default prefix
+ # of 128 bits.
+ #
+ # ip6 = IPAddress("2001:db8::8:800:200c:417a")
+ #
+ # puts ip6.to_string
+ # #=> "2001:db8::8:800:200c:417a/128"
+ #
+ # ip6.prefix = 64
+ # puts ip6.to_string
+ # #=> "2001:db8::8:800:200c:417a/64"
+ #
+ def prefix=(num)
+ @prefix = Prefix128.new(num)
+ end
+
+ #
+ # Unlike its counterpart IPv6#to_string method, IPv6#to_string_uncompressed
+ # returns the whole IPv6 address and prefix in an uncompressed form
+ #
+ # ip6 = IPAddress "2001:db8::8:800:200c:417a/64"
+ #
+ # ip6.to_string_uncompressed
+ # #=> "2001:0db8:0000:0000:0008:0800:200c:417a/64"
+ #
+ def to_string_uncompressed
+ "#@address/#@prefix"
+ end
+
+ #
+ # Returns the IPv6 address in a human readable form,
+ # using the compressed address.
+ #
+ # ip6 = IPAddress "2001:0db8:0000:0000:0008:0800:200c:417a/64"
+ #
+ # ip6.to_string
+ # #=> "2001:db8::8:800:200c:417a/64"
+ #
+ def to_string
+ "#@compressed/#@prefix"
+ end
+
+ #
+ # Returns the IPv6 address in a human readable form,
+ # using the compressed address.
+ #
+ # ip6 = IPAddress "2001:db8::8:800:200c:417a/64"
+ #
+ # ip6.to_s
+ # #=> "2001:db8::8:800:200c:417a"
+ #
+ def to_s
+ @compressed
+ end
+
+ #
+ # Returns a decimal format (unsigned 128 bit) of the
+ # IPv6 address
+ #
+ # ip6 = IPAddress "2001:db8::8:800:200c:417a/64"
+ #
+ # ip6.to_i
+ # #=> 42540766411282592856906245548098208122
+ #
+ def to_i
+ to_hex.hex
+ end
+ alias_method :to_u128, :to_i
+
+ #
+ # True if the IPv6 address is a network
+ #
+ # ip6 = IPAddress "2001:db8::8:800:200c:417a/64"
+ #
+ # ip6.network?
+ # #=> false
+ #
+ # ip6 = IPAddress "2001:db8:8:800::/64"
+ #
+ # ip6.network?
+ # #=> true
+ #
+ def network?
+ to_u128 | @prefix.to_u128 == @prefix.to_u128
+ end
+
+ #
+ # Returns the 16-bits value specified by index
+ #
+ # ip = IPAddress("2001:db8::8:800:200c:417a/64")
+ #
+ # ip[0]
+ # #=> 8193
+ # ip[1]
+ # #=> 3512
+ # ip[2]
+ # #=> 0
+ # ip[3]
+ # #=> 0
+ #
+ def [](index)
+ @groups[index]
+ end
+ alias_method :group, :[]
+
+ #
+ # Returns a Base16 number representing the IPv6
+ # address
+ #
+ # ip6 = IPAddress "2001:db8::8:800:200c:417a/64"
+ #
+ # ip6.to_hex