1
# Copyright 2007 Google Inc.
2
# Licensed to PSF under a Contributor Agreement.
4
"""A fast, lightweight IPv4/IPv6 manipulation library in Python.
6
This library is used to create/poke/manipulate IPv4 and IPv6 addresses
19
class AddressValueError(ValueError):
20
"""A Value Error related to the address."""
23
class NetmaskValueError(ValueError):
24
"""A Value Error related to the netmask."""
27
def ip_address(address):
28
"""Take an IP string/int and return an object of the correct type.
31
address: A string or integer, the IP address. Either IPv4 or
32
IPv6 addresses may be supplied; integers less than 2**32 will
33
be considered to be IPv4 by default.
36
An IPv4Address or IPv6Address object.
39
ValueError: if the *address* passed isn't either a v4 or a v6
44
return IPv4Address(address)
45
except (AddressValueError, NetmaskValueError):
49
return IPv6Address(address)
50
except (AddressValueError, NetmaskValueError):
53
raise ValueError('%r does not appear to be an IPv4 or IPv6 address' %
57
def ip_network(address, strict=True):
58
"""Take an IP string/int and return an object of the correct type.
61
address: A string or integer, the IP network. Either IPv4 or
62
IPv6 networks may be supplied; integers less than 2**32 will
63
be considered to be IPv4 by default.
66
An IPv4Network or IPv6Network object.
69
ValueError: if the string passed isn't either a v4 or a v6
70
address. Or if the network has host bits set.
74
return IPv4Network(address, strict)
75
except (AddressValueError, NetmaskValueError):
79
return IPv6Network(address, strict)
80
except (AddressValueError, NetmaskValueError):
83
raise ValueError('%r does not appear to be an IPv4 or IPv6 network' %
87
def ip_interface(address):
88
"""Take an IP string/int and return an object of the correct type.
91
address: A string or integer, the IP address. Either IPv4 or
92
IPv6 addresses may be supplied; integers less than 2**32 will
93
be considered to be IPv4 by default.
96
An IPv4Interface or IPv6Interface object.
99
ValueError: if the string passed isn't either a v4 or a v6
103
The IPv?Interface classes describe an Address on a particular
104
Network, so they're basically a combination of both the Address
109
return IPv4Interface(address)
110
except (AddressValueError, NetmaskValueError):
114
return IPv6Interface(address)
115
except (AddressValueError, NetmaskValueError):
118
raise ValueError('%r does not appear to be an IPv4 or IPv6 interface' %
122
def v4_int_to_packed(address):
123
"""Represent an address as 4 packed bytes in network (big-endian) order.
126
address: An integer representation of an IPv4 IP address.
129
The integer address packed as 4 bytes in network (big-endian) order.
132
ValueError: If the integer is negative or too large to be an
137
return address.to_bytes(4, 'big')
139
raise ValueError("Address negative or too large for IPv4")
142
def v6_int_to_packed(address):
143
"""Represent an address as 16 packed bytes in network (big-endian) order.
146
address: An integer representation of an IPv6 IP address.
149
The integer address packed as 16 bytes in network (big-endian) order.
153
return address.to_bytes(16, 'big')
155
raise ValueError("Address negative or too large for IPv6")
158
def _split_optional_netmask(address):
159
"""Helper to split the netmask and raise AddressValueError if needed"""
160
addr = str(address).split('/')
162
raise AddressValueError("Only one '/' permitted in %r" % address)
166
def _find_address_range(addresses):
167
"""Find a sequence of IPv#Address.
170
addresses: a list of IPv#Address objects.
173
A tuple containing the first and last IP addresses in the sequence.
176
first = last = addresses[0]
177
for ip in addresses[1:]:
178
if ip._ip == last._ip + 1:
185
def _count_righthand_zero_bits(number, bits):
186
"""Count the number of zero bits on the right hand side.
190
bits: maximum number of bits to count.
193
The number of zero bits on the right hand side of the number.
198
for i in range(bits):
199
if (number >> i) & 1:
201
# All bits of interest were zero, even if there are more in the number
205
def summarize_address_range(first, last):
206
"""Summarize a network range given the first and last IP addresses.
209
>>> list(summarize_address_range(IPv4Address('192.0.2.0'),
210
... IPv4Address('192.0.2.130')))
211
... #doctest: +NORMALIZE_WHITESPACE
212
[IPv4Network('192.0.2.0/25'), IPv4Network('192.0.2.128/31'),
213
IPv4Network('192.0.2.130/32')]
216
first: the first IPv4Address or IPv6Address in the range.
217
last: the last IPv4Address or IPv6Address in the range.
220
An iterator of the summarized IPv(4|6) network objects.
224
If the first and last objects are not IP addresses.
225
If the first and last objects are not the same version.
227
If the last object is not greater than the first.
228
If the version of the first address is not 4 or 6.
231
if (not (isinstance(first, _BaseAddress) and
232
isinstance(last, _BaseAddress))):
233
raise TypeError('first and last must be IP addresses, not networks')
234
if first.version != last.version:
235
raise TypeError("%s and %s are not of the same version" % (
238
raise ValueError('last IP address must be greater than first')
240
if first.version == 4:
242
elif first.version == 6:
245
raise ValueError('unknown IP version')
247
ip_bits = first._max_prefixlen
248
first_int = first._ip
250
while first_int <= last_int:
251
nbits = min(_count_righthand_zero_bits(first_int, ip_bits),
252
(last_int - first_int + 1).bit_length() - 1)
253
net = ip('%s/%d' % (first, ip_bits - nbits))
255
first_int += 1 << nbits
256
if first_int - 1 == ip._ALL_ONES:
258
first = first.__class__(first_int)
261
def _collapse_addresses_recursive(addresses):
262
"""Loops through the addresses, collapsing concurrent netblocks.
266
ip1 = IPv4Network('192.0.2.0/26')
267
ip2 = IPv4Network('192.0.2.64/26')
268
ip3 = IPv4Network('192.0.2.128/26')
269
ip4 = IPv4Network('192.0.2.192/26')
271
_collapse_addresses_recursive([ip1, ip2, ip3, ip4]) ->
272
[IPv4Network('192.0.2.0/24')]
274
This shouldn't be called directly; it is called via
275
collapse_addresses([]).
278
addresses: A list of IPv4Network's or IPv6Network's
281
A list of IPv4Network's or IPv6Network's depending on what we were
290
for cur_addr in addresses:
293
ret_array.append(cur_addr)
294
elif (cur_addr.network_address >= last_addr.network_address and
295
cur_addr.broadcast_address <= last_addr.broadcast_address):
297
elif cur_addr == list(last_addr.supernet().subnets())[1]:
298
ret_array[-1] = last_addr = last_addr.supernet()
302
ret_array.append(cur_addr)
304
addresses = ret_array
309
def collapse_addresses(addresses):
310
"""Collapse a list of IP objects.
313
collapse_addresses([IPv4Network('192.0.2.0/25'),
314
IPv4Network('192.0.2.128/25')]) ->
315
[IPv4Network('192.0.2.0/24')]
318
addresses: An iterator of IPv4Network or IPv6Network objects.
321
An iterator of the collapsed IPv(4|6)Network objects.
324
TypeError: If passed a list of mixed version objects.
332
# split IP addresses and networks
334
if isinstance(ip, _BaseAddress):
335
if ips and ips[-1]._version != ip._version:
336
raise TypeError("%s and %s are not of the same version" % (
339
elif ip._prefixlen == ip._max_prefixlen:
340
if ips and ips[-1]._version != ip._version:
341
raise TypeError("%s and %s are not of the same version" % (
345
except AttributeError:
346
ips.append(ip.network_address)
348
if nets and nets[-1]._version != ip._version:
349
raise TypeError("%s and %s are not of the same version" % (
354
ips = sorted(set(ips))
355
nets = sorted(set(nets))
358
(first, last) = _find_address_range(ips[i:])
359
i = ips.index(last) + 1
360
addrs.extend(summarize_address_range(first, last))
362
return iter(_collapse_addresses_recursive(sorted(
363
addrs + nets, key=_BaseNetwork._get_networks_key)))
366
def get_mixed_type_key(obj):
367
"""Return a key suitable for sorting between networks and addresses.
369
Address and Network objects are not sortable by default; they're
370
fundamentally different so the expression
372
IPv4Address('192.0.2.0') <= IPv4Network('192.0.2.0/24')
374
doesn't make any sense. There are some times however, where you may wish
375
to have ipaddress sort these for you anyway. If you need to do this, you
376
can use this function as the key= argument to sorted().
379
obj: either a Network or Address object.
384
if isinstance(obj, _BaseNetwork):
385
return obj._get_networks_key()
386
elif isinstance(obj, _BaseAddress):
387
return obj._get_address_key()
388
return NotImplemented
391
class _TotalOrderingMixin:
392
# Helper that derives the other comparison operations from
394
# We avoid functools.total_ordering because it doesn't handle
395
# NotImplemented correctly yet (http://bugs.python.org/issue10042)
396
def __eq__(self, other):
397
raise NotImplementedError
398
def __ne__(self, other):
399
equal = self.__eq__(other)
400
if equal is NotImplemented:
401
return NotImplemented
403
def __lt__(self, other):
404
raise NotImplementedError
405
def __le__(self, other):
406
less = self.__lt__(other)
407
if less is NotImplemented or not less:
408
return self.__eq__(other)
410
def __gt__(self, other):
411
less = self.__lt__(other)
412
if less is NotImplemented:
413
return NotImplemented
414
equal = self.__eq__(other)
415
if equal is NotImplemented:
416
return NotImplemented
417
return not (less or equal)
418
def __ge__(self, other):
419
less = self.__lt__(other)
420
if less is NotImplemented:
421
return NotImplemented
424
class _IPAddressBase(_TotalOrderingMixin):
426
"""The mother class."""
430
"""Return the longhand version of the IP address as a string."""
431
return self._explode_shorthand_ip_string()
434
def compressed(self):
435
"""Return the shorthand version of the IP address as a string."""
440
msg = '%200s has no version specified' % (type(self),)
441
raise NotImplementedError(msg)
443
def _check_int_address(self, address):
445
msg = "%d (< 0) is not permitted as an IPv%d address"
446
raise AddressValueError(msg % (address, self._version))
447
if address > self._ALL_ONES:
448
msg = "%d (>= 2**%d) is not permitted as an IPv%d address"
449
raise AddressValueError(msg % (address, self._max_prefixlen,
452
def _check_packed_address(self, address, expected_len):
453
address_len = len(address)
454
if address_len != expected_len:
455
msg = "%r (len %d != %d) is not permitted as an IPv%d address"
456
raise AddressValueError(msg % (address, address_len,
457
expected_len, self._version))
459
def _ip_int_from_prefix(self, prefixlen=None):
460
"""Turn the prefix length netmask into a int for comparison.
463
prefixlen: An integer, the prefix length.
469
if prefixlen is None:
470
prefixlen = self._prefixlen
471
return self._ALL_ONES ^ (self._ALL_ONES >> prefixlen)
473
def _prefix_from_ip_int(self, ip_int, mask=32):
474
"""Return prefix length from the decimal netmask.
477
ip_int: An integer, the IP address.
478
mask: The netmask. Defaults to 32.
481
An integer, the prefix length.
484
return mask - _count_righthand_zero_bits(ip_int, mask)
486
def _ip_string_from_prefix(self, prefixlen=None):
487
"""Turn a prefix length into a dotted decimal string.
490
prefixlen: An integer, the netmask prefix length.
493
A string, the dotted decimal netmask string.
497
prefixlen = self._prefixlen
498
return self._string_from_ip_int(self._ip_int_from_prefix(prefixlen))
501
class _BaseAddress(_IPAddressBase):
503
"""A generic IP object.
505
This IP class contains the version independent methods which are
506
used by single IP addresses.
510
def __init__(self, address):
511
if (not isinstance(address, bytes)
512
and '/' in str(address)):
513
raise AddressValueError("Unexpected '/' in %r" % address)
518
def __eq__(self, other):
520
return (self._ip == other._ip
521
and self._version == other._version)
522
except AttributeError:
523
return NotImplemented
525
def __lt__(self, other):
526
if self._version != other._version:
527
raise TypeError('%s and %s are not of the same version' % (
529
if not isinstance(other, _BaseAddress):
530
raise TypeError('%s and %s are not of the same type' % (
532
if self._ip != other._ip:
533
return self._ip < other._ip
536
# Shorthand for Integer addition and subtraction. This is not
537
# meant to ever support addition/subtraction of addresses.
538
def __add__(self, other):
539
if not isinstance(other, int):
540
return NotImplemented
541
return self.__class__(int(self) + other)
543
def __sub__(self, other):
544
if not isinstance(other, int):
545
return NotImplemented
546
return self.__class__(int(self) - other)
549
return '%s(%r)' % (self.__class__.__name__, str(self))
552
return str(self._string_from_ip_int(self._ip))
555
return hash(hex(int(self._ip)))
557
def _get_address_key(self):
558
return (self._version, self)
561
class _BaseNetwork(_IPAddressBase):
563
"""A generic IP network object.
565
This IP class contains the version independent methods which are
569
def __init__(self, address):
573
return '%s(%r)' % (self.__class__.__name__, str(self))
576
return '%s/%d' % (self.network_address, self.prefixlen)
579
"""Generate Iterator over usable hosts in a network.
581
This is like __iter__ except it doesn't return the network
582
or broadcast addresses.
585
network = int(self.network_address)
586
broadcast = int(self.broadcast_address)
587
for x in range(network + 1, broadcast):
588
yield self._address_class(x)
591
network = int(self.network_address)
592
broadcast = int(self.broadcast_address)
593
for x in range(network, broadcast + 1):
594
yield self._address_class(x)
596
def __getitem__(self, n):
597
network = int(self.network_address)
598
broadcast = int(self.broadcast_address)
600
if network + n > broadcast:
602
return self._address_class(network + n)
605
if broadcast + n < network:
607
return self._address_class(broadcast + n)
609
def __lt__(self, other):
610
if self._version != other._version:
611
raise TypeError('%s and %s are not of the same version' % (
613
if not isinstance(other, _BaseNetwork):
614
raise TypeError('%s and %s are not of the same type' % (
616
if self.network_address != other.network_address:
617
return self.network_address < other.network_address
618
if self.netmask != other.netmask:
619
return self.netmask < other.netmask
622
def __eq__(self, other):
624
return (self._version == other._version and
625
self.network_address == other.network_address and
626
int(self.netmask) == int(other.netmask))
627
except AttributeError:
628
return NotImplemented
631
return hash(int(self.network_address) ^ int(self.netmask))
633
def __contains__(self, other):
634
# always false if one is v4 and the other is v6.
635
if self._version != other._version:
637
# dealing with another network.
638
if isinstance(other, _BaseNetwork):
640
# dealing with another address
643
return (int(self.network_address) <= int(other._ip) <=
644
int(self.broadcast_address))
646
def overlaps(self, other):
647
"""Tell if self is partly contained in other."""
648
return self.network_address in other or (
649
self.broadcast_address in other or (
650
other.network_address in self or (
651
other.broadcast_address in self)))
654
def broadcast_address(self):
655
x = self._cache.get('broadcast_address')
657
x = self._address_class(int(self.network_address) |
659
self._cache['broadcast_address'] = x
664
x = self._cache.get('hostmask')
666
x = self._address_class(int(self.netmask) ^ self._ALL_ONES)
667
self._cache['hostmask'] = x
671
def with_prefixlen(self):
672
return '%s/%d' % (self.network_address, self._prefixlen)
675
def with_netmask(self):
676
return '%s/%s' % (self.network_address, self.netmask)
679
def with_hostmask(self):
680
return '%s/%s' % (self.network_address, self.hostmask)
683
def num_addresses(self):
684
"""Number of hosts in the current subnet."""
685
return int(self.broadcast_address) - int(self.network_address) + 1
688
def _address_class(self):
689
# Returning bare address objects (rather than interfaces) allows for
690
# more consistent behaviour across the network address, broadcast
691
# address and individual host addresses.
692
msg = '%200s has no associated address class' % (type(self),)
693
raise NotImplementedError(msg)
697
return self._prefixlen
699
def address_exclude(self, other):
700
"""Remove an address from a larger block.
704
addr1 = ip_network('192.0.2.0/28')
705
addr2 = ip_network('192.0.2.1/32')
706
addr1.address_exclude(addr2) =
707
[IPv4Network('192.0.2.0/32'), IPv4Network('192.0.2.2/31'),
708
IPv4Network('192.0.2.4/30'), IPv4Network('192.0.2.8/29')]
712
addr1 = ip_network('2001:db8::1/32')
713
addr2 = ip_network('2001:db8::1/128')
714
addr1.address_exclude(addr2) =
715
[ip_network('2001:db8::1/128'),
716
ip_network('2001:db8::2/127'),
717
ip_network('2001:db8::4/126'),
718
ip_network('2001:db8::8/125'),
720
ip_network('2001:db8:8000::/33')]
723
other: An IPv4Network or IPv6Network object of the same type.
726
An iterator of the IPv(4|6)Network objects which is self
730
TypeError: If self and other are of differing address
731
versions, or if other is not a network object.
732
ValueError: If other is not completely contained by self.
735
if not self._version == other._version:
736
raise TypeError("%s and %s are not of the same version" % (
739
if not isinstance(other, _BaseNetwork):
740
raise TypeError("%s is not a network object" % other)
742
if not (other.network_address >= self.network_address and
743
other.broadcast_address <= self.broadcast_address):
744
raise ValueError('%s not contained in %s' % (other, self))
748
# Make sure we're comparing the network of other.
749
other = other.__class__('%s/%s' % (other.network_address,
752
s1, s2 = self.subnets()
753
while s1 != other and s2 != other:
754
if (other.network_address >= s1.network_address and
755
other.broadcast_address <= s1.broadcast_address):
757
s1, s2 = s1.subnets()
758
elif (other.network_address >= s2.network_address and
759
other.broadcast_address <= s2.broadcast_address):
761
s1, s2 = s2.subnets()
763
# If we got here, there's a bug somewhere.
764
raise AssertionError('Error performing exclusion: '
765
's1: %s s2: %s other: %s' %
772
# If we got here, there's a bug somewhere.
773
raise AssertionError('Error performing exclusion: '
774
's1: %s s2: %s other: %s' %
777
def compare_networks(self, other):
778
"""Compare two IP objects.
780
This is only concerned about the comparison of the integer
781
representation of the network addresses. This means that the
782
host bits aren't considered at all in this method. If you want
783
to compare host bits, you can easily enough do a
784
'HostA._ip < HostB._ip'
790
If the IP versions of self and other are the same, returns:
793
eg: IPv4Network('192.0.2.0/25') < IPv4Network('192.0.2.128/25')
794
IPv6Network('2001:db8::1000/124') <
795
IPv6Network('2001:db8::2000/124')
797
eg: IPv4Network('192.0.2.0/24') == IPv4Network('192.0.2.0/24')
798
IPv6Network('2001:db8::1000/124') ==
799
IPv6Network('2001:db8::1000/124')
801
eg: IPv4Network('192.0.2.128/25') > IPv4Network('192.0.2.0/25')
802
IPv6Network('2001:db8::2000/124') >
803
IPv6Network('2001:db8::1000/124')
806
TypeError if the IP versions are different.
809
# does this need to raise a ValueError?
810
if self._version != other._version:
811
raise TypeError('%s and %s are not of the same type' % (
813
# self._version == other._version below here:
814
if self.network_address < other.network_address:
816
if self.network_address > other.network_address:
818
# self.network_address == other.network_address below here:
819
if self.netmask < other.netmask:
821
if self.netmask > other.netmask:
825
def _get_networks_key(self):
826
"""Network-only key function.
828
Returns an object that identifies this address' network and
829
netmask. This function is a suitable "key" argument for sorted()
833
return (self._version, self.network_address, self.netmask)
835
def subnets(self, prefixlen_diff=1, new_prefix=None):
836
"""The subnets which join to make the current subnet.
838
In the case that self contains only one IP
839
(self._prefixlen == 32 for IPv4 or self._prefixlen == 128
840
for IPv6), yield an iterator with just ourself.
843
prefixlen_diff: An integer, the amount the prefix length
844
should be increased by. This should not be set if
845
new_prefix is also set.
846
new_prefix: The desired new prefix length. This must be a
847
larger number (smaller prefix) than the existing prefix.
848
This should not be set if prefixlen_diff is also set.
851
An iterator of IPv(4|6) objects.
854
ValueError: The prefixlen_diff is too small or too large.
856
prefixlen_diff and new_prefix are both set or new_prefix
857
is a smaller number than the current prefix (smaller
858
number means a larger network)
861
if self._prefixlen == self._max_prefixlen:
865
if new_prefix is not None:
866
if new_prefix < self._prefixlen:
867
raise ValueError('new prefix must be longer')
868
if prefixlen_diff != 1:
869
raise ValueError('cannot set prefixlen_diff and new_prefix')
870
prefixlen_diff = new_prefix - self._prefixlen
872
if prefixlen_diff < 0:
873
raise ValueError('prefix length diff must be > 0')
874
new_prefixlen = self._prefixlen + prefixlen_diff
876
if not self._is_valid_netmask(str(new_prefixlen)):
878
'prefix length diff %d is invalid for netblock %s' % (
879
new_prefixlen, self))
881
first = self.__class__('%s/%s' %
882
(self.network_address,
883
self._prefixlen + prefixlen_diff))
888
broadcast = current.broadcast_address
889
if broadcast == self.broadcast_address:
891
new_addr = self._address_class(int(broadcast) + 1)
892
current = self.__class__('%s/%s' % (new_addr,
897
def supernet(self, prefixlen_diff=1, new_prefix=None):
898
"""The supernet containing the current network.
901
prefixlen_diff: An integer, the amount the prefix length of
902
the network should be decreased by. For example, given a
903
/24 network and a prefixlen_diff of 3, a supernet with a
904
/21 netmask is returned.
907
An IPv4 network object.
910
ValueError: If self.prefixlen - prefixlen_diff < 0. I.e., you have
911
a negative prefix length.
913
If prefixlen_diff and new_prefix are both set or new_prefix is a
914
larger number than the current prefix (larger number means a
918
if self._prefixlen == 0:
921
if new_prefix is not None:
922
if new_prefix > self._prefixlen:
923
raise ValueError('new prefix must be shorter')
924
if prefixlen_diff != 1:
925
raise ValueError('cannot set prefixlen_diff and new_prefix')
926
prefixlen_diff = self._prefixlen - new_prefix
928
if self.prefixlen - prefixlen_diff < 0:
930
'current prefixlen is %d, cannot have a prefixlen_diff of %d' %
931
(self.prefixlen, prefixlen_diff))
932
# TODO (pmoody): optimize this.
933
t = self.__class__('%s/%d' % (self.network_address,
934
self.prefixlen - prefixlen_diff),
936
return t.__class__('%s/%d' % (t.network_address, t.prefixlen))
939
def is_multicast(self):
940
"""Test if the address is reserved for multicast use.
943
A boolean, True if the address is a multicast address.
944
See RFC 2373 2.7 for details.
947
return (self.network_address.is_multicast and
948
self.broadcast_address.is_multicast)
951
def is_reserved(self):
952
"""Test if the address is otherwise IETF reserved.
955
A boolean, True if the address is within one of the
956
reserved IPv6 Network ranges.
959
return (self.network_address.is_reserved and
960
self.broadcast_address.is_reserved)
963
def is_link_local(self):
964
"""Test if the address is reserved for link-local.
967
A boolean, True if the address is reserved per RFC 4291.
970
return (self.network_address.is_link_local and
971
self.broadcast_address.is_link_local)
974
def is_private(self):
975
"""Test if this address is allocated for private networks.
978
A boolean, True if the address is reserved per
979
iana-ipv4-special-registry or iana-ipv6-special-registry.
982
return (self.network_address.is_private and
983
self.broadcast_address.is_private)
987
"""Test if this address is allocated for public networks.
990
A boolean, True if the address is not reserved per
991
iana-ipv4-special-registry or iana-ipv6-special-registry.
994
return not self.is_private
997
def is_unspecified(self):
998
"""Test if the address is unspecified.
1001
A boolean, True if this is the unspecified address as defined in
1005
return (self.network_address.is_unspecified and
1006
self.broadcast_address.is_unspecified)
1009
def is_loopback(self):
1010
"""Test if the address is a loopback address.
1013
A boolean, True if the address is a loopback address as defined in
1017
return (self.network_address.is_loopback and
1018
self.broadcast_address.is_loopback)
1023
"""Base IPv4 object.
1025
The following methods are used by IPv4 objects in both single IP
1026
addresses and networks.
1030
# Equivalent to 255.255.255.255 or 32 bits of 1's.
1031
_ALL_ONES = (2**IPV4LENGTH) - 1
1032
_DECIMAL_DIGITS = frozenset('0123456789')
1034
# the valid octets for host and netmasks. only useful for IPv4.
1035
_valid_mask_octets = frozenset((255, 254, 252, 248, 240, 224, 192, 128, 0))
1037
def __init__(self, address):
1039
self._max_prefixlen = IPV4LENGTH
1041
def _explode_shorthand_ip_string(self):
1044
def _ip_int_from_string(self, ip_str):
1045
"""Turn the given IP string into an integer for comparison.
1048
ip_str: A string, the IP ip_str.
1051
The IP ip_str as an integer.
1054
AddressValueError: if ip_str isn't a valid IPv4 Address.
1058
raise AddressValueError('Address cannot be empty')
1060
octets = ip_str.split('.')
1061
if len(octets) != 4:
1062
raise AddressValueError("Expected 4 octets in %r" % ip_str)
1065
return int.from_bytes(map(self._parse_octet, octets), 'big')
1066
except ValueError as exc:
1067
raise AddressValueError("%s in %r" % (exc, ip_str)) from None
1069
def _parse_octet(self, octet_str):
1070
"""Convert a decimal octet into an integer.
1073
octet_str: A string, the number to parse.
1076
The octet as an integer.
1079
ValueError: if the octet isn't strictly a decimal from [0..255].
1083
raise ValueError("Empty octet not permitted")
1084
# Whitelist the characters, since int() allows a lot of bizarre stuff.
1085
if not self._DECIMAL_DIGITS.issuperset(octet_str):
1086
msg = "Only decimal digits permitted in %r"
1087
raise ValueError(msg % octet_str)
1088
# We do the length check second, since the invalid character error
1089
# is likely to be more informative for the user
1090
if len(octet_str) > 3:
1091
msg = "At most 3 characters permitted in %r"
1092
raise ValueError(msg % octet_str)
1093
# Convert to integer (we know digits are legal)
1094
octet_int = int(octet_str, 10)
1095
# Any octets that look like they *might* be written in octal,
1096
# and which don't look exactly the same in both octal and
1097
# decimal are rejected as ambiguous
1098
if octet_int > 7 and octet_str[0] == '0':
1099
msg = "Ambiguous (octal/decimal) value in %r not permitted"
1100
raise ValueError(msg % octet_str)
1102
raise ValueError("Octet %d (> 255) not permitted" % octet_int)
1105
def _string_from_ip_int(self, ip_int):
1106
"""Turns a 32-bit integer into dotted decimal notation.
1109
ip_int: An integer, the IP address.
1112
The IP address as a string in dotted decimal notation.
1115
return '.'.join(map(str, ip_int.to_bytes(4, 'big')))
1117
def _is_valid_netmask(self, netmask):
1118
"""Verify that the netmask is valid.
1121
netmask: A string, either a prefix or dotted decimal
1125
A boolean, True if the prefix represents a valid IPv4
1129
mask = netmask.split('.')
1133
if int(x) not in self._valid_mask_octets:
1136
# Found something that isn't an integer or isn't valid
1138
for idx, y in enumerate(mask):
1139
if idx > 0 and y > mask[idx - 1]:
1143
netmask = int(netmask)
1146
return 0 <= netmask <= self._max_prefixlen
1148
def _is_hostmask(self, ip_str):
1149
"""Test if the IP string is a hostmask (rather than a netmask).
1152
ip_str: A string, the potential hostmask.
1155
A boolean, True if the IP string is a hostmask.
1158
bits = ip_str.split('.')
1160
parts = [x for x in map(int, bits) if x in self._valid_mask_octets]
1163
if len(parts) != len(bits):
1165
if parts[0] < parts[-1]:
1170
def max_prefixlen(self):
1171
return self._max_prefixlen
1175
return self._version
1178
class IPv4Address(_BaseV4, _BaseAddress):
1180
"""Represent and manipulate single IPv4 Addresses."""
1182
def __init__(self, address):
1186
address: A string or integer representing the IP
1188
Additionally, an integer can be passed, so
1189
IPv4Address('192.0.2.1') == IPv4Address(3221225985).
1191
IPv4Address(int(IPv4Address('192.0.2.1'))) ==
1192
IPv4Address('192.0.2.1')
1195
AddressValueError: If ipaddress isn't a valid IPv4 address.
1198
_BaseAddress.__init__(self, address)
1199
_BaseV4.__init__(self, address)
1201
# Efficient constructor from integer.
1202
if isinstance(address, int):
1203
self._check_int_address(address)
1207
# Constructing from a packed address
1208
if isinstance(address, bytes):
1209
self._check_packed_address(address, 4)
1210
self._ip = int.from_bytes(address, 'big')
1213
# Assume input argument to be string or any object representation
1214
# which converts into a formatted IP string.
1215
addr_str = str(address)
1216
self._ip = self._ip_int_from_string(addr_str)
1220
"""The binary representation of this address."""
1221
return v4_int_to_packed(self._ip)
1224
def is_reserved(self):
1225
"""Test if the address is otherwise IETF reserved.
1228
A boolean, True if the address is within the
1229
reserved IPv4 Network range.
1232
reserved_network = IPv4Network('240.0.0.0/4')
1233
return self in reserved_network
1236
@functools.lru_cache()
1237
def is_private(self):
1238
"""Test if this address is allocated for private networks.
1241
A boolean, True if the address is reserved per
1242
iana-ipv4-special-registry.
1245
return (self in IPv4Network('0.0.0.0/8') or
1246
self in IPv4Network('10.0.0.0/8') or
1247
self in IPv4Network('127.0.0.0/8') or
1248
self in IPv4Network('169.254.0.0/16') or
1249
self in IPv4Network('172.16.0.0/12') or
1250
self in IPv4Network('192.0.0.0/29') or
1251
self in IPv4Network('192.0.0.170/31') or
1252
self in IPv4Network('192.0.2.0/24') or
1253
self in IPv4Network('192.168.0.0/16') or
1254
self in IPv4Network('198.18.0.0/15') or
1255
self in IPv4Network('198.51.100.0/24') or
1256
self in IPv4Network('203.0.113.0/24') or
1257
self in IPv4Network('240.0.0.0/4') or
1258
self in IPv4Network('255.255.255.255/32'))
1262
def is_multicast(self):
1263
"""Test if the address is reserved for multicast use.
1266
A boolean, True if the address is multicast.
1267
See RFC 3171 for details.
1270
multicast_network = IPv4Network('224.0.0.0/4')
1271
return self in multicast_network
1274
def is_unspecified(self):
1275
"""Test if the address is unspecified.
1278
A boolean, True if this is the unspecified address as defined in
1282
unspecified_address = IPv4Address('0.0.0.0')
1283
return self == unspecified_address
1286
def is_loopback(self):
1287
"""Test if the address is a loopback address.
1290
A boolean, True if the address is a loopback per RFC 3330.
1293
loopback_network = IPv4Network('127.0.0.0/8')
1294
return self in loopback_network
1297
def is_link_local(self):
1298
"""Test if the address is reserved for link-local.
1301
A boolean, True if the address is link-local per RFC 3927.
1304
linklocal_network = IPv4Network('169.254.0.0/16')
1305
return self in linklocal_network
1308
class IPv4Interface(IPv4Address):
1310
def __init__(self, address):
1311
if isinstance(address, (bytes, int)):
1312
IPv4Address.__init__(self, address)
1313
self.network = IPv4Network(self._ip)
1314
self._prefixlen = self._max_prefixlen
1317
addr = _split_optional_netmask(address)
1318
IPv4Address.__init__(self, addr[0])
1320
self.network = IPv4Network(address, strict=False)
1321
self._prefixlen = self.network._prefixlen
1323
self.netmask = self.network.netmask
1324
self.hostmask = self.network.hostmask
1327
return '%s/%d' % (self._string_from_ip_int(self._ip),
1328
self.network.prefixlen)
1330
def __eq__(self, other):
1331
address_equal = IPv4Address.__eq__(self, other)
1332
if not address_equal or address_equal is NotImplemented:
1333
return address_equal
1335
return self.network == other.network
1336
except AttributeError:
1337
# An interface with an associated network is NOT the
1338
# same as an unassociated address. That's why the hash
1339
# takes the extra info into account.
1342
def __lt__(self, other):
1343
address_less = IPv4Address.__lt__(self, other)
1344
if address_less is NotImplemented:
1345
return NotImplemented
1347
return self.network < other.network
1348
except AttributeError:
1349
# We *do* allow addresses and interfaces to be sorted. The
1350
# unassociated address is considered less than all interfaces.
1354
return self._ip ^ self._prefixlen ^ int(self.network.network_address)
1358
return IPv4Address(self._ip)
1361
def with_prefixlen(self):
1362
return '%s/%s' % (self._string_from_ip_int(self._ip),
1366
def with_netmask(self):
1367
return '%s/%s' % (self._string_from_ip_int(self._ip),
1371
def with_hostmask(self):
1372
return '%s/%s' % (self._string_from_ip_int(self._ip),
1376
class IPv4Network(_BaseV4, _BaseNetwork):
1378
"""This class represents and manipulates 32-bit IPv4 network + addresses..
1380
Attributes: [examples for IPv4Network('192.0.2.0/27')]
1381
.network_address: IPv4Address('192.0.2.0')
1382
.hostmask: IPv4Address('0.0.0.31')
1383
.broadcast_address: IPv4Address('192.0.2.32')
1384
.netmask: IPv4Address('255.255.255.224')
1388
# Class to use when creating address objects
1389
_address_class = IPv4Address
1391
def __init__(self, address, strict=True):
1393
"""Instantiate a new IPv4 network object.
1396
address: A string or integer representing the IP [& network].
1398
'192.0.2.0/255.255.255.0'
1399
'192.0.0.2/0.0.0.255'
1400
are all functionally the same in IPv4. Similarly,
1402
'192.0.2.1/255.255.255.255'
1404
are also functionally equivalent. That is to say, failing to
1405
provide a subnetmask will create an object with a mask of /32.
1407
If the mask (portion after the / in the argument) is given in
1408
dotted quad form, it is treated as a netmask if it starts with a
1409
non-zero field (e.g. /255.0.0.0 == /8) and as a hostmask if it
1410
starts with a zero field (e.g. 0.255.255.255 == /8), with the
1411
single exception of an all-zero mask which is treated as a
1412
netmask == /0. If no mask is given, a default of /32 is used.
1414
Additionally, an integer can be passed, so
1415
IPv4Network('192.0.2.1') == IPv4Network(3221225985)
1417
IPv4Interface(int(IPv4Interface('192.0.2.1'))) ==
1418
IPv4Interface('192.0.2.1')
1421
AddressValueError: If ipaddress isn't a valid IPv4 address.
1422
NetmaskValueError: If the netmask isn't valid for
1424
ValueError: If strict is True and a network address is not
1429
_BaseV4.__init__(self, address)
1430
_BaseNetwork.__init__(self, address)
1432
# Constructing from a packed address
1433
if isinstance(address, bytes):
1434
self.network_address = IPv4Address(address)
1435
self._prefixlen = self._max_prefixlen
1436
self.netmask = IPv4Address(self._ALL_ONES)
1437
#fixme: address/network test here
1440
# Efficient constructor from integer.
1441
if isinstance(address, int):
1442
self.network_address = IPv4Address(address)
1443
self._prefixlen = self._max_prefixlen
1444
self.netmask = IPv4Address(self._ALL_ONES)
1445
#fixme: address/network test here.
1448
# Assume input argument to be string or any object representation
1449
# which converts into a formatted IP prefix string.
1450
addr = _split_optional_netmask(address)
1451
self.network_address = IPv4Address(self._ip_int_from_string(addr[0]))
1454
mask = addr[1].split('.')
1457
# We have dotted decimal netmask.
1458
if self._is_valid_netmask(addr[1]):
1459
self.netmask = IPv4Address(self._ip_int_from_string(
1461
elif self._is_hostmask(addr[1]):
1462
self.netmask = IPv4Address(
1463
self._ip_int_from_string(addr[1]) ^ self._ALL_ONES)
1465
raise NetmaskValueError('%r is not a valid netmask'
1468
self._prefixlen = self._prefix_from_ip_int(int(self.netmask))
1470
# We have a netmask in prefix length form.
1471
if not self._is_valid_netmask(addr[1]):
1472
raise NetmaskValueError('%r is not a valid netmask'
1474
self._prefixlen = int(addr[1])
1475
self.netmask = IPv4Address(self._ip_int_from_prefix(
1478
self._prefixlen = self._max_prefixlen
1479
self.netmask = IPv4Address(self._ip_int_from_prefix(
1483
if (IPv4Address(int(self.network_address) & int(self.netmask)) !=
1484
self.network_address):
1485
raise ValueError('%s has host bits set' % self)
1486
self.network_address = IPv4Address(int(self.network_address) &
1489
if self._prefixlen == (self._max_prefixlen - 1):
1490
self.hosts = self.__iter__
1493
@functools.lru_cache()
1494
def is_global(self):
1495
"""Test if this address is allocated for public networks.
1498
A boolean, True if the address is not reserved per
1499
iana-ipv4-special-registry.
1502
return (not (self.network_address in IPv4Network('100.64.0.0/10') and
1503
self.broadcast_address in IPv4Network('100.64.0.0/10')) and
1504
not self.is_private)
1510
"""Base IPv6 object.
1512
The following methods are used by IPv6 objects in both single IP
1513
addresses and networks.
1517
_ALL_ONES = (2**IPV6LENGTH) - 1
1519
_HEX_DIGITS = frozenset('0123456789ABCDEFabcdef')
1521
def __init__(self, address):
1523
self._max_prefixlen = IPV6LENGTH
1525
def _ip_int_from_string(self, ip_str):
1526
"""Turn an IPv6 ip_str into an integer.
1529
ip_str: A string, the IPv6 ip_str.
1532
An int, the IPv6 address
1535
AddressValueError: if ip_str isn't a valid IPv6 Address.
1539
raise AddressValueError('Address cannot be empty')
1541
parts = ip_str.split(':')
1543
# An IPv6 address needs at least 2 colons (3 parts).
1545
if len(parts) < _min_parts:
1546
msg = "At least %d parts expected in %r" % (_min_parts, ip_str)
1547
raise AddressValueError(msg)
1549
# If the address has an IPv4-style suffix, convert it to hexadecimal.
1550
if '.' in parts[-1]:
1552
ipv4_int = IPv4Address(parts.pop())._ip
1553
except AddressValueError as exc:
1554
raise AddressValueError("%s in %r" % (exc, ip_str)) from None
1555
parts.append('%x' % ((ipv4_int >> 16) & 0xFFFF))
1556
parts.append('%x' % (ipv4_int & 0xFFFF))
1558
# An IPv6 address can't have more than 8 colons (9 parts).
1559
# The extra colon comes from using the "::" notation for a single
1560
# leading or trailing zero part.
1561
_max_parts = self._HEXTET_COUNT + 1
1562
if len(parts) > _max_parts:
1563
msg = "At most %d colons permitted in %r" % (_max_parts-1, ip_str)
1564
raise AddressValueError(msg)
1566
# Disregarding the endpoints, find '::' with nothing in between.
1567
# This indicates that a run of zeroes has been skipped.
1569
for i in range(1, len(parts) - 1):
1571
if skip_index is not None:
1572
# Can't have more than one '::'
1573
msg = "At most one '::' permitted in %r" % ip_str
1574
raise AddressValueError(msg)
1577
# parts_hi is the number of parts to copy from above/before the '::'
1578
# parts_lo is the number of parts to copy from below/after the '::'
1579
if skip_index is not None:
1580
# If we found a '::', then check if it also covers the endpoints.
1581
parts_hi = skip_index
1582
parts_lo = len(parts) - skip_index - 1
1586
msg = "Leading ':' only permitted as part of '::' in %r"
1587
raise AddressValueError(msg % ip_str) # ^: requires ^::
1591
msg = "Trailing ':' only permitted as part of '::' in %r"
1592
raise AddressValueError(msg % ip_str) # :$ requires ::$
1593
parts_skipped = self._HEXTET_COUNT - (parts_hi + parts_lo)
1594
if parts_skipped < 1:
1595
msg = "Expected at most %d other parts with '::' in %r"
1596
raise AddressValueError(msg % (self._HEXTET_COUNT-1, ip_str))
1598
# Otherwise, allocate the entire address to parts_hi. The
1599
# endpoints could still be empty, but _parse_hextet() will check
1601
if len(parts) != self._HEXTET_COUNT:
1602
msg = "Exactly %d parts expected without '::' in %r"
1603
raise AddressValueError(msg % (self._HEXTET_COUNT, ip_str))
1605
msg = "Leading ':' only permitted as part of '::' in %r"
1606
raise AddressValueError(msg % ip_str) # ^: requires ^::
1608
msg = "Trailing ':' only permitted as part of '::' in %r"
1609
raise AddressValueError(msg % ip_str) # :$ requires ::$
1610
parts_hi = len(parts)
1615
# Now, parse the hextets into a 128-bit integer.
1617
for i in range(parts_hi):
1619
ip_int |= self._parse_hextet(parts[i])
1620
ip_int <<= 16 * parts_skipped
1621
for i in range(-parts_lo, 0):
1623
ip_int |= self._parse_hextet(parts[i])
1625
except ValueError as exc:
1626
raise AddressValueError("%s in %r" % (exc, ip_str)) from None
1628
def _parse_hextet(self, hextet_str):
1629
"""Convert an IPv6 hextet string into an integer.
1632
hextet_str: A string, the number to parse.
1635
The hextet as an integer.
1638
ValueError: if the input isn't strictly a hex number from
1642
# Whitelist the characters, since int() allows a lot of bizarre stuff.
1643
if not self._HEX_DIGITS.issuperset(hextet_str):
1644
raise ValueError("Only hex digits permitted in %r" % hextet_str)
1645
# We do the length check second, since the invalid character error
1646
# is likely to be more informative for the user
1647
if len(hextet_str) > 4:
1648
msg = "At most 4 characters permitted in %r"
1649
raise ValueError(msg % hextet_str)
1650
# Length check means we can skip checking the integer value
1651
return int(hextet_str, 16)
1653
def _compress_hextets(self, hextets):
1654
"""Compresses a list of hextets.
1656
Compresses a list of strings, replacing the longest continuous
1657
sequence of "0" in the list with "" and adding empty strings at
1658
the beginning or at the end of the string such that subsequently
1659
calling ":".join(hextets) will produce the compressed version of
1663
hextets: A list of strings, the hextets to compress.
1669
best_doublecolon_start = -1
1670
best_doublecolon_len = 0
1671
doublecolon_start = -1
1673
for index, hextet in enumerate(hextets):
1675
doublecolon_len += 1
1676
if doublecolon_start == -1:
1677
# Start of a sequence of zeros.
1678
doublecolon_start = index
1679
if doublecolon_len > best_doublecolon_len:
1680
# This is the longest sequence of zeros so far.
1681
best_doublecolon_len = doublecolon_len
1682
best_doublecolon_start = doublecolon_start
1685
doublecolon_start = -1
1687
if best_doublecolon_len > 1:
1688
best_doublecolon_end = (best_doublecolon_start +
1689
best_doublecolon_len)
1690
# For zeros at the end of the address.
1691
if best_doublecolon_end == len(hextets):
1693
hextets[best_doublecolon_start:best_doublecolon_end] = ['']
1694
# For zeros at the beginning of the address.
1695
if best_doublecolon_start == 0:
1696
hextets = [''] + hextets
1700
def _string_from_ip_int(self, ip_int=None):
1701
"""Turns a 128-bit integer into hexadecimal notation.
1704
ip_int: An integer, the IP address.
1707
A string, the hexadecimal representation of the address.
1710
ValueError: The address is bigger than 128 bits of all ones.
1714
ip_int = int(self._ip)
1716
if ip_int > self._ALL_ONES:
1717
raise ValueError('IPv6 address is too large')
1719
hex_str = '%032x' % ip_int
1720
hextets = ['%x' % int(hex_str[x:x+4], 16) for x in range(0, 32, 4)]
1722
hextets = self._compress_hextets(hextets)
1723
return ':'.join(hextets)
1725
def _explode_shorthand_ip_string(self):
1726
"""Expand a shortened IPv6 address.
1729
ip_str: A string, the IPv6 address.
1732
A string, the expanded IPv6 address.
1735
if isinstance(self, IPv6Network):
1736
ip_str = str(self.network_address)
1737
elif isinstance(self, IPv6Interface):
1738
ip_str = str(self.ip)
1742
ip_int = self._ip_int_from_string(ip_str)
1743
hex_str = '%032x' % ip_int
1744
parts = [hex_str[x:x+4] for x in range(0, 32, 4)]
1745
if isinstance(self, (_BaseNetwork, IPv6Interface)):
1746
return '%s/%d' % (':'.join(parts), self._prefixlen)
1747
return ':'.join(parts)
1750
def max_prefixlen(self):
1751
return self._max_prefixlen
1755
return self._version
1758
class IPv6Address(_BaseV6, _BaseAddress):
1760
"""Represent and manipulate single IPv6 Addresses."""
1762
def __init__(self, address):
1763
"""Instantiate a new IPv6 address object.
1766
address: A string or integer representing the IP
1768
Additionally, an integer can be passed, so
1769
IPv6Address('2001:db8::') ==
1770
IPv6Address(42540766411282592856903984951653826560)
1772
IPv6Address(int(IPv6Address('2001:db8::'))) ==
1773
IPv6Address('2001:db8::')
1776
AddressValueError: If address isn't a valid IPv6 address.
1779
_BaseAddress.__init__(self, address)
1780
_BaseV6.__init__(self, address)
1782
# Efficient constructor from integer.
1783
if isinstance(address, int):
1784
self._check_int_address(address)
1788
# Constructing from a packed address
1789
if isinstance(address, bytes):
1790
self._check_packed_address(address, 16)
1791
self._ip = int.from_bytes(address, 'big')
1794
# Assume input argument to be string or any object representation
1795
# which converts into a formatted IP string.
1796
addr_str = str(address)
1797
self._ip = self._ip_int_from_string(addr_str)
1801
"""The binary representation of this address."""
1802
return v6_int_to_packed(self._ip)
1805
def is_multicast(self):
1806
"""Test if the address is reserved for multicast use.
1809
A boolean, True if the address is a multicast address.
1810
See RFC 2373 2.7 for details.
1813
multicast_network = IPv6Network('ff00::/8')
1814
return self in multicast_network
1817
def is_reserved(self):
1818
"""Test if the address is otherwise IETF reserved.
1821
A boolean, True if the address is within one of the
1822
reserved IPv6 Network ranges.
1825
reserved_networks = [IPv6Network('::/8'), IPv6Network('100::/8'),
1826
IPv6Network('200::/7'), IPv6Network('400::/6'),
1827
IPv6Network('800::/5'), IPv6Network('1000::/4'),
1828
IPv6Network('4000::/3'), IPv6Network('6000::/3'),
1829
IPv6Network('8000::/3'), IPv6Network('A000::/3'),
1830
IPv6Network('C000::/3'), IPv6Network('E000::/4'),
1831
IPv6Network('F000::/5'), IPv6Network('F800::/6'),
1832
IPv6Network('FE00::/9')]
1834
return any(self in x for x in reserved_networks)
1837
def is_link_local(self):
1838
"""Test if the address is reserved for link-local.
1841
A boolean, True if the address is reserved per RFC 4291.
1844
linklocal_network = IPv6Network('fe80::/10')
1845
return self in linklocal_network
1848
def is_site_local(self):
1849
"""Test if the address is reserved for site-local.
1851
Note that the site-local address space has been deprecated by RFC 3879.
1852
Use is_private to test if this address is in the space of unique local
1853
addresses as defined by RFC 4193.
1856
A boolean, True if the address is reserved per RFC 3513 2.5.6.
1859
sitelocal_network = IPv6Network('fec0::/10')
1860
return self in sitelocal_network
1863
@functools.lru_cache()
1864
def is_private(self):
1865
"""Test if this address is allocated for private networks.
1868
A boolean, True if the address is reserved per
1869
iana-ipv6-special-registry.
1872
return (self in IPv6Network('::1/128') or
1873
self in IPv6Network('::/128') or
1874
self in IPv6Network('::ffff:0:0/96') or
1875
self in IPv6Network('100::/64') or
1876
self in IPv6Network('2001::/23') or
1877
self in IPv6Network('2001:2::/48') or
1878
self in IPv6Network('2001:db8::/32') or
1879
self in IPv6Network('2001:10::/28') or
1880
self in IPv6Network('fc00::/7') or
1881
self in IPv6Network('fe80::/10'))
1884
def is_global(self):
1885
"""Test if this address is allocated for public networks.
1888
A boolean, true if the address is not reserved per
1889
iana-ipv6-special-registry.
1892
return not self.is_private
1895
def is_unspecified(self):
1896
"""Test if the address is unspecified.
1899
A boolean, True if this is the unspecified address as defined in
1903
return self._ip == 0
1906
def is_loopback(self):
1907
"""Test if the address is a loopback address.
1910
A boolean, True if the address is a loopback address as defined in
1914
return self._ip == 1
1917
def ipv4_mapped(self):
1918
"""Return the IPv4 mapped address.
1921
If the IPv6 address is a v4 mapped address, return the
1922
IPv4 mapped address. Return None otherwise.
1925
if (self._ip >> 32) != 0xFFFF:
1927
return IPv4Address(self._ip & 0xFFFFFFFF)
1931
"""Tuple of embedded teredo IPs.
1934
Tuple of the (server, client) IPs or None if the address
1935
doesn't appear to be a teredo address (doesn't start with
1939
if (self._ip >> 96) != 0x20010000:
1941
return (IPv4Address((self._ip >> 64) & 0xFFFFFFFF),
1942
IPv4Address(~self._ip & 0xFFFFFFFF))
1945
def sixtofour(self):
1946
"""Return the IPv4 6to4 embedded address.
1949
The IPv4 6to4-embedded address if present or None if the
1950
address doesn't appear to contain a 6to4 embedded address.
1953
if (self._ip >> 112) != 0x2002:
1955
return IPv4Address((self._ip >> 80) & 0xFFFFFFFF)
1958
class IPv6Interface(IPv6Address):
1960
def __init__(self, address):
1961
if isinstance(address, (bytes, int)):
1962
IPv6Address.__init__(self, address)
1963
self.network = IPv6Network(self._ip)
1964
self._prefixlen = self._max_prefixlen
1967
addr = _split_optional_netmask(address)
1968
IPv6Address.__init__(self, addr[0])
1969
self.network = IPv6Network(address, strict=False)
1970
self.netmask = self.network.netmask
1971
self._prefixlen = self.network._prefixlen
1972
self.hostmask = self.network.hostmask
1975
return '%s/%d' % (self._string_from_ip_int(self._ip),
1976
self.network.prefixlen)
1978
def __eq__(self, other):
1979
address_equal = IPv6Address.__eq__(self, other)
1980
if not address_equal or address_equal is NotImplemented:
1981
return address_equal
1983
return self.network == other.network
1984
except AttributeError:
1985
# An interface with an associated network is NOT the
1986
# same as an unassociated address. That's why the hash
1987
# takes the extra info into account.
1990
def __lt__(self, other):
1991
address_less = IPv6Address.__lt__(self, other)
1992
if address_less is NotImplemented:
1993
return NotImplemented
1995
return self.network < other.network
1996
except AttributeError:
1997
# We *do* allow addresses and interfaces to be sorted. The
1998
# unassociated address is considered less than all interfaces.
2002
return self._ip ^ self._prefixlen ^ int(self.network.network_address)
2006
return IPv6Address(self._ip)
2009
def with_prefixlen(self):
2010
return '%s/%s' % (self._string_from_ip_int(self._ip),
2014
def with_netmask(self):
2015
return '%s/%s' % (self._string_from_ip_int(self._ip),
2019
def with_hostmask(self):
2020
return '%s/%s' % (self._string_from_ip_int(self._ip),
2024
def is_unspecified(self):
2025
return self._ip == 0 and self.network.is_unspecified
2028
def is_loopback(self):
2029
return self._ip == 1 and self.network.is_loopback
2032
class IPv6Network(_BaseV6, _BaseNetwork):
2034
"""This class represents and manipulates 128-bit IPv6 networks.
2036
Attributes: [examples for IPv6('2001:db8::1000/124')]
2037
.network_address: IPv6Address('2001:db8::1000')
2038
.hostmask: IPv6Address('::f')
2039
.broadcast_address: IPv6Address('2001:db8::100f')
2040
.netmask: IPv6Address('ffff:ffff:ffff:ffff:ffff:ffff:ffff:fff0')
2045
# Class to use when creating address objects
2046
_address_class = IPv6Address
2048
def __init__(self, address, strict=True):
2049
"""Instantiate a new IPv6 Network object.
2052
address: A string or integer representing the IPv6 network or the
2053
IP and prefix/netmask.
2055
'2001:db8:0000:0000:0000:0000:0000:0000/128'
2057
are all functionally the same in IPv6. That is to say,
2058
failing to provide a subnetmask will create an object with
2061
Additionally, an integer can be passed, so
2062
IPv6Network('2001:db8::') ==
2063
IPv6Network(42540766411282592856903984951653826560)
2065
IPv6Network(int(IPv6Network('2001:db8::'))) ==
2066
IPv6Network('2001:db8::')
2068
strict: A boolean. If true, ensure that we have been passed
2069
A true network address, eg, 2001:db8::1000/124 and not an
2070
IP address on a network, eg, 2001:db8::1/124.
2073
AddressValueError: If address isn't a valid IPv6 address.
2074
NetmaskValueError: If the netmask isn't valid for
2076
ValueError: If strict was True and a network address was not
2080
_BaseV6.__init__(self, address)
2081
_BaseNetwork.__init__(self, address)
2083
# Efficient constructor from integer.
2084
if isinstance(address, int):
2085
self.network_address = IPv6Address(address)
2086
self._prefixlen = self._max_prefixlen
2087
self.netmask = IPv6Address(self._ALL_ONES)
2090
# Constructing from a packed address
2091
if isinstance(address, bytes):
2092
self.network_address = IPv6Address(address)
2093
self._prefixlen = self._max_prefixlen
2094
self.netmask = IPv6Address(self._ALL_ONES)
2097
# Assume input argument to be string or any object representation
2098
# which converts into a formatted IP prefix string.
2099
addr = _split_optional_netmask(address)
2101
self.network_address = IPv6Address(self._ip_int_from_string(addr[0]))
2104
if self._is_valid_netmask(addr[1]):
2105
self._prefixlen = int(addr[1])
2107
raise NetmaskValueError('%r is not a valid netmask'
2110
self._prefixlen = self._max_prefixlen
2112
self.netmask = IPv6Address(self._ip_int_from_prefix(self._prefixlen))
2114
if (IPv6Address(int(self.network_address) & int(self.netmask)) !=
2115
self.network_address):
2116
raise ValueError('%s has host bits set' % self)
2117
self.network_address = IPv6Address(int(self.network_address) &
2120
if self._prefixlen == (self._max_prefixlen - 1):
2121
self.hosts = self.__iter__
2123
def _is_valid_netmask(self, prefixlen):
2124
"""Verify that the netmask/prefixlen is valid.
2127
prefixlen: A string, the netmask in prefix length format.
2130
A boolean, True if the prefix represents a valid IPv6
2135
prefixlen = int(prefixlen)
2138
return 0 <= prefixlen <= self._max_prefixlen
2141
def is_site_local(self):
2142
"""Test if the address is reserved for site-local.
2144
Note that the site-local address space has been deprecated by RFC 3879.
2145
Use is_private to test if this address is in the space of unique local
2146
addresses as defined by RFC 4193.
2149
A boolean, True if the address is reserved per RFC 3513 2.5.6.
2152
return (self.network_address.is_site_local and
2153
self.broadcast_address.is_site_local)
added
removed
Lib/ipaddress.py
