1 # Copyright 2007 Google Inc. 2 # Licensed to PSF under a Contributor Agreement. 3 4 """A fast, lightweight IPv4/IPv6 manipulation library in Python. 5 6 This library is used to create/poke/manipulate IPv4 and IPv6 addresses 7 and networks. 8 9 """ 10 11 __version__ = '1.0' 12 13 14 import functools 15 16 IPV4LENGTH = 32 17 IPV6LENGTH = 128 18 19 class AddressValueError(ValueError): 20 """A Value Error related to the address.""" 21 22 23 class NetmaskValueError(ValueError): 24 """A Value Error related to the netmask.""" 25 26 27 def ip_address(address): 28 """Take an IP string/int and return an object of the correct type. 29 30 Args: 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. 34 35 Returns: 36 An IPv4Address or IPv6Address object. 37 38 Raises: 39 ValueError: if the *address* passed isn't either a v4 or a v6 40 address 41 42 """ 43 try: 44 return IPv4Address(address) 45 except (AddressValueError, NetmaskValueError): 46 pass 47 48 try: 49 return IPv6Address(address) 50 except (AddressValueError, NetmaskValueError): 51 pass 52 53 raise ValueError('%r does not appear to be an IPv4 or IPv6 address' % 54 address) 55 56 57 def ip_network(address, strict=True): 58 """Take an IP string/int and return an object of the correct type. 59 60 Args: 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. 64 65 Returns: 66 An IPv4Network or IPv6Network object. 67 68 Raises: 69 ValueError: if the string passed isn't either a v4 or a v6 70 address. Or if the network has host bits set. 71 72 """ 73 try: 74 return IPv4Network(address, strict) 75 except (AddressValueError, NetmaskValueError): 76 pass 77 78 try: 79 return IPv6Network(address, strict) 80 except (AddressValueError, NetmaskValueError): 81 pass 82 83 raise ValueError('%r does not appear to be an IPv4 or IPv6 network' % 84 address) 85 86 87 def ip_interface(address): 88 """Take an IP string/int and return an object of the correct type. 89 90 Args: 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. 94 95 Returns: 96 An IPv4Interface or IPv6Interface object. 97 98 Raises: 99 ValueError: if the string passed isn't either a v4 or a v6 100 address. 101 102 Notes: 103 The IPv?Interface classes describe an Address on a particular 104 Network, so they're basically a combination of both the Address 105 and Network classes. 106 107 """ 108 try: 109 return IPv4Interface(address) 110 except (AddressValueError, NetmaskValueError): 111 pass 112 113 try: 114 return IPv6Interface(address) 115 except (AddressValueError, NetmaskValueError): 116 pass 117 118 raise ValueError('%r does not appear to be an IPv4 or IPv6 interface' % 119 address) 120 121 122 def v4_int_to_packed(address): 123 """Represent an address as 4 packed bytes in network (big-endian) order. 124 125 Args: 126 address: An integer representation of an IPv4 IP address. 127 128 Returns: 129 The integer address packed as 4 bytes in network (big-endian) order. 130 131 Raises: 132 ValueError: If the integer is negative or too large to be an 133 IPv4 IP address. 134 135 """ 136 try: 137 return address.to_bytes(4, 'big') 138 except OverflowError: 139 raise ValueError("Address negative or too large for IPv4") 140 141 142 def v6_int_to_packed(address): 143 """Represent an address as 16 packed bytes in network (big-endian) order. 144 145 Args: 146 address: An integer representation of an IPv6 IP address. 147 148 Returns: 149 The integer address packed as 16 bytes in network (big-endian) order. 150 151 """ 152 try: 153 return address.to_bytes(16, 'big') 154 except OverflowError: 155 raise ValueError("Address negative or too large for IPv6") 156 157 158 def _split_optional_netmask(address): 159 """Helper to split the netmask and raise AddressValueError if needed""" 160 addr = str(address).split('/') 161 if len(addr) > 2: 162 raise AddressValueError("Only one '/' permitted in %r" % address) 163 return addr 164 165 166 def _find_address_range(addresses): 167 """Find a sequence of sorted deduplicated IPv#Address. 168 169 Args: 170 addresses: a list of IPv#Address objects. 171 172 Yields: 173 A tuple containing the first and last IP addresses in the sequence. 174 175 """ 176 it = iter(addresses) 177 first = last = next(it) 178 for ip in it: 179 if ip._ip != last._ip + 1: 180 yield first, last 181 first = ip 182 last = ip 183 yield first, last 184 185 186 def _count_righthand_zero_bits(number, bits): 187 """Count the number of zero bits on the right hand side. 188 189 Args: 190 number: an integer. 191 bits: maximum number of bits to count. 192 193 Returns: 194 The number of zero bits on the right hand side of the number. 195 196 """ 197 if number == 0: 198 return bits 199 return min(bits, (~number & (number-1)).bit_length()) 200 201 202 def summarize_address_range(first, last): 203 """Summarize a network range given the first and last IP addresses. 204 205 Example: 206 >>> list(summarize_address_range(IPv4Address('192.0.2.0'), 207 ... IPv4Address('192.0.2.130'))) 208 ... #doctest: +NORMALIZE_WHITESPACE 209 [IPv4Network('192.0.2.0/25'), IPv4Network('192.0.2.128/31'), 210 IPv4Network('192.0.2.130/32')] 211 212 Args: 213 first: the first IPv4Address or IPv6Address in the range. 214 last: the last IPv4Address or IPv6Address in the range. 215 216 Returns: 217 An iterator of the summarized IPv(4|6) network objects. 218 219 Raise: 220 TypeError: 221 If the first and last objects are not IP addresses. 222 If the first and last objects are not the same version. 223 ValueError: 224 If the last object is not greater than the first. 225 If the version of the first address is not 4 or 6. 226 227 """ 228 if (not (isinstance(first, _BaseAddress) and 229 isinstance(last, _BaseAddress))): 230 raise TypeError('first and last must be IP addresses, not networks') 231 if first.version != last.version: 232 raise TypeError("%s and %s are not of the same version" % ( 233 first, last)) 234 if first > last: 235 raise ValueError('last IP address must be greater than first') 236 237 if first.version == 4: 238 ip = IPv4Network 239 elif first.version == 6: 240 ip = IPv6Network 241 else: 242 raise ValueError('unknown IP version') 243 244 ip_bits = first._max_prefixlen 245 first_int = first._ip 246 last_int = last._ip 247 while first_int <= last_int: 248 nbits = min(_count_righthand_zero_bits(first_int, ip_bits), 249 (last_int - first_int + 1).bit_length() - 1) 250 net = ip((first_int, ip_bits - nbits)) 251 yield net 252 first_int += 1 << nbits 253 if first_int - 1 == ip._ALL_ONES: 254 break 255 256 257 def _collapse_addresses_internal(addresses): 258 """Loops through the addresses, collapsing concurrent netblocks. 259 260 Example: 261 262 ip1 = IPv4Network('192.0.2.0/26') 263 ip2 = IPv4Network('192.0.2.64/26') 264 ip3 = IPv4Network('192.0.2.128/26') 265 ip4 = IPv4Network('192.0.2.192/26') 266 267 _collapse_addresses_internal([ip1, ip2, ip3, ip4]) -> 268 [IPv4Network('192.0.2.0/24')] 269 270 This shouldn't be called directly; it is called via 271 collapse_addresses([]). 272 273 Args: 274 addresses: A list of IPv4Network's or IPv6Network's 275 276 Returns: 277 A list of IPv4Network's or IPv6Network's depending on what we were 278 passed. 279 280 """ 281 # First merge 282 to_merge = list(addresses) 283 subnets = {} 284 while to_merge: 285 net = to_merge.pop() 286 supernet = net.supernet() 287 existing = subnets.get(supernet) 288 if existing is None: 289 subnets[supernet] = net 290 elif existing != net: 291 # Merge consecutive subnets 292 del subnets[supernet] 293 to_merge.append(supernet) 294 # Then iterate over resulting networks, skipping subsumed subnets 295 last = None 296 for net in sorted(subnets.values()): 297 if last is not None: 298 # Since they are sorted, last.network_address <= net.network_address 299 # is a given. 300 if last.broadcast_address >= net.broadcast_address: 301 continue 302 yield net 303 last = net 304 305 306 def collapse_addresses(addresses): 307 """Collapse a list of IP objects. 308 309 Example: 310 collapse_addresses([IPv4Network('192.0.2.0/25'), 311 IPv4Network('192.0.2.128/25')]) -> 312 [IPv4Network('192.0.2.0/24')] 313 314 Args: 315 addresses: An iterator of IPv4Network or IPv6Network objects. 316 317 Returns: 318 An iterator of the collapsed IPv(4|6)Network objects. 319 320 Raises: 321 TypeError: If passed a list of mixed version objects. 322 323 """ 324 addrs = [] 325 ips = [] 326 nets = [] 327 328 # split IP addresses and networks 329 for ip in addresses: 330 if isinstance(ip, _BaseAddress): 331 if ips and ips[-1]._version != ip._version: 332 raise TypeError("%s and %s are not of the same version" % ( 333 ip, ips[-1])) 334 ips.append(ip) 335 elif ip._prefixlen == ip._max_prefixlen: 336 if ips and ips[-1]._version != ip._version: 337 raise TypeError("%s and %s are not of the same version" % ( 338 ip, ips[-1])) 339 try: 340 ips.append(ip.ip) 341 except AttributeError: 342 ips.append(ip.network_address) 343 else: 344 if nets and nets[-1]._version != ip._version: 345 raise TypeError("%s and %s are not of the same version" % ( 346 ip, nets[-1])) 347 nets.append(ip) 348 349 # sort and dedup 350 ips = sorted(set(ips)) 351 352 # find consecutive address ranges in the sorted sequence and summarize them 353 if ips: 354 for first, last in _find_address_range(ips): 355 addrs.extend(summarize_address_range(first, last)) 356 357 return _collapse_addresses_internal(addrs + nets) 358 359 360 def get_mixed_type_key(obj): 361 """Return a key suitable for sorting between networks and addresses. 362 363 Address and Network objects are not sortable by default; they're 364 fundamentally different so the expression 365 366 IPv4Address('192.0.2.0') <= IPv4Network('192.0.2.0/24') 367 368 doesn't make any sense. There are some times however, where you may wish 369 to have ipaddress sort these for you anyway. If you need to do this, you 370 can use this function as the key= argument to sorted(). 371 372 Args: 373 obj: either a Network or Address object. 374 Returns: 375 appropriate key. 376 377 """ 378 if isinstance(obj, _BaseNetwork): 379 return obj._get_networks_key() 380 elif isinstance(obj, _BaseAddress): 381 return obj._get_address_key() 382 return NotImplemented 383 384 385 class _IPAddressBase: 386 387 """The mother class.""" 388 389 __slots__ = () 390 391 @property 392 def exploded(self): 393 """Return the longhand version of the IP address as a string.""" 394 return self._explode_shorthand_ip_string() 395 396 @property 397 def compressed(self): 398 """Return the shorthand version of the IP address as a string.""" 399 return str(self) 400 401 @property 402 def reverse_pointer(self): 403 """The name of the reverse DNS pointer for the IP address, e.g.: 404 >>> ipaddress.ip_address("127.0.0.1").reverse_pointer 405 '1.0.0.127.in-addr.arpa' 406 >>> ipaddress.ip_address("2001:db8::1").reverse_pointer 407 '1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa' 408 409 """ 410 return self._reverse_pointer() 411 412 @property 413 def version(self): 414 msg = '%200s has no version specified' % (type(self),) 415 raise NotImplementedError(msg) 416 417 def _check_int_address(self, address): 418 if address < 0: 419 msg = "%d (< 0) is not permitted as an IPv%d address" 420 raise AddressValueError(msg % (address, self._version)) 421 if address > self._ALL_ONES: 422 msg = "%d (>= 2**%d) is not permitted as an IPv%d address" 423 raise AddressValueError(msg % (address, self._max_prefixlen, 424 self._version)) 425 426 def _check_packed_address(self, address, expected_len): 427 address_len = len(address) 428 if address_len != expected_len: 429 msg = "%r (len %d != %d) is not permitted as an IPv%d address" 430 raise AddressValueError(msg % (address, address_len, 431 expected_len, self._version)) 432 433 @classmethod 434 def _ip_int_from_prefix(cls, prefixlen): 435 """Turn the prefix length into a bitwise netmask 436 437 Args: 438 prefixlen: An integer, the prefix length. 439 440 Returns: 441 An integer. 442 443 """ 444 return cls._ALL_ONES ^ (cls._ALL_ONES >> prefixlen) 445 446 @classmethod 447 def _prefix_from_ip_int(cls, ip_int): 448 """Return prefix length from the bitwise netmask. 449 450 Args: 451 ip_int: An integer, the netmask in expanded bitwise format 452 453 Returns: 454 An integer, the prefix length. 455 456 Raises: 457 ValueError: If the input intermingles zeroes & ones 458 """ 459 trailing_zeroes = _count_righthand_zero_bits(ip_int, 460 cls._max_prefixlen) 461 prefixlen = cls._max_prefixlen - trailing_zeroes 462 leading_ones = ip_int >> trailing_zeroes 463 all_ones = (1 << prefixlen) - 1 464 if leading_ones != all_ones: 465 byteslen = cls._max_prefixlen // 8 466 details = ip_int.to_bytes(byteslen, 'big') 467 msg = 'Netmask pattern %r mixes zeroes & ones' 468 raise ValueError(msg % details) 469 return prefixlen 470 471 @classmethod 472 def _report_invalid_netmask(cls, netmask_str): 473 msg = '%r is not a valid netmask' % netmask_str 474 raise NetmaskValueError(msg) from None 475 476 @classmethod 477 def _prefix_from_prefix_string(cls, prefixlen_str): 478 """Return prefix length from a numeric string 479 480 Args: 481 prefixlen_str: The string to be converted 482 483 Returns: 484 An integer, the prefix length. 485 486 Raises: 487 NetmaskValueError: If the input is not a valid netmask 488 """ 489 # int allows a leading +/- as well as surrounding whitespace, 490 # so we ensure that isn't the case 491 if not _BaseV4._DECIMAL_DIGITS.issuperset(prefixlen_str): 492 cls._report_invalid_netmask(prefixlen_str) 493 try: 494 prefixlen = int(prefixlen_str) 495 except ValueError: 496 cls._report_invalid_netmask(prefixlen_str) 497 if not (0 <= prefixlen <= cls._max_prefixlen): 498 cls._report_invalid_netmask(prefixlen_str) 499 return prefixlen 500 501 @classmethod 502 def _prefix_from_ip_string(cls, ip_str): 503 """Turn a netmask/hostmask string into a prefix length 504 505 Args: 506 ip_str: The netmask/hostmask to be converted 507 508 Returns: 509 An integer, the prefix length. 510 511 Raises: 512 NetmaskValueError: If the input is not a valid netmask/hostmask 513 """ 514 # Parse the netmask/hostmask like an IP address. 515 try: 516 ip_int = cls._ip_int_from_string(ip_str) 517 except AddressValueError: 518 cls._report_invalid_netmask(ip_str) 519 520 # Try matching a netmask (this would be /1*0*/ as a bitwise regexp). 521 # Note that the two ambiguous cases (all-ones and all-zeroes) are 522 # treated as netmasks. 523 try: 524 return cls._prefix_from_ip_int(ip_int) 525 except ValueError: 526 pass 527 528 # Invert the bits, and try matching a /0+1+/ hostmask instead. 529 ip_int ^= cls._ALL_ONES 530 try: 531 return cls._prefix_from_ip_int(ip_int) 532 except ValueError: 533 cls._report_invalid_netmask(ip_str) 534 535 def __reduce__(self): 536 return self.__class__, (str(self),) 537 538 539 @functools.total_ordering 540 class _BaseAddress(_IPAddressBase): 541 542 """A generic IP object. 543 544 This IP class contains the version independent methods which are 545 used by single IP addresses. 546 """ 547 548 __slots__ = () 549 550 def __int__(self): 551 return self._ip 552 553 def __eq__(self, other): 554 try: 555 return (self._ip == other._ip 556 and self._version == other._version) 557 except AttributeError: 558 return NotImplemented 559 560 def __lt__(self, other): 561 if not isinstance(other, _BaseAddress): 562 return NotImplemented 563 if self._version != other._version: 564 raise TypeError('%s and %s are not of the same version' % ( 565 self, other)) 566 if self._ip != other._ip: 567 return self._ip < other._ip 568 return False 569 570 # Shorthand for Integer addition and subtraction. This is not 571 # meant to ever support addition/subtraction of addresses. 572 def __add__(self, other): 573 if not isinstance(other, int): 574 return NotImplemented 575 return self.__class__(int(self) + other) 576 577 def __sub__(self, other): 578 if not isinstance(other, int): 579 return NotImplemented 580 return self.__class__(int(self) - other) 581 582 def __repr__(self): 583 return '%s(%r)' % (self.__class__.__name__, str(self)) 584 585 def __str__(self): 586 return str(self._string_from_ip_int(self._ip)) 587 588 def __hash__(self): 589 return hash(hex(int(self._ip))) 590 591 def _get_address_key(self): 592 return (self._version, self) 593 594 def __reduce__(self): 595 return self.__class__, (self._ip,) 596 597 598 @functools.total_ordering 599 class _BaseNetwork(_IPAddressBase): 600 601 """A generic IP network object. 602 603 This IP class contains the version independent methods which are 604 used by networks. 605 606 """ 607 def __init__(self, address): 608 self._cache = {} 609 610 def __repr__(self): 611 return '%s(%r)' % (self.__class__.__name__, str(self)) 612 613 def __str__(self): 614 return '%s/%d' % (self.network_address, self.prefixlen) 615 616 def hosts(self): 617 """Generate Iterator over usable hosts in a network. 618 619 This is like __iter__ except it doesn't return the network 620 or broadcast addresses. 621 622 """ 623 network = int(self.network_address) 624 broadcast = int(self.broadcast_address) 625 for x in range(network + 1, broadcast): 626 yield self._address_class(x) 627 628 def __iter__(self): 629 network = int(self.network_address) 630 broadcast = int(self.broadcast_address) 631 for x in range(network, broadcast + 1): 632 yield self._address_class(x) 633 634 def __getitem__(self, n): 635 network = int(self.network_address) 636 broadcast = int(self.broadcast_address) 637 if n >= 0: 638 if network + n > broadcast: 639 raise IndexError('address out of range') 640 return self._address_class(network + n) 641 else: 642 n += 1 643 if broadcast + n < network: 644 raise IndexError('address out of range') 645 return self._address_class(broadcast + n) 646 647 def __lt__(self, other): 648 if not isinstance(other, _BaseNetwork): 649 return NotImplemented 650 if self._version != other._version: 651 raise TypeError('%s and %s are not of the same version' % ( 652 self, other)) 653 if self.network_address != other.network_address: 654 return self.network_address < other.network_address 655 if self.netmask != other.netmask: 656 return self.netmask < other.netmask 657 return False 658 659 def __eq__(self, other): 660 try: 661 return (self._version == other._version and 662 self.network_address == other.network_address and 663 int(self.netmask) == int(other.netmask)) 664 except AttributeError: 665 return NotImplemented 666 667 def __hash__(self): 668 return hash(int(self.network_address) ^ int(self.netmask)) 669 670 def __contains__(self, other): 671 # always false if one is v4 and the other is v6. 672 if self._version != other._version: 673 return False 674 # dealing with another network. 675 if isinstance(other, _BaseNetwork): 676 return False 677 # dealing with another address 678 else: 679 # address 680 return (int(self.network_address) <= int(other._ip) <= 681 int(self.broadcast_address)) 682 683 def overlaps(self, other): 684 """Tell if self is partly contained in other.""" 685 return self.network_address in other or ( 686 self.broadcast_address in other or ( 687 other.network_address in self or ( 688 other.broadcast_address in self))) 689 690 @property 691 def broadcast_address(self): 692 x = self._cache.get('broadcast_address') 693 if x is None: 694 x = self._address_class(int(self.network_address) | 695 int(self.hostmask)) 696 self._cache['broadcast_address'] = x 697 return x 698 699 @property 700 def hostmask(self): 701 x = self._cache.get('hostmask') 702 if x is None: 703 x = self._address_class(int(self.netmask) ^ self._ALL_ONES) 704 self._cache['hostmask'] = x 705 return x 706 707 @property 708 def with_prefixlen(self): 709 return '%s/%d' % (self.network_address, self._prefixlen) 710 711 @property 712 def with_netmask(self): 713 return '%s/%s' % (self.network_address, self.netmask) 714 715 @property 716 def with_hostmask(self): 717 return '%s/%s' % (self.network_address, self.hostmask) 718 719 @property 720 def num_addresses(self): 721 """Number of hosts in the current subnet.""" 722 return int(self.broadcast_address) - int(self.network_address) + 1 723 724 @property 725 def _address_class(self): 726 # Returning bare address objects (rather than interfaces) allows for 727 # more consistent behaviour across the network address, broadcast 728 # address and individual host addresses. 729 msg = '%200s has no associated address class' % (type(self),) 730 raise NotImplementedError(msg) 731 732 @property 733 def prefixlen(self): 734 return self._prefixlen 735 736 def address_exclude(self, other): 737 """Remove an address from a larger block. 738 739 For example: 740 741 addr1 = ip_network('192.0.2.0/28') 742 addr2 = ip_network('192.0.2.1/32') 743 list(addr1.address_exclude(addr2)) = 744 [IPv4Network('192.0.2.0/32'), IPv4Network('192.0.2.2/31'), 745 IPv4Network('192.0.2.4/30'), IPv4Network('192.0.2.8/29')] 746 747 or IPv6: 748 749 addr1 = ip_network('2001:db8::1/32') 750 addr2 = ip_network('2001:db8::1/128') 751 list(addr1.address_exclude(addr2)) = 752 [ip_network('2001:db8::1/128'), 753 ip_network('2001:db8::2/127'), 754 ip_network('2001:db8::4/126'), 755 ip_network('2001:db8::8/125'), 756 ... 757 ip_network('2001:db8:8000::/33')] 758 759 Args: 760 other: An IPv4Network or IPv6Network object of the same type. 761 762 Returns: 763 An iterator of the IPv(4|6)Network objects which is self 764 minus other. 765 766 Raises: 767 TypeError: If self and other are of differing address 768 versions, or if other is not a network object. 769 ValueError: If other is not completely contained by self. 770 771 """ 772 if not self._version == other._version: 773 raise TypeError("%s and %s are not of the same version" % ( 774 self, other)) 775 776 if not isinstance(other, _BaseNetwork): 777 raise TypeError("%s is not a network object" % other) 778 779 if not (other.network_address >= self.network_address and 780 other.broadcast_address <= self.broadcast_address): 781 raise ValueError('%s not contained in %s' % (other, self)) 782 if other == self: 783 return 784 785 # Make sure we're comparing the network of other. 786 other = other.__class__('%s/%s' % (other.network_address, 787 other.prefixlen)) 788 789 s1, s2 = self.subnets() 790 while s1 != other and s2 != other: 791 if (other.network_address >= s1.network_address and 792 other.broadcast_address <= s1.broadcast_address): 793 yield s2 794 s1, s2 = s1.subnets() 795 elif (other.network_address >= s2.network_address and 796 other.broadcast_address <= s2.broadcast_address): 797 yield s1 798 s1, s2 = s2.subnets() 799 else: 800 # If we got here, there's a bug somewhere. 801 raise AssertionError('Error performing exclusion: ' 802 's1: %s s2: %s other: %s' % 803 (s1, s2, other)) 804 if s1 == other: 805 yield s2 806 elif s2 == other: 807 yield s1 808 else: 809 # If we got here, there's a bug somewhere. 810 raise AssertionError('Error performing exclusion: ' 811 's1: %s s2: %s other: %s' % 812 (s1, s2, other)) 813 814 def compare_networks(self, other): 815 """Compare two IP objects. 816 817 This is only concerned about the comparison of the integer 818 representation of the network addresses. This means that the 819 host bits aren't considered at all in this method. If you want 820 to compare host bits, you can easily enough do a 821 'HostA._ip < HostB._ip' 822 823 Args: 824 other: An IP object. 825 826 Returns: 827 If the IP versions of self and other are the same, returns: 828 829 -1 if self < other: 830 eg: IPv4Network('192.0.2.0/25') < IPv4Network('192.0.2.128/25') 831 IPv6Network('2001:db8::1000/124') < 832 IPv6Network('2001:db8::2000/124') 833 0 if self == other 834 eg: IPv4Network('192.0.2.0/24') == IPv4Network('192.0.2.0/24') 835 IPv6Network('2001:db8::1000/124') == 836 IPv6Network('2001:db8::1000/124') 837 1 if self > other 838 eg: IPv4Network('192.0.2.128/25') > IPv4Network('192.0.2.0/25') 839 IPv6Network('2001:db8::2000/124') > 840 IPv6Network('2001:db8::1000/124') 841 842 Raises: 843 TypeError if the IP versions are different. 844 845 """ 846 # does this need to raise a ValueError? 847 if self._version != other._version: 848 raise TypeError('%s and %s are not of the same type' % ( 849 self, other)) 850 # self._version == other._version below here: 851 if self.network_address < other.network_address: 852 return -1 853 if self.network_address > other.network_address: 854 return 1 855 # self.network_address == other.network_address below here: 856 if self.netmask < other.netmask: 857 return -1 858 if self.netmask > other.netmask: 859 return 1 860 return 0 861 862 def _get_networks_key(self): 863 """Network-only key function. 864 865 Returns an object that identifies this address' network and 866 netmask. This function is a suitable "key" argument for sorted() 867 and list.sort(). 868 869 """ 870 return (self._version, self.network_address, self.netmask) 871 872 def subnets(self, prefixlen_diff=1, new_prefix=None): 873 """The subnets which join to make the current subnet. 874 875 In the case that self contains only one IP 876 (self._prefixlen == 32 for IPv4 or self._prefixlen == 128 877 for IPv6), yield an iterator with just ourself. 878 879 Args: 880 prefixlen_diff: An integer, the amount the prefix length 881 should be increased by. This should not be set if 882 new_prefix is also set. 883 new_prefix: The desired new prefix length. This must be a 884 larger number (smaller prefix) than the existing prefix. 885 This should not be set if prefixlen_diff is also set. 886 887 Returns: 888 An iterator of IPv(4|6) objects. 889 890 Raises: 891 ValueError: The prefixlen_diff is too small or too large. 892 OR 893 prefixlen_diff and new_prefix are both set or new_prefix 894 is a smaller number than the current prefix (smaller 895 number means a larger network) 896 897 """ 898 if self._prefixlen == self._max_prefixlen: 899 yield self 900 return 901 902 if new_prefix is not None: 903 if new_prefix < self._prefixlen: 904 raise ValueError('new prefix must be longer') 905 if prefixlen_diff != 1: 906 raise ValueError('cannot set prefixlen_diff and new_prefix') 907 prefixlen_diff = new_prefix - self._prefixlen 908 909 if prefixlen_diff < 0: 910 raise ValueError('prefix length diff must be > 0') 911 new_prefixlen = self._prefixlen + prefixlen_diff 912 913 if new_prefixlen > self._max_prefixlen: 914 raise ValueError( 915 'prefix length diff %d is invalid for netblock %s' % ( 916 new_prefixlen, self)) 917 918 start = int(self.network_address) 919 end = int(self.broadcast_address) + 1 920 step = (int(self.hostmask) + 1) >> prefixlen_diff 921 for new_addr in range(start, end, step): 922 current = self.__class__((new_addr, new_prefixlen)) 923 yield current 924 925 def supernet(self, prefixlen_diff=1, new_prefix=None): 926 """The supernet containing the current network. 927 928 Args: 929 prefixlen_diff: An integer, the amount the prefix length of 930 the network should be decreased by. For example, given a 931 /24 network and a prefixlen_diff of 3, a supernet with a 932 /21 netmask is returned. 933 934 Returns: 935 An IPv4 network object. 936 937 Raises: 938 ValueError: If self.prefixlen - prefixlen_diff < 0. I.e., you have 939 a negative prefix length. 940 OR 941 If prefixlen_diff and new_prefix are both set or new_prefix is a 942 larger number than the current prefix (larger number means a 943 smaller network) 944 945 """ 946 if self._prefixlen == 0: 947 return self 948 949 if new_prefix is not None: 950 if new_prefix > self._prefixlen: 951 raise ValueError('new prefix must be shorter') 952 if prefixlen_diff != 1: 953 raise ValueError('cannot set prefixlen_diff and new_prefix') 954 prefixlen_diff = self._prefixlen - new_prefix 955 956 new_prefixlen = self.prefixlen - prefixlen_diff 957 if new_prefixlen < 0: 958 raise ValueError( 959 'current prefixlen is %d, cannot have a prefixlen_diff of %d' % 960 (self.prefixlen, prefixlen_diff)) 961 return self.__class__(( 962 int(self.network_address) & (int(self.netmask) << prefixlen_diff), 963 new_prefixlen 964 )) 965 966 @property 967 def is_multicast(self): 968 """Test if the address is reserved for multicast use. 969 970 Returns: 971 A boolean, True if the address is a multicast address. 972 See RFC 2373 2.7 for details. 973 974 """ 975 return (self.network_address.is_multicast and 976 self.broadcast_address.is_multicast) 977 978 @property 979 def is_reserved(self): 980 """Test if the address is otherwise IETF reserved. 981 982 Returns: 983 A boolean, True if the address is within one of the 984 reserved IPv6 Network ranges. 985 986 """ 987 return (self.network_address.is_reserved and 988 self.broadcast_address.is_reserved) 989 990 @property 991 def is_link_local(self): 992 """Test if the address is reserved for link-local. 993 994 Returns: 995 A boolean, True if the address is reserved per RFC 4291. 996 997 """ 998 return (self.network_address.is_link_local and 999 self.broadcast_address.is_link_local) 1000 1001 @property 1002 def is_private(self): 1003 """Test if this address is allocated for private networks. 1004 1005 Returns: 1006 A boolean, True if the address is reserved per 1007 iana-ipv4-special-registry or iana-ipv6-special-registry. 1008 1009 """ 1010 return (self.network_address.is_private and 1011 self.broadcast_address.is_private) 1012 1013 @property 1014 def is_global(self): 1015 """Test if this address is allocated for public networks. 1016 1017 Returns: 1018 A boolean, True if the address is not reserved per 1019 iana-ipv4-special-registry or iana-ipv6-special-registry. 1020 1021 """ 1022 return not self.is_private 1023 1024 @property 1025 def is_unspecified(self): 1026 """Test if the address is unspecified. 1027 1028 Returns: 1029 A boolean, True if this is the unspecified address as defined in 1030 RFC 2373 2.5.2. 1031 1032 """ 1033 return (self.network_address.is_unspecified and 1034 self.broadcast_address.is_unspecified) 1035 1036 @property 1037 def is_loopback(self): 1038 """Test if the address is a loopback address. 1039 1040 Returns: 1041 A boolean, True if the address is a loopback address as defined in 1042 RFC 2373 2.5.3. 1043 1044 """ 1045 return (self.network_address.is_loopback and 1046 self.broadcast_address.is_loopback) 1047 1048 1049 class _BaseV4: 1050 1051 """Base IPv4 object. 1052 1053 The following methods are used by IPv4 objects in both single IP 1054 addresses and networks. 1055 1056 """ 1057 1058 __slots__ = () 1059 _version = 4 1060 # Equivalent to 255.255.255.255 or 32 bits of 1's. 1061 _ALL_ONES = (2**IPV4LENGTH) - 1 1062 _DECIMAL_DIGITS = frozenset('0123456789') 1063 1064 # the valid octets for host and netmasks. only useful for IPv4. 1065 _valid_mask_octets = frozenset({255, 254, 252, 248, 240, 224, 192, 128, 0}) 1066 1067 _max_prefixlen = IPV4LENGTH 1068 # There are only a handful of valid v4 netmasks, so we cache them all 1069 # when constructed (see _make_netmask()). 1070 _netmask_cache = {} 1071 1072 def _explode_shorthand_ip_string(self): 1073 return str(self) 1074 1075 @classmethod 1076 def _make_netmask(cls, arg): 1077 """Make a (netmask, prefix_len) tuple from the given argument. 1078 1079 Argument can be: 1080 - an integer (the prefix length) 1081 - a string representing the prefix length (e.g. "24") 1082 - a string representing the prefix netmask (e.g. "255.255.255.0") 1083 """ 1084 if arg not in cls._netmask_cache: 1085 if isinstance(arg, int): 1086 prefixlen = arg 1087 else: 1088 try: 1089 # Check for a netmask in prefix length form 1090 prefixlen = cls._prefix_from_prefix_string(arg) 1091 except NetmaskValueError: 1092 # Check for a netmask or hostmask in dotted-quad form. 1093 # This may raise NetmaskValueError. 1094 prefixlen = cls._prefix_from_ip_string(arg) 1095 netmask = IPv4Address(cls._ip_int_from_prefix(prefixlen)) 1096 cls._netmask_cache[arg] = netmask, prefixlen 1097 return cls._netmask_cache[arg] 1098 1099 @classmethod 1100 def _ip_int_from_string(cls, ip_str): 1101 """Turn the given IP string into an integer for comparison. 1102 1103 Args: 1104 ip_str: A string, the IP ip_str. 1105 1106 Returns: 1107 The IP ip_str as an integer. 1108 1109 Raises: 1110 AddressValueError: if ip_str isn't a valid IPv4 Address. 1111 1112 """ 1113 if not ip_str: 1114 raise AddressValueError('Address cannot be empty') 1115 1116 octets = ip_str.split('.') 1117 if len(octets) != 4: 1118 raise AddressValueError("Expected 4 octets in %r" % ip_str) 1119 1120 try: 1121 return int.from_bytes(map(cls._parse_octet, octets), 'big') 1122 except ValueError as exc: 1123 raise AddressValueError("%s in %r" % (exc, ip_str)) from None 1124 1125 @classmethod 1126 def _parse_octet(cls, octet_str): 1127 """Convert a decimal octet into an integer. 1128 1129 Args: 1130 octet_str: A string, the number to parse. 1131 1132 Returns: 1133 The octet as an integer. 1134 1135 Raises: 1136 ValueError: if the octet isn't strictly a decimal from [0..255]. 1137 1138 """ 1139 if not octet_str: 1140 raise ValueError("Empty octet not permitted") 1141 # Whitelist the characters, since int() allows a lot of bizarre stuff. 1142 if not cls._DECIMAL_DIGITS.issuperset(octet_str): 1143 msg = "Only decimal digits permitted in %r" 1144 raise ValueError(msg % octet_str) 1145 # We do the length check second, since the invalid character error 1146 # is likely to be more informative for the user 1147 if len(octet_str) > 3: 1148 msg = "At most 3 characters permitted in %r" 1149 raise ValueError(msg % octet_str) 1150 # Convert to integer (we know digits are legal) 1151 octet_int = int(octet_str, 10) 1152 # Any octets that look like they *might* be written in octal, 1153 # and which don't look exactly the same in both octal and 1154 # decimal are rejected as ambiguous 1155 if octet_int > 7 and octet_str[0] == '0': 1156 msg = "Ambiguous (octal/decimal) value in %r not permitted" 1157 raise ValueError(msg % octet_str) 1158 if octet_int > 255: 1159 raise ValueError("Octet %d (> 255) not permitted" % octet_int) 1160 return octet_int 1161 1162 @classmethod 1163 def _string_from_ip_int(cls, ip_int): 1164 """Turns a 32-bit integer into dotted decimal notation. 1165 1166 Args: 1167 ip_int: An integer, the IP address. 1168 1169 Returns: 1170 The IP address as a string in dotted decimal notation. 1171 1172 """ 1173 return '.'.join(map(str, ip_int.to_bytes(4, 'big'))) 1174 1175 def _is_valid_netmask(self, netmask): 1176 """Verify that the netmask is valid. 1177 1178 Args: 1179 netmask: A string, either a prefix or dotted decimal 1180 netmask. 1181 1182 Returns: 1183 A boolean, True if the prefix represents a valid IPv4 1184 netmask. 1185 1186 """ 1187 mask = netmask.split('.') 1188 if len(mask) == 4: 1189 try: 1190 for x in mask: 1191 if int(x) not in self._valid_mask_octets: 1192 return False 1193 except ValueError: 1194 # Found something that isn't an integer or isn't valid 1195 return False 1196 for idx, y in enumerate(mask): 1197 if idx > 0 and y > mask[idx - 1]: 1198 return False 1199 return True 1200 try: 1201 netmask = int(netmask) 1202 except ValueError: 1203 return False 1204 return 0 <= netmask <= self._max_prefixlen 1205 1206 def _is_hostmask(self, ip_str): 1207 """Test if the IP string is a hostmask (rather than a netmask). 1208 1209 Args: 1210 ip_str: A string, the potential hostmask. 1211 1212 Returns: 1213 A boolean, True if the IP string is a hostmask. 1214 1215 """ 1216 bits = ip_str.split('.') 1217 try: 1218 parts = [x for x in map(int, bits) if x in self._valid_mask_octets] 1219 except ValueError: 1220 return False 1221 if len(parts) != len(bits): 1222 return False 1223 if parts[0] < parts[-1]: 1224 return True 1225 return False 1226 1227 def _reverse_pointer(self): 1228 """Return the reverse DNS pointer name for the IPv4 address. 1229 1230 This implements the method described in RFC1035 3.5. 1231 1232 """ 1233 reverse_octets = str(self).split('.')[::-1] 1234 return '.'.join(reverse_octets) + '.in-addr.arpa' 1235 1236 @property 1237 def max_prefixlen(self): 1238 return self._max_prefixlen 1239 1240 @property 1241 def version(self): 1242 return self._version 1243 1244 1245 class IPv4Address(_BaseV4, _BaseAddress): 1246 1247 """Represent and manipulate single IPv4 Addresses.""" 1248 1249 __slots__ = ('_ip', '__weakref__') 1250 1251 def __init__(self, address): 1252 1253 """ 1254 Args: 1255 address: A string or integer representing the IP 1256 1257 Additionally, an integer can be passed, so 1258 IPv4Address('192.0.2.1') == IPv4Address(3221225985). 1259 or, more generally 1260 IPv4Address(int(IPv4Address('192.0.2.1'))) == 1261 IPv4Address('192.0.2.1') 1262 1263 Raises: 1264 AddressValueError: If ipaddress isn't a valid IPv4 address. 1265 1266 """ 1267 # Efficient constructor from integer. 1268 if isinstance(address, int): 1269 self._check_int_address(address) 1270 self._ip = address 1271 return 1272 1273 # Constructing from a packed address 1274 if isinstance(address, bytes): 1275 self._check_packed_address(address, 4) 1276 self._ip = int.from_bytes(address, 'big') 1277 return 1278 1279 # Assume input argument to be string or any object representation 1280 # which converts into a formatted IP string. 1281 addr_str = str(address) 1282 if '/' in addr_str: 1283 raise AddressValueError("Unexpected '/' in %r" % address) 1284 self._ip = self._ip_int_from_string(addr_str) 1285 1286 @property 1287 def packed(self): 1288 """The binary representation of this address.""" 1289 return v4_int_to_packed(self._ip) 1290 1291 @property 1292 def is_reserved(self): 1293 """Test if the address is otherwise IETF reserved. 1294 1295 Returns: 1296 A boolean, True if the address is within the 1297 reserved IPv4 Network range. 1298 1299 """ 1300 return self in self._constants._reserved_network 1301 1302 @property 1303 @functools.lru_cache() 1304 def is_private(self): 1305 """Test if this address is allocated for private networks. 1306 1307 Returns: 1308 A boolean, True if the address is reserved per 1309 iana-ipv4-special-registry. 1310 1311 """ 1312 return any(self in net for net in self._constants._private_networks) 1313 1314 @property 1315 @functools.lru_cache() 1316 def is_global(self): 1317 return self not in self._constants._public_network and not self.is_private 1318 1319 @property 1320 def is_multicast(self): 1321 """Test if the address is reserved for multicast use. 1322 1323 Returns: 1324 A boolean, True if the address is multicast. 1325 See RFC 3171 for details. 1326 1327 """ 1328 return self in self._constants._multicast_network 1329 1330 @property 1331 def is_unspecified(self): 1332 """Test if the address is unspecified. 1333 1334 Returns: 1335 A boolean, True if this is the unspecified address as defined in 1336 RFC 5735 3. 1337 1338 """ 1339 return self == self._constants._unspecified_address 1340 1341 @property 1342 def is_loopback(self): 1343 """Test if the address is a loopback address. 1344 1345 Returns: 1346 A boolean, True if the address is a loopback per RFC 3330. 1347 1348 """ 1349 return self in self._constants._loopback_network 1350 1351 @property 1352 def is_link_local(self): 1353 """Test if the address is reserved for link-local. 1354 1355 Returns: 1356 A boolean, True if the address is link-local per RFC 3927. 1357 1358 """ 1359 return self in self._constants._linklocal_network 1360 1361 1362 class IPv4Interface(IPv4Address): 1363 1364 def __init__(self, address): 1365 if isinstance(address, (bytes, int)): 1366 IPv4Address.__init__(self, address) 1367 self.network = IPv4Network(self._ip) 1368 self._prefixlen = self._max_prefixlen 1369 return 1370 1371 if isinstance(address, tuple): 1372 IPv4Address.__init__(self, address[0]) 1373 if len(address) > 1: 1374 self._prefixlen = int(address[1]) 1375 else: 1376 self._prefixlen = self._max_prefixlen 1377 1378 self.network = IPv4Network(address, strict=False) 1379 self.netmask = self.network.netmask 1380 self.hostmask = self.network.hostmask 1381 return 1382 1383 addr = _split_optional_netmask(address) 1384 IPv4Address.__init__(self, addr[0]) 1385 1386 self.network = IPv4Network(address, strict=False) 1387 self._prefixlen = self.network._prefixlen 1388 1389 self.netmask = self.network.netmask 1390 self.hostmask = self.network.hostmask 1391 1392 def __str__(self): 1393 return '%s/%d' % (self._string_from_ip_int(self._ip), 1394 self.network.prefixlen) 1395 1396 def __eq__(self, other): 1397 address_equal = IPv4Address.__eq__(self, other) 1398 if not address_equal or address_equal is NotImplemented: 1399 return address_equal 1400 try: 1401 return self.network == other.network 1402 except AttributeError: 1403 # An interface with an associated network is NOT the 1404 # same as an unassociated address. That's why the hash 1405 # takes the extra info into account. 1406 return False 1407 1408 def __lt__(self, other): 1409 address_less = IPv4Address.__lt__(self, other) 1410 if address_less is NotImplemented: 1411 return NotImplemented 1412 try: 1413 return self.network < other.network 1414 except AttributeError: 1415 # We *do* allow addresses and interfaces to be sorted. The 1416 # unassociated address is considered less than all interfaces. 1417 return False 1418 1419 def __hash__(self): 1420 return self._ip ^ self._prefixlen ^ int(self.network.network_address) 1421 1422 __reduce__ = _IPAddressBase.__reduce__ 1423 1424 @property 1425 def ip(self): 1426 return IPv4Address(self._ip) 1427 1428 @property 1429 def with_prefixlen(self): 1430 return '%s/%s' % (self._string_from_ip_int(self._ip), 1431 self._prefixlen) 1432 1433 @property 1434 def with_netmask(self): 1435 return '%s/%s' % (self._string_from_ip_int(self._ip), 1436 self.netmask) 1437 1438 @property 1439 def with_hostmask(self): 1440 return '%s/%s' % (self._string_from_ip_int(self._ip), 1441 self.hostmask) 1442 1443 1444 class IPv4Network(_BaseV4, _BaseNetwork): 1445 1446 """This class represents and manipulates 32-bit IPv4 network + addresses.. 1447 1448 Attributes: [examples for IPv4Network('192.0.2.0/27')] 1449 .network_address: IPv4Address('192.0.2.0') 1450 .hostmask: IPv4Address('0.0.0.31') 1451 .broadcast_address: IPv4Address('192.0.2.32') 1452 .netmask: IPv4Address('255.255.255.224') 1453 .prefixlen: 27 1454 1455 """ 1456 # Class to use when creating address objects 1457 _address_class = IPv4Address 1458 1459 def __init__(self, address, strict=True): 1460 1461 """Instantiate a new IPv4 network object. 1462 1463 Args: 1464 address: A string or integer representing the IP [& network]. 1465 '192.0.2.0/24' 1466 '192.0.2.0/255.255.255.0' 1467 '192.0.0.2/0.0.0.255' 1468 are all functionally the same in IPv4. Similarly, 1469 '192.0.2.1' 1470 '192.0.2.1/255.255.255.255' 1471 '192.0.2.1/32' 1472 are also functionally equivalent. That is to say, failing to 1473 provide a subnetmask will create an object with a mask of /32. 1474 1475 If the mask (portion after the / in the argument) is given in 1476 dotted quad form, it is treated as a netmask if it starts with a 1477 non-zero field (e.g. /255.0.0.0 == /8) and as a hostmask if it 1478 starts with a zero field (e.g. 0.255.255.255 == /8), with the 1479 single exception of an all-zero mask which is treated as a 1480 netmask == /0. If no mask is given, a default of /32 is used. 1481 1482 Additionally, an integer can be passed, so 1483 IPv4Network('192.0.2.1') == IPv4Network(3221225985) 1484 or, more generally 1485 IPv4Interface(int(IPv4Interface('192.0.2.1'))) == 1486 IPv4Interface('192.0.2.1') 1487 1488 Raises: 1489 AddressValueError: If ipaddress isn't a valid IPv4 address. 1490 NetmaskValueError: If the netmask isn't valid for 1491 an IPv4 address. 1492 ValueError: If strict is True and a network address is not 1493 supplied. 1494 1495 """ 1496 _BaseNetwork.__init__(self, address) 1497 1498 # Constructing from a packed address or integer 1499 if isinstance(address, (int, bytes)): 1500 self.network_address = IPv4Address(address) 1501 self.netmask, self._prefixlen = self._make_netmask(self._max_prefixlen) 1502 #fixme: address/network test here. 1503 return 1504 1505 if isinstance(address, tuple): 1506 if len(address) > 1: 1507 arg = address[1] 1508 else: 1509 # We weren't given an address[1] 1510 arg = self._max_prefixlen 1511 self.network_address = IPv4Address(address[0]) 1512 self.netmask, self._prefixlen = self._make_netmask(arg) 1513 packed = int(self.network_address) 1514 if packed & int(self.netmask) != packed: 1515 if strict: 1516 raise ValueError('%s has host bits set' % self) 1517 else: 1518 self.network_address = IPv4Address(packed & 1519 int(self.netmask)) 1520 return 1521 1522 # Assume input argument to be string or any object representation 1523 # which converts into a formatted IP prefix string. 1524 addr = _split_optional_netmask(address) 1525 self.network_address = IPv4Address(self._ip_int_from_string(addr[0])) 1526 1527 if len(addr) == 2: 1528 arg = addr[1] 1529 else: 1530 arg = self._max_prefixlen 1531 self.netmask, self._prefixlen = self._make_netmask(arg) 1532 1533 if strict: 1534 if (IPv4Address(int(self.network_address) & int(self.netmask)) != 1535 self.network_address): 1536 raise ValueError('%s has host bits set' % self) 1537 self.network_address = IPv4Address(int(self.network_address) & 1538 int(self.netmask)) 1539 1540 if self._prefixlen == (self._max_prefixlen - 1): 1541 self.hosts = self.__iter__ 1542 1543 @property 1544 @functools.lru_cache() 1545 def is_global(self): 1546 """Test if this address is allocated for public networks. 1547 1548 Returns: 1549 A boolean, True if the address is not reserved per 1550 iana-ipv4-special-registry. 1551 1552 """ 1553 return (not (self.network_address in IPv4Network('100.64.0.0/10') and 1554 self.broadcast_address in IPv4Network('100.64.0.0/10')) and 1555 not self.is_private) 1556 1557 1558 class _IPv4Constants: 1559 _linklocal_network = IPv4Network('169.254.0.0/16') 1560 1561 _loopback_network = IPv4Network('127.0.0.0/8') 1562 1563 _multicast_network = IPv4Network('224.0.0.0/4') 1564 1565 _public_network = IPv4Network('100.64.0.0/10') 1566 1567 _private_networks = [ 1568 IPv4Network('0.0.0.0/8'), 1569 IPv4Network('10.0.0.0/8'), 1570 IPv4Network('127.0.0.0/8'), 1571 IPv4Network('169.254.0.0/16'), 1572 IPv4Network('172.16.0.0/12'), 1573 IPv4Network('192.0.0.0/29'), 1574 IPv4Network('192.0.0.170/31'), 1575 IPv4Network('192.0.2.0/24'), 1576 IPv4Network('192.168.0.0/16'), 1577 IPv4Network('198.18.0.0/15'), 1578 IPv4Network('198.51.100.0/24'), 1579 IPv4Network('203.0.113.0/24'), 1580 IPv4Network('240.0.0.0/4'), 1581 IPv4Network('255.255.255.255/32'), 1582 ] 1583 1584 _reserved_network = IPv4Network('240.0.0.0/4') 1585 1586 _unspecified_address = IPv4Address('0.0.0.0') 1587 1588 1589 IPv4Address._constants = _IPv4Constants 1590 1591 1592 class _BaseV6: 1593 1594 """Base IPv6 object. 1595 1596 The following methods are used by IPv6 objects in both single IP 1597 addresses and networks. 1598 1599 """ 1600 1601 __slots__ = () 1602 _version = 6 1603 _ALL_ONES = (2**IPV6LENGTH) - 1 1604 _HEXTET_COUNT = 8 1605 _HEX_DIGITS = frozenset('0123456789ABCDEFabcdef') 1606 _max_prefixlen = IPV6LENGTH 1607 1608 # There are only a bunch of valid v6 netmasks, so we cache them all 1609 # when constructed (see _make_netmask()). 1610 _netmask_cache = {} 1611 1612 @classmethod 1613 def _make_netmask(cls, arg): 1614 """Make a (netmask, prefix_len) tuple from the given argument. 1615 1616 Argument can be: 1617 - an integer (the prefix length) 1618 - a string representing the prefix length (e.g. "24") 1619 - a string representing the prefix netmask (e.g. "255.255.255.0") 1620 """ 1621 if arg not in cls._netmask_cache: 1622 if isinstance(arg, int): 1623 prefixlen = arg 1624 else: 1625 prefixlen = cls._prefix_from_prefix_string(arg) 1626 netmask = IPv6Address(cls._ip_int_from_prefix(prefixlen)) 1627 cls._netmask_cache[arg] = netmask, prefixlen 1628 return cls._netmask_cache[arg] 1629 1630 @classmethod 1631 def _ip_int_from_string(cls, ip_str): 1632 """Turn an IPv6 ip_str into an integer. 1633 1634 Args: 1635 ip_str: A string, the IPv6 ip_str. 1636 1637 Returns: 1638 An int, the IPv6 address 1639 1640 Raises: 1641 AddressValueError: if ip_str isn't a valid IPv6 Address. 1642 1643 """ 1644 if not ip_str: 1645 raise AddressValueError('Address cannot be empty') 1646 1647 parts = ip_str.split(':') 1648 1649 # An IPv6 address needs at least 2 colons (3 parts). 1650 _min_parts = 3 1651 if len(parts) < _min_parts: 1652 msg = "At least %d parts expected in %r" % (_min_parts, ip_str) 1653 raise AddressValueError(msg) 1654 1655 # If the address has an IPv4-style suffix, convert it to hexadecimal. 1656 if '.' in parts[-1]: 1657 try: 1658 ipv4_int = IPv4Address(parts.pop())._ip 1659 except AddressValueError as exc: 1660 raise AddressValueError("%s in %r" % (exc, ip_str)) from None 1661 parts.append('%x' % ((ipv4_int >> 16) & 0xFFFF)) 1662 parts.append('%x' % (ipv4_int & 0xFFFF)) 1663 1664 # An IPv6 address can't have more than 8 colons (9 parts). 1665 # The extra colon comes from using the "::" notation for a single 1666 # leading or trailing zero part. 1667 _max_parts = cls._HEXTET_COUNT + 1 1668 if len(parts) > _max_parts: 1669 msg = "At most %d colons permitted in %r" % (_max_parts-1, ip_str) 1670 raise AddressValueError(msg) 1671 1672 # Disregarding the endpoints, find '::' with nothing in between. 1673 # This indicates that a run of zeroes has been skipped. 1674 skip_index = None 1675 for i in range(1, len(parts) - 1): 1676 if not parts[i]: 1677 if skip_index is not None: 1678 # Can't have more than one '::' 1679 msg = "At most one '::' permitted in %r" % ip_str 1680 raise AddressValueError(msg) 1681 skip_index = i 1682 1683 # parts_hi is the number of parts to copy from above/before the '::' 1684 # parts_lo is the number of parts to copy from below/after the '::' 1685 if skip_index is not None: 1686 # If we found a '::', then check if it also covers the endpoints. 1687 parts_hi = skip_index 1688 parts_lo = len(parts) - skip_index - 1 1689 if not parts[0]: 1690 parts_hi -= 1 1691 if parts_hi: 1692 msg = "Leading ':' only permitted as part of '::' in %r" 1693 raise AddressValueError(msg % ip_str) # ^: requires ^:: 1694 if not parts[-1]: 1695 parts_lo -= 1 1696 if parts_lo: 1697 msg = "Trailing ':' only permitted as part of '::' in %r" 1698 raise AddressValueError(msg % ip_str) # :$ requires ::$ 1699 parts_skipped = cls._HEXTET_COUNT - (parts_hi + parts_lo) 1700 if parts_skipped < 1: 1701 msg = "Expected at most %d other parts with '::' in %r" 1702 raise AddressValueError(msg % (cls._HEXTET_COUNT-1, ip_str)) 1703 else: 1704 # Otherwise, allocate the entire address to parts_hi. The 1705 # endpoints could still be empty, but _parse_hextet() will check 1706 # for that. 1707 if len(parts) != cls._HEXTET_COUNT: 1708 msg = "Exactly %d parts expected without '::' in %r" 1709 raise AddressValueError(msg % (cls._HEXTET_COUNT, ip_str)) 1710 if not parts[0]: 1711 msg = "Leading ':' only permitted as part of '::' in %r" 1712 raise AddressValueError(msg % ip_str) # ^: requires ^:: 1713 if not parts[-1]: 1714 msg = "Trailing ':' only permitted as part of '::' in %r" 1715 raise AddressValueError(msg % ip_str) # :$ requires ::$ 1716 parts_hi = len(parts) 1717 parts_lo = 0 1718 parts_skipped = 0 1719 1720 try: 1721 # Now, parse the hextets into a 128-bit integer. 1722 ip_int = 0 1723 for i in range(parts_hi): 1724 ip_int <<= 16 1725 ip_int |= cls._parse_hextet(parts[i]) 1726 ip_int <<= 16 * parts_skipped 1727 for i in range(-parts_lo, 0): 1728 ip_int <<= 16 1729 ip_int |= cls._parse_hextet(parts[i]) 1730 return ip_int 1731 except ValueError as exc: 1732 raise AddressValueError("%s in %r" % (exc, ip_str)) from None 1733 1734 @classmethod 1735 def _parse_hextet(cls, hextet_str): 1736 """Convert an IPv6 hextet string into an integer. 1737 1738 Args: 1739 hextet_str: A string, the number to parse. 1740 1741 Returns: 1742 The hextet as an integer. 1743 1744 Raises: 1745 ValueError: if the input isn't strictly a hex number from 1746 [0..FFFF]. 1747 1748 """ 1749 # Whitelist the characters, since int() allows a lot of bizarre stuff. 1750 if not cls._HEX_DIGITS.issuperset(hextet_str): 1751 raise ValueError("Only hex digits permitted in %r" % hextet_str) 1752 # We do the length check second, since the invalid character error 1753 # is likely to be more informative for the user 1754 if len(hextet_str) > 4: 1755 msg = "At most 4 characters permitted in %r" 1756 raise ValueError(msg % hextet_str) 1757 # Length check means we can skip checking the integer value 1758 return int(hextet_str, 16) 1759 1760 @classmethod 1761 def _compress_hextets(cls, hextets): 1762 """Compresses a list of hextets. 1763 1764 Compresses a list of strings, replacing the longest continuous 1765 sequence of "0" in the list with "" and adding empty strings at 1766 the beginning or at the end of the string such that subsequently 1767 calling ":".join(hextets) will produce the compressed version of 1768 the IPv6 address. 1769 1770 Args: 1771 hextets: A list of strings, the hextets to compress. 1772 1773 Returns: 1774 A list of strings. 1775 1776 """ 1777 best_doublecolon_start = -1 1778 best_doublecolon_len = 0 1779 doublecolon_start = -1 1780 doublecolon_len = 0 1781 for index, hextet in enumerate(hextets): 1782 if hextet == '0': 1783 doublecolon_len += 1 1784 if doublecolon_start == -1: 1785 # Start of a sequence of zeros. 1786 doublecolon_start = index 1787 if doublecolon_len > best_doublecolon_len: 1788 # This is the longest sequence of zeros so far. 1789 best_doublecolon_len = doublecolon_len 1790 best_doublecolon_start = doublecolon_start 1791 else: 1792 doublecolon_len = 0 1793 doublecolon_start = -1 1794 1795 if best_doublecolon_len > 1: 1796 best_doublecolon_end = (best_doublecolon_start + 1797 best_doublecolon_len) 1798 # For zeros at the end of the address. 1799 if best_doublecolon_end == len(hextets): 1800 hextets += [''] 1801 hextets[best_doublecolon_start:best_doublecolon_end] = [''] 1802 # For zeros at the beginning of the address. 1803 if best_doublecolon_start == 0: 1804 hextets = [''] + hextets 1805 1806 return hextets 1807 1808 @classmethod 1809 def _string_from_ip_int(cls, ip_int=None): 1810 """Turns a 128-bit integer into hexadecimal notation. 1811 1812 Args: 1813 ip_int: An integer, the IP address. 1814 1815 Returns: 1816 A string, the hexadecimal representation of the address. 1817 1818 Raises: 1819 ValueError: The address is bigger than 128 bits of all ones. 1820 1821 """ 1822 if ip_int is None: 1823 ip_int = int(cls._ip) 1824 1825 if ip_int > cls._ALL_ONES: 1826 raise ValueError('IPv6 address is too large') 1827 1828 hex_str = '%032x' % ip_int 1829 hextets = ['%x' % int(hex_str[x:x+4], 16) for x in range(0, 32, 4)] 1830 1831 hextets = cls._compress_hextets(hextets) 1832 return ':'.join(hextets) 1833 1834 def _explode_shorthand_ip_string(self): 1835 """Expand a shortened IPv6 address. 1836 1837 Args: 1838 ip_str: A string, the IPv6 address. 1839 1840 Returns: 1841 A string, the expanded IPv6 address. 1842 1843 """ 1844 if isinstance(self, IPv6Network): 1845 ip_str = str(self.network_address) 1846 elif isinstance(self, IPv6Interface): 1847 ip_str = str(self.ip) 1848 else: 1849 ip_str = str(self) 1850 1851 ip_int = self._ip_int_from_string(ip_str) 1852 hex_str = '%032x' % ip_int 1853 parts = [hex_str[x:x+4] for x in range(0, 32, 4)] 1854 if isinstance(self, (_BaseNetwork, IPv6Interface)): 1855 return '%s/%d' % (':'.join(parts), self._prefixlen) 1856 return ':'.join(parts) 1857 1858 def _reverse_pointer(self): 1859 """Return the reverse DNS pointer name for the IPv6 address. 1860 1861 This implements the method described in RFC3596 2.5. 1862 1863 """ 1864 reverse_chars = self.exploded[::-1].replace(':', '') 1865 return '.'.join(reverse_chars) + '.ip6.arpa' 1866 1867 @property 1868 def max_prefixlen(self): 1869 return self._max_prefixlen 1870 1871 @property 1872 def version(self): 1873 return self._version 1874 1875 1876 class IPv6Address(_BaseV6, _BaseAddress): 1877 1878 """Represent and manipulate single IPv6 Addresses.""" 1879 1880 __slots__ = ('_ip', '__weakref__') 1881 1882 def __init__(self, address): 1883 """Instantiate a new IPv6 address object. 1884 1885 Args: 1886 address: A string or integer representing the IP 1887 1888 Additionally, an integer can be passed, so 1889 IPv6Address('2001:db8::') == 1890 IPv6Address(42540766411282592856903984951653826560) 1891 or, more generally 1892 IPv6Address(int(IPv6Address('2001:db8::'))) == 1893 IPv6Address('2001:db8::') 1894 1895 Raises: 1896 AddressValueError: If address isn't a valid IPv6 address. 1897 1898 """ 1899 # Efficient constructor from integer. 1900 if isinstance(address, int): 1901 self._check_int_address(address) 1902 self._ip = address 1903 return 1904 1905 # Constructing from a packed address 1906 if isinstance(address, bytes): 1907 self._check_packed_address(address, 16) 1908 self._ip = int.from_bytes(address, 'big') 1909 return 1910 1911 # Assume input argument to be string or any object representation 1912 # which converts into a formatted IP string. 1913 addr_str = str(address) 1914 if '/' in addr_str: 1915 raise AddressValueError("Unexpected '/' in %r" % address) 1916 self._ip = self._ip_int_from_string(addr_str) 1917 1918 @property 1919 def packed(self): 1920 """The binary representation of this address.""" 1921 return v6_int_to_packed(self._ip) 1922 1923 @property 1924 def is_multicast(self): 1925 """Test if the address is reserved for multicast use. 1926 1927 Returns: 1928 A boolean, True if the address is a multicast address. 1929 See RFC 2373 2.7 for details. 1930 1931 """ 1932 return self in self._constants._multicast_network 1933 1934 @property 1935 def is_reserved(self): 1936 """Test if the address is otherwise IETF reserved. 1937 1938 Returns: 1939 A boolean, True if the address is within one of the 1940 reserved IPv6 Network ranges. 1941 1942 """ 1943 return any(self in x for x in self._constants._reserved_networks) 1944 1945 @property 1946 def is_link_local(self): 1947 """Test if the address is reserved for link-local. 1948 1949 Returns: 1950 A boolean, True if the address is reserved per RFC 4291. 1951 1952 """ 1953 return self in self._constants._linklocal_network 1954 1955 @property 1956 def is_site_local(self): 1957 """Test if the address is reserved for site-local. 1958 1959 Note that the site-local address space has been deprecated by RFC 3879. 1960 Use is_private to test if this address is in the space of unique local 1961 addresses as defined by RFC 4193. 1962 1963 Returns: 1964 A boolean, True if the address is reserved per RFC 3513 2.5.6. 1965 1966 """ 1967 return self in self._constants._sitelocal_network 1968 1969 @property 1970 @functools.lru_cache() 1971 def is_private(self): 1972 """Test if this address is allocated for private networks. 1973 1974 Returns: 1975 A boolean, True if the address is reserved per 1976 iana-ipv6-special-registry. 1977 1978 """ 1979 return any(self in net for net in self._constants._private_networks) 1980 1981 @property 1982 def is_global(self): 1983 """Test if this address is allocated for public networks. 1984 1985 Returns: 1986 A boolean, true if the address is not reserved per 1987 iana-ipv6-special-registry. 1988 1989 """ 1990 return not self.is_private 1991 1992 @property 1993 def is_unspecified(self): 1994 """Test if the address is unspecified. 1995 1996 Returns: 1997 A boolean, True if this is the unspecified address as defined in 1998 RFC 2373 2.5.2. 1999 2000 """ 2001 return self._ip == 0 2002 2003 @property 2004 def is_loopback(self): 2005 """Test if the address is a loopback address. 2006 2007 Returns: 2008 A boolean, True if the address is a loopback address as defined in 2009 RFC 2373 2.5.3. 2010 2011 """ 2012 return self._ip == 1 2013 2014 @property 2015 def ipv4_mapped(self): 2016 """Return the IPv4 mapped address. 2017 2018 Returns: 2019 If the IPv6 address is a v4 mapped address, return the 2020 IPv4 mapped address. Return None otherwise. 2021 2022 """ 2023 if (self._ip >> 32) != 0xFFFF: 2024 return None 2025 return IPv4Address(self._ip & 0xFFFFFFFF) 2026 2027 @property 2028 def teredo(self): 2029 """Tuple of embedded teredo IPs. 2030 2031 Returns: 2032 Tuple of the (server, client) IPs or None if the address 2033 doesn't appear to be a teredo address (doesn't start with 2034 2001::/32) 2035 2036 """ 2037 if (self._ip >> 96) != 0x20010000: 2038 return None 2039 return (IPv4Address((self._ip >> 64) & 0xFFFFFFFF), 2040 IPv4Address(~self._ip & 0xFFFFFFFF)) 2041 2042 @property 2043 def sixtofour(self): 2044 """Return the IPv4 6to4 embedded address. 2045 2046 Returns: 2047 The IPv4 6to4-embedded address if present or None if the 2048 address doesn't appear to contain a 6to4 embedded address. 2049 2050 """ 2051 if (self._ip >> 112) != 0x2002: 2052 return None 2053 return IPv4Address((self._ip >> 80) & 0xFFFFFFFF) 2054 2055 2056 class IPv6Interface(IPv6Address): 2057 2058 def __init__(self, address): 2059 if isinstance(address, (bytes, int)): 2060 IPv6Address.__init__(self, address) 2061 self.network = IPv6Network(self._ip) 2062 self._prefixlen = self._max_prefixlen 2063 return 2064 if isinstance(address, tuple): 2065 IPv6Address.__init__(self, address[0]) 2066 if len(address) > 1: 2067 self._prefixlen = int(address[1]) 2068 else: 2069 self._prefixlen = self._max_prefixlen 2070 self.network = IPv6Network(address, strict=False) 2071 self.netmask = self.network.netmask 2072 self.hostmask = self.network.hostmask 2073 return 2074 2075 addr = _split_optional_netmask(address) 2076 IPv6Address.__init__(self, addr[0]) 2077 self.network = IPv6Network(address, strict=False) 2078 self.netmask = self.network.netmask 2079 self._prefixlen = self.network._prefixlen 2080 self.hostmask = self.network.hostmask 2081 2082 def __str__(self): 2083 return '%s/%d' % (self._string_from_ip_int(self._ip), 2084 self.network.prefixlen) 2085 2086 def __eq__(self, other): 2087 address_equal = IPv6Address.__eq__(self, other) 2088 if not address_equal or address_equal is NotImplemented: 2089 return address_equal 2090 try: 2091 return self.network == other.network 2092 except AttributeError: 2093 # An interface with an associated network is NOT the 2094 # same as an unassociated address. That's why the hash 2095 # takes the extra info into account. 2096 return False 2097 2098 def __lt__(self, other): 2099 address_less = IPv6Address.__lt__(self, other) 2100 if address_less is NotImplemented: 2101 return NotImplemented 2102 try: 2103 return self.network < other.network 2104 except AttributeError: 2105 # We *do* allow addresses and interfaces to be sorted. The 2106 # unassociated address is considered less than all interfaces. 2107 return False 2108 2109 def __hash__(self): 2110 return self._ip ^ self._prefixlen ^ int(self.network.network_address) 2111 2112 __reduce__ = _IPAddressBase.__reduce__ 2113 2114 @property 2115 def ip(self): 2116 return IPv6Address(self._ip) 2117 2118 @property 2119 def with_prefixlen(self): 2120 return '%s/%s' % (self._string_from_ip_int(self._ip), 2121 self._prefixlen) 2122 2123 @property 2124 def with_netmask(self): 2125 return '%s/%s' % (self._string_from_ip_int(self._ip), 2126 self.netmask) 2127 2128 @property 2129 def with_hostmask(self): 2130 return '%s/%s' % (self._string_from_ip_int(self._ip), 2131 self.hostmask) 2132 2133 @property 2134 def is_unspecified(self): 2135 return self._ip == 0 and self.network.is_unspecified 2136 2137 @property 2138 def is_loopback(self): 2139 return self._ip == 1 and self.network.is_loopback 2140 2141 2142 class IPv6Network(_BaseV6, _BaseNetwork): 2143 2144 """This class represents and manipulates 128-bit IPv6 networks. 2145 2146 Attributes: [examples for IPv6('2001:db8::1000/124')] 2147 .network_address: IPv6Address('2001:db8::1000') 2148 .hostmask: IPv6Address('::f') 2149 .broadcast_address: IPv6Address('2001:db8::100f') 2150 .netmask: IPv6Address('ffff:ffff:ffff:ffff:ffff:ffff:ffff:fff0') 2151 .prefixlen: 124 2152 2153 """ 2154 2155 # Class to use when creating address objects 2156 _address_class = IPv6Address 2157 2158 def __init__(self, address, strict=True): 2159 """Instantiate a new IPv6 Network object. 2160 2161 Args: 2162 address: A string or integer representing the IPv6 network or the 2163 IP and prefix/netmask. 2164 '2001:db8::/128' 2165 '2001:db8:0000:0000:0000:0000:0000:0000/128' 2166 '2001:db8::' 2167 are all functionally the same in IPv6. That is to say, 2168 failing to provide a subnetmask will create an object with 2169 a mask of /128. 2170 2171 Additionally, an integer can be passed, so 2172 IPv6Network('2001:db8::') == 2173 IPv6Network(42540766411282592856903984951653826560) 2174 or, more generally 2175 IPv6Network(int(IPv6Network('2001:db8::'))) == 2176 IPv6Network('2001:db8::') 2177 2178 strict: A boolean. If true, ensure that we have been passed 2179 A true network address, eg, 2001:db8::1000/124 and not an 2180 IP address on a network, eg, 2001:db8::1/124. 2181 2182 Raises: 2183 AddressValueError: If address isn't a valid IPv6 address. 2184 NetmaskValueError: If the netmask isn't valid for 2185 an IPv6 address. 2186 ValueError: If strict was True and a network address was not 2187 supplied. 2188 2189 """ 2190 _BaseNetwork.__init__(self, address) 2191 2192 # Efficient constructor from integer or packed address 2193 if isinstance(address, (bytes, int)): 2194 self.network_address = IPv6Address(address) 2195 self.netmask, self._prefixlen = self._make_netmask(self._max_prefixlen) 2196 return 2197 2198 if isinstance(address, tuple): 2199 if len(address) > 1: 2200 arg = address[1] 2201 else: 2202 arg = self._max_prefixlen 2203 self.netmask, self._prefixlen = self._make_netmask(arg) 2204 self.network_address = IPv6Address(address[0]) 2205 packed = int(self.network_address) 2206 if packed & int(self.netmask) != packed: 2207 if strict: 2208 raise ValueError('%s has host bits set' % self) 2209 else: 2210 self.network_address = IPv6Address(packed & 2211 int(self.netmask)) 2212 return 2213 2214 # Assume input argument to be string or any object representation 2215 # which converts into a formatted IP prefix string. 2216 addr = _split_optional_netmask(address) 2217 2218 self.network_address = IPv6Address(self._ip_int_from_string(addr[0])) 2219 2220 if len(addr) == 2: 2221 arg = addr[1] 2222 else: 2223 arg = self._max_prefixlen 2224 self.netmask, self._prefixlen = self._make_netmask(arg) 2225 2226 if strict: 2227 if (IPv6Address(int(self.network_address) & int(self.netmask)) != 2228 self.network_address): 2229 raise ValueError('%s has host bits set' % self) 2230 self.network_address = IPv6Address(int(self.network_address) & 2231 int(self.netmask)) 2232 2233 if self._prefixlen == (self._max_prefixlen - 1): 2234 self.hosts = self.__iter__ 2235 2236 def hosts(self): 2237 """Generate Iterator over usable hosts in a network. 2238 2239 This is like __iter__ except it doesn't return the 2240 Subnet-Router anycast address. 2241 2242 """ 2243 network = int(self.network_address) 2244 broadcast = int(self.broadcast_address) 2245 for x in range(network + 1, broadcast + 1): 2246 yield self._address_class(x) 2247 2248 @property 2249 def is_site_local(self): 2250 """Test if the address is reserved for site-local. 2251 2252 Note that the site-local address space has been deprecated by RFC 3879. 2253 Use is_private to test if this address is in the space of unique local 2254 addresses as defined by RFC 4193. 2255 2256 Returns: 2257 A boolean, True if the address is reserved per RFC 3513 2.5.6. 2258 2259 """ 2260 return (self.network_address.is_site_local and 2261 self.broadcast_address.is_site_local) 2262 2263 2264 class _IPv6Constants: 2265 2266 _linklocal_network = IPv6Network('fe80::/10') 2267 2268 _multicast_network = IPv6Network('ff00::/8') 2269 2270 _private_networks = [ 2271 IPv6Network('::1/128'), 2272 IPv6Network('::/128'), 2273 IPv6Network('::ffff:0:0/96'), 2274 IPv6Network('100::/64'), 2275 IPv6Network('2001::/23'), 2276 IPv6Network('2001:2::/48'), 2277 IPv6Network('2001:db8::/32'), 2278 IPv6Network('2001:10::/28'), 2279 IPv6Network('fc00::/7'), 2280 IPv6Network('fe80::/10'), 2281 ] 2282 2283 _reserved_networks = [ 2284 IPv6Network('::/8'), IPv6Network('100::/8'), 2285 IPv6Network('200::/7'), IPv6Network('400::/6'), 2286 IPv6Network('800::/5'), IPv6Network('1000::/4'), 2287 IPv6Network('4000::/3'), IPv6Network('6000::/3'), 2288 IPv6Network('8000::/3'), IPv6Network('A000::/3'), 2289 IPv6Network('C000::/3'), IPv6Network('E000::/4'), 2290 IPv6Network('F000::/5'), IPv6Network('F800::/6'), 2291 IPv6Network('FE00::/9'), 2292 ] 2293 2294 _sitelocal_network = IPv6Network('fec0::/10') 2295 2296 2297 IPv6Address._constants = _IPv6Constants 2298