Skip to content
A library to handle IP (both IPv4 and IPv6) addresses in a modern and productive way.
Find file
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Failed to load latest commit information.



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.


  • 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.

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

Moreover, many methods and procedures are so old that they have been declared deprecated by the IETF.

We hope that IPAddress will address all these issues and meet all your needs in network programming.


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://

And then install the library

$ cd ipaddress
ipaddress$ rake install


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


In this section I will illustrate how to use the IPAddress library through some examples of common tasks.


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, and a prefix, such as 24, separated by a slash.

To create a new IPv4 object, you can use IPv4 own class

ip = ""

or, in a easier way, using the IPAddress wrapper method

ip = IPAddress ""

You can specify an IPv4 address in any of two ways:

IPAddress ""
IPAddress ""

In this example, prefix /24 and netmask are the same and you have the flexibility to use either one of them.

Classful networks

If you don't specify a prefix (or a subnet mask), then the library will create an object base on the CLASSFUL network from the given IP. Remember the CLASSFUL network are the following (RFC 791)

  • Class A, from to

  • Class B, from to

  • Class C, from to

Since classful networks here are only considered to calculate the default prefix number, classes D and E are not considered.

You can easily check which CLASSFUL network the IP belongs:

ip = IPAddress("")
  #=> true

ip = IPAddress("")
  #=> true

ip = IPAddress("")
  #=> true

These methods are only checking the address portion of an IP, and are indipendent from its prefix.

For more information on CLASSFUL networks visit the Wikipedia page

Handling the IPv4 address

Once created, you can obtain the attributes for an IPv4 object:

ip = IPAddress("")

  #=> ""
  #=> 24

In case you need to retrieve the netmask in IPv4 format, you can use the IPv4#netmask method:

  #=> ""

A special attribute, IPv4#octets, is available to get the four decimal octets from the IP address:

  #=> [172,16,10,1]

Shortcut method IPv4#[], provides access to a given octet whithin the range:

  #=> 16

If you need to print out the IPv4 address in a canonical form, you can use IPv4#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

  #=> "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 = ""

  #=> ""

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 “”, you are actually handling two different information:

  • The IP address itself, “”

  • 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 “” belongs to network “”.

This is very important because, for instance, IP “” is very different to the previous one, belonging to the very different network “”.


With IPAddress it's very easy to calculate the network for an IP address:

ip = IPAddress ""

net =
  #=> #<IPAddress::IPv4:0xb7a5ab24 @octets=[172, 16, 10, 0], 
  #=> ""

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 ""
ip2 = IPAddress ""
  #=> false
  #=> true

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 “” has broadcast “”, where ip “” has broadcast “”.

Method IPv4#broadcast has the same behaviour as is #network counterpart: it creates a new IPv4 object to handle the broadcast address:

ip = IPAddress ""

bcast = ip.broadcast
  #=> #<IPAddress::IPv4:0xb7a406fc @octets=[172, 16, 10, 255],
  #=> ""
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 ""

ip.each do |addr|
  puts addr

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 ""

ip.each_host do |host|
  puts host

Methods IPv4#first and IPv4#last return a new object containing respectively the first and the last host address in the range

ip = IPAddress ""

  #=> ""

  #=> ""

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 ""

  #=> ""

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:

  #=> "10101100000100000000101000000001"

To calculate the 32 bits unsigned int format of the ip address, use the IPv4#to_u32 method

  #=> 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 trasmit your IP over a network socket, you might need to transform it in data format using the IPv4#data method:
  #=> "\254\020\n\001"

Finally, you can transform an IPv4 address into a format which is suitable to use in IPv4-IPv6 mapped addresses:

  #=> "ac10:0a01"

Network design with IPAddress

IPAddress includes a lot of useful methods to manipulate IPv4 and IPv6 networks and do some basic network design.


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 “”, 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("")

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] [...]]{|i| i.to_string}
  #=> ["", "", "", 

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("")

ip.subnet(4).map{|i| i.to_string}
  #=> ["", "", "",

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 divived 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 into 3 different subnets:

network = IPAddress("")

