Struct ipaddress::IPAddress
[−]
[src]
pub struct IPAddress { pub ip_bits: &'static IpBits, pub host_address: BigUint, pub prefix: Prefix, pub mapped: Option<Box<IPAddress>>, pub vt_is_private: fn(_: &IPAddress) -> bool, pub vt_is_loopback: fn(_: &IPAddress) -> bool, pub vt_to_ipv6: fn(_: &IPAddress) -> IPAddress, }
Fields
ip_bits: &'static IpBits
host_address: BigUint
prefix: Prefix
mapped: Option<Box<IPAddress>>
vt_is_private: fn(_: &IPAddress) -> bool
vt_is_loopback: fn(_: &IPAddress) -> bool
vt_to_ipv6: fn(_: &IPAddress) -> IPAddress
Methods
impl IPAddress
[src]
fn parse<S: Into<String>>(_str: S) -> Result<IPAddress, String>
[src]
Parse the argument string to create a new IPv4, IPv6 or Mapped IP object
ip = IPAddress.parse "172.16.10.1/24" ip6 = IPAddress.parse "2001:db8::8:800:200c:417a/64" ip_mapped = IPAddress.parse "::ffff:172.16.10.1/128"
All the object created will be instances of the correct class:
ip.class //=> IPAddress::IPv4 ip6.class //=> IPAddress::IPv6 ip_mapped.class //=> IPAddress::IPv6::Mapped
fn split_at_slash(str: &String) -> (String, Option<String>)
[src]
fn from(&self, addr: &BigUint, prefix: &Prefix) -> IPAddress
[src]
fn is_ipv4(&self) -> bool
[src]
True if the object is an IPv4 address
ip = IPAddress("192.168.10.100/24")
ip.ipv4? //-> true
fn is_ipv6(&self) -> bool
[src]
True if the object is an IPv6 address
ip = IPAddress("192.168.10.100/24")
ip.ipv6? //-> false
fn is_valid<S: Into<String>>(_addr: S) -> bool
[src]
Checks if the given string is a valid IP address, either IPv4 or IPv6
Example:
IPAddress::valid? "2002::1" //=> true
IPAddress::valid? "10.0.0.256" //=> false
fn parse_ipv4_part(i: &str, addr: &String) -> Result<u32, String>
[src]
Checks if the given string is a valid IPv4 address
Example:
IPAddress::valid_ipv4? "2002::1" //=> false
IPAddress::valid_ipv4? "172.16.10.1" //=> true
fn split_to_u32(addr: &String) -> Result<u32, String>
[src]
fn is_valid_ipv4<S: Into<String>>(addr: S) -> bool
[src]
fn split_on_colon(addr: &String) -> (Result<BigUint, String>, usize)
[src]
Checks if the given string is a valid IPv6 address
Example:
IPAddress::valid_ipv6? "2002::1" //=> true
IPAddress::valid_ipv6? "2002::DEAD::BEEF" // => false
fn split_to_num(addr: &String) -> Result<BigUint, String>
[src]
fn is_valid_ipv6<S: Into<String>>(addr: S) -> bool
[src]
fn aggregate(networks: &Vec<IPAddress>) -> Vec<IPAddress>
[src]
fn parts(&self) -> Vec<u16>
[src]
fn parts_hex_str(&self) -> Vec<String>
[src]
fn dns_rev_domains(&self) -> Vec<String>
[src]
Returns the IP address in in-addr.arpa format for DNS Domain definition entries like SOA Records
ip = IPAddress("172.17.100.50/15")
ip.dns_rev_domains // => ["16.172.in-addr.arpa","17.172.in-addr.arpa"]
fn dns_reverse(&self) -> String
[src]
fn dns_parts(&self) -> Vec<u8>
[src]
fn dns_networks(&self) -> Vec<IPAddress>
[src]
fn summarize(networks: &Vec<IPAddress>) -> Vec<IPAddress>
[src]
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"]
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("2000:0::4/32") ip2 = IPAddress("2000:1::6/32")
These two networks can be expressed using only one IP address network if we change the prefix. Let Ruby do the work:
IPAddress::IPv6::summarize(ip1,ip2).to_s /// "2000:0::/31"
We note how the network "2000:0::/31" 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:
"2000::/16"
we would have satisfied rule /// 1 above, but not rule /// 2. So "2000::/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("2000:0::/32") ip2 = IPAddress("2000:1::/32") ip3 = IPAddress("2000:2::/32") ip4 = IPAddress("2000:3::/32")
IPAddress::IPv6::summarize(ip1,ip2,ip3,ip4).to_string /// ""2000:3::/30",
But the following networks can't be summarized in a single network:
ip1 = IPAddress("2000:1::/32") ip2 = IPAddress("2000:2::/32") ip3 = IPAddress("2000:3::/32") ip4 = IPAddress("2000:4::/32")
IPAddress::IPv4::summarize(ip1,ip2,ip3,ip4).map{|i| i.to_string} /// ["2000:1::/32","2000:2::/31","2000:4::/32"]
fn summarize_str<S: Into<String>>(
netstr: Vec<S>
) -> Result<Vec<IPAddress>, String>
[src]
netstr: Vec<S>
) -> Result<Vec<IPAddress>, String>
fn ip_same_kind(&self, oth: &IPAddress) -> bool
[src]
fn is_unspecified(&self) -> bool
[src]
Returns true if the address is an unspecified address
See IPAddress::IPv6::Unspecified for more information
fn is_loopback(&self) -> bool
[src]
Returns true if the address is a loopback address
See IPAddress::IPv6::Loopback for more information
fn is_mapped(&self) -> bool
[src]
Returns true if the address is a mapped address
See IPAddress::IPv6::Mapped for more information
fn prefix(&self) -> &Prefix
[src]
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
fn is_valid_netmask<S: Into<String>>(addr: S) -> bool
[src]
Checks if the argument is a valid IPv4 netmask expressed in dotted decimal format.
IPAddress.valid_ipv4_netmask? "255.255.0.0" /// true
fn netmask_to_prefix(nm: &BigUint, bits: usize) -> Result<usize, String>
[src]
fn parse_netmask_to_prefix<S: Into<String>>(
_netmask: S
) -> Result<usize, String>
[src]
_netmask: S
) -> Result<usize, String>
fn change_prefix(&self, num: usize) -> Result<IPAddress, String>
[src]
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
fn change_netmask<S: Into<String>>(&self, str: S) -> Result<IPAddress, String>
[src]
fn to_string(&self) -> String
[src]
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"
fn to_s(&self) -> String
[src]
fn to_string_uncompressed(&self) -> String
[src]
fn to_s_uncompressed(&self) -> String
[src]
fn to_s_mapped(&self) -> String
[src]
fn to_string_mapped(&self) -> String
[src]
fn bits(&self) -> String
[src]
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"
fn to_hex(&self) -> String
[src]
fn netmask(&self) -> IPAddress
[src]
fn broadcast(&self) -> IPAddress
[src]
Returns the broadcast address for the given IP.
ip = IPAddress("172.16.10.64/24")
ip.broadcast.to_s /// "172.16.10.255"
fn is_network(&self) -> bool
[src]
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
fn network(&self) -> IPAddress
[src]
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"
fn to_network(adr: &BigUint, host_prefix: usize) -> BigUint
[src]
fn sub(&self, other: &IPAddress) -> BigUint
[src]
fn add(&self, other: &IPAddress) -> Vec<IPAddress>
[src]
fn to_s_vec(vec: &Vec<IPAddress>) -> Vec<String>
[src]
fn to_string_vec(vec: &Vec<IPAddress>) -> Vec<String>
[src]
fn to_ipaddress_vec<S: Into<String>>(
vec: Vec<S>
) -> Result<Vec<IPAddress>, String>
[src]
vec: Vec<S>
) -> Result<Vec<IPAddress>, String>
fn first(&self) -> IPAddress
[src]
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"
fn last(&self) -> IPAddress
[src]
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"
fn each_host<F>(&self, func: F) where
F: Fn(&IPAddress),
[src]
F: Fn(&IPAddress),
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"
fn each<F>(&self, func: F) where
F: Fn(&IPAddress),
[src]
F: Fn(&IPAddress),
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"
fn size(&self) -> BigUint
[src]
Spaceship operator to compare IPv4 objects
Comparing IPv4 addresses is useful to ordinate them into lists that match our intuitive perception of ordered IP addresses.
The first comparison criteria is the u32 value. For example, 10.100.100.1 will be considered to be less than 172.16.0.1, because, in a ordered list, we expect 10.100.100.1 to come before 172.16.0.1.
The second criteria, in case two IPv4 objects have identical addresses, is the prefix. An higher prefix will be considered greater than a lower prefix. This is because we expect to see 10.100.100.0/24 come before 10.100.100.0/25.
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
[ip1,ip2,ip3].sort.map{|i| i.to_string} /// ["10.100.100.1/8","10.100.100.1/16","172.16.0.1/16"]
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
fn is_same_kind(&self, oth: &IPAddress) -> bool
[src]
fn includes(&self, oth: &IPAddress) -> bool
[src]
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
fn includes_all(&self, oths: &[IPAddress]) -> bool
[src]
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
fn is_private(&self) -> bool
[src]
Checks if an IPv4 address objects belongs to a private network RFC1918
Example:
ip = IPAddress "10.1.1.1/24" ip.private? /// true
fn split(&self, subnets: usize) -> Result<Vec<IPAddress>, String>
[src]
fn supernet(&self, new_prefix: usize) -> Result<IPAddress, String>
[src]
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"
If +new_prefix+ is less than 1, returns 0.0.0.0/0
fn subnet(&self, subprefix: usize) -> Result<Vec<IPAddress>, String>
[src]
This method implements the subnetting function similar to the one described in RFC3531.
By specifying a new prefix, the method calculates the network number for the given IPv4 object and calculates the subnets associated to the new prefix.
For example, given the following network:
ip = IPAddress "172.16.10.0/24"
we can calculate the subnets with a /26 prefix
ip.subnets(26).map(&:to_string) /// ["172.16.10.0/26", "172.16.10.64/26", "172.16.10.128/26", "172.16.10.192/26"]
The resulting number of subnets will of course always be a power of two.
fn to_ipv6(&self) -> IPAddress
[src]
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"
Trait Implementations
impl Debug for IPAddress
[src]
impl Clone for IPAddress
[src]
fn clone(&self) -> IPAddress
[src]
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0[src]
Performs copy-assignment from source
. Read more
impl Ord for IPAddress
[src]
fn cmp(&self, oth: &IPAddress) -> Ordering
[src]
This method returns an Ordering
between self
and other
. Read more
fn max(self, other: Self) -> Self
1.22.0[src]
Compares and returns the maximum of two values. Read more
fn min(self, other: Self) -> Self
1.22.0[src]
Compares and returns the minimum of two values. Read more
impl PartialOrd for IPAddress
[src]
fn partial_cmp(&self, other: &IPAddress) -> Option<Ordering>
[src]
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq for IPAddress
[src]
fn eq(&self, other: &Self) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Self) -> bool
[src]
This method tests for !=
.