network.subnet(3).map{|i| i.to_string}
  #=> ["",

We can go even further and divide into 11 subnets:

network = IPAddress("")

network.subnet(11).map{|i| i.to_string}
  #=> ["", "", "",
       "", "", "",
       "", "", "",
       "", ""]

As you can see, most of the networks are /28, with a few /27 and one /26 to fill up the remaning space.


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("")
ip2 = IPAddress("")

These two networks can be expressed using only one IP address network if we change the prefix. Let Ruby do the work:

  #=> ""

We note how the network “” 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:


we would have satisfied rule #1 above, but not rule #2. So


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("")
ip2 = IPAddress("")
ip3 = IPAddress("")
ip4 = IPAddress("")

IPAddress::IPv4::summarize(ip1,ip2,ip3,ip4).map{|i| i.to_string}
  #=> [""]

But the following networks can't be summarized in a single network:

ip1 = IPAddress("")
ip2 = IPAddress("")
ip3 = IPAddress("")
ip4 = IPAddress("")

IPAddress::IPv4::summarize(ip1,ip2,ip3,ip4).map{|i| i.to_string}
  #=> ["","",""]

In this case, the two summarizables networks have been aggregated into a single /23, while the other two networks have been left untouched.


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("")

you can supernet it with a new /23 prefix

  #=> ""

However if you supernet it with a /22 prefix, the network address will change:

  #=> ""

This is because “” is not a network anymore, but an host address.


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 octect. For example, the following is a valid IPv6 address:


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.


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


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:


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"

  #=> "2001:0db8:0000:0000:0008:0800:200c:417a"

  #=> 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"

  #=> "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"

  #=> [8193, 3512, 0, 0, 8, 2048, 8204, 16762]

As with IPv4 addresses, each individual group can be accessed using the IPv6#[] shortcut method:

  #=> 8193
  #=> 3512
  #=> 0
  #=> 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:

  #=> => ["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

  #=> 42540766411282592856906245548098208122

or to hexadecimal representation

  #=> "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"

  #=> "2001:db8::8:800:200c:417a/96"

  #=> "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

  #=> "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

  #=> "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

  #=> "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 builtin support for unspecified, loopback and mapped IPv6 addresses.

Unspecified address

The address with all zero bits is called the unspecified address (corresponding to in IPv4). It should be something like this:


but, with the use of compression, it is usually written as just two colons:


or, specifying the netmask:


With IPAddress, create a new unspecified IPv6 address using its own subclass:

ip =

  #=> "::/128"

You can easily check if an IPv6 object is an unspecified address by using the IPv6#unspecified? method

  #=> true

An unspecified IPv6 address can also be created with the wrapper method, like we've seen before

ip = IPAddress "::"

  #=> 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:


or, with their appropriate prefix,


As for the unspecified addresses, IPv6 loopbacks can be created with IPAddress calling their own class:

ip =

  #=> "::1/128"

or by using the wrapper:

ip = IPAddress "::1"

  #=> "::1/128"

Checking if an address is loopback is easy with the IPv6#loopback? method:

  #=> true

The IPv6 loopback address corresponds to 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


where w.x.y.z is a normal IPv4 address. For example, the following is a mapped IPv6 address:


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 = "::ffff:"

or just use the wrapper method

ip6 = IPAddress "::ffff:"

Let's check it's really a mapped address:

  #=> true

  #=> "::ffff:"

Now with the ipv4 attribute, we can easily access the IPv4 portion of the mapped IPv6 address:

  #=> ""

Internally, the IPv4 address is stored as two 16 bits groups. Therefore all the usual methods for an IPv6 address are working perfectly fine:

  #=> "00000000000000000000ffffac100a01"

  #=> "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 "::"

That is, two colons and the IPv4 address. However, as by RFC, the ffff group will be automatically added at the beginning

  => "::ffff:"

making it a mapped IPv6 compatible address.


Want to join the community?

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 and Steve Rawlinson for their support, feedback and bug reports.


Copyright © 2009-2010 Marco Ceresa. See LICENSE for details.

Something went wrong with that request. Please try again.