« back to all changes in this revision
Viewing changes to lib/exabgp/compatibility/ipaddress.py
- browse files at revision 9
- compare with another revision
- download diff
- download tarball
- view history from revision 9
- Committer: Package Import Robot
- Author(s): Henry-Nicolas Tourneur
- Date: 2013-01-02 11:42:00 UTC
- mfrom: (1.1.6)
- Revision ID: package-import@ubuntu.com-20130102114200-heowva4yrqiiukc5
Tags: 3.1.1-1
* New upstream release
* Closes: #687134 debconf abuse, notice of software behavior take places under
NEWS.Debian, not in a debconf screen, information moved accordingly.
* Closes: #693338 Japanese translation removed since debconf template is out.
* Closes: #697178 Russian translation removed since debconf template is out.
* Closes: #689533 UCF-based conf added.
No more manual changes to exabgp.env, thanks to Federico Ceratto.
- files added:
- PEP8
- QA/bin
- lib/exabgp/bgp/message/update/nlri
- lib/exabgp/compatibility
- files removed:
- debian/exabgp.env
- debian/po
- lib/exabgp/bgp/message/nlri
- files modified:
- CHANGELOG
added
removed
lib/exabgp/compatibility/ipaddress.py
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:
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:
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 IPv#Address.
168
169
Args:
170
addresses: a list of IPv#Address objects.
171
172
Returns:
173
A tuple containing the first and last IP addresses in the sequence.
174
175
"""
176
first = last = addresses[0]
177
for ip in addresses[1:]:
178
if ip._ip == last._ip + 1:
179
last = ip
180
else:
181
break
182
return (first, last)
183
184
185
def _count_righthand_zero_bits(number, bits):
186
"""Count the number of zero bits on the right hand side.
187
188
Args:
189
number: an integer.
190
bits: maximum number of bits to count.
191
192
Returns:
193
The number of zero bits on the right hand side of the number.
194
195
"""
196
if number == 0:
197
return bits
198
for i in range(bits):
199
if (number >> i) & 1:
200
return i
201
# All bits of interest were zero, even if there are more in the number
202
return bits
203
204
205
def summarize_address_range(first, last):
206
"""Summarize a network range given the first and last IP addresses.
207
208
Example:
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')]
214
215
Args:
216
first: the first IPv4Address or IPv6Address in the range.
217
last: the last IPv4Address or IPv6Address in the range.
218
219
Returns:
220
An iterator of the summarized IPv(4|6) network objects.
221
222
Raise:
223
TypeError:
224
If the first and last objects are not IP addresses.
225
If the first and last objects are not the same version.
226
ValueError:
227
If the last object is not greater than the first.
228
If the version of the first address is not 4 or 6.
229
230
"""
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" % (
236
first, last))
237
if first > last:
238
raise ValueError('last IP address must be greater than first')
239
240
if first.version == 4:
241
ip = IPv4Network
242
elif first.version == 6:
243
ip = IPv6Network
244
else:
245
raise ValueError('unknown IP version')
246
247
ip_bits = first._max_prefixlen
248
first_int = first._ip
249
last_int = last._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))
254
yield net
255
first_int += 1 << nbits
256
if first_int - 1 == ip._ALL_ONES:
257
break
258
first = first.__class__(first_int)
259
260
261
def _collapse_addresses_recursive(addresses):
262
"""Loops through the addresses, collapsing concurrent netblocks.
263
264
Example:
265
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')
270
271
_collapse_addresses_recursive([ip1, ip2, ip3, ip4]) ->
272
[IPv4Network('192.0.2.0/24')]
273
274
This shouldn't be called directly; it is called via
275
collapse_addresses([]).
276
277
Args:
278
addresses: A list of IPv4Network's or IPv6Network's
279
280
Returns:
281
A list of IPv4Network's or IPv6Network's depending on what we were
282
passed.
283
284
"""
285
while True:
286
last_addr = None
287
ret_array = []
288
optimized = False
289
290
for cur_addr in addresses:
291
if not ret_array:
292
last_addr = cur_addr
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):
296
optimized = True
297
elif cur_addr == list(last_addr.supernet().subnets())[1]:
298
ret_array[-1] = last_addr = last_addr.supernet()
299
optimized = True
300
else:
301
last_addr = cur_addr
302
ret_array.append(cur_addr)
303
304
addresses = ret_array
305
if not optimized:
306
return addresses
307
308
309
def collapse_addresses(addresses):
310
"""Collapse a list of IP objects.
311
312
Example:
313
collapse_addresses([IPv4Network('192.0.2.0/25'),
314
IPv4Network('192.0.2.128/25')]) ->
315
[IPv4Network('192.0.2.0/24')]
316
317
Args:
318
addresses: An iterator of IPv4Network or IPv6Network objects.
319
320
Returns:
321
An iterator of the collapsed IPv(4|6)Network objects.
322
323
Raises:
324
TypeError: If passed a list of mixed version objects.
325
326
"""
327
i = 0
328
addrs = []
329
ips = []
330
nets = []
331
332
# split IP addresses and networks
333
for ip in addresses:
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" % (
337
ip, ips[-1]))
338
ips.append(ip)
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" % (
342
ip, ips[-1]))
343
try:
344
ips.append(ip.ip)
345
except AttributeError:
346
ips.append(ip.network_address)
347
else:
348
if nets and nets[-1]._version != ip._version:
349
raise TypeError("%s and %s are not of the same version" % (
350
ip, nets[-1]))
351
nets.append(ip)
352
353
# sort and dedup
354
ips = sorted(set(ips))
355
nets = sorted(set(nets))
356
357
while i < len(ips):
358
(first, last) = _find_address_range(ips[i:])
359
i = ips.index(last) + 1
360
addrs.extend(summarize_address_range(first, last))
361
362
return iter(_collapse_addresses_recursive(sorted(
363
addrs + nets, key=_BaseNetwork._get_networks_key)))
364
365
366
def get_mixed_type_key(obj):
367
"""Return a key suitable for sorting between networks and addresses.
368
369
Address and Network objects are not sortable by default; they're
370
fundamentally different so the expression
371
372
IPv4Address('192.0.2.0') <= IPv4Network('192.0.2.0/24')
373
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().
377
378
Args:
379
obj: either a Network or Address object.
380
Returns:
381
appropriate key.
382
383
"""
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
389
390
391
class _TotalOrderingMixin:
392
# Helper that derives the other comparison operations from
393
# __lt__ and __eq__
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
402
return not equal
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)
409
return less
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
422
return not less
423
424
class _IPAddressBase(_TotalOrderingMixin):
425
426
"""The mother class."""
427
428
@property
429
def exploded(self):
430
"""Return the longhand version of the IP address as a string."""
431
return self._explode_shorthand_ip_string()
432
433
@property
434
def compressed(self):
435
"""Return the shorthand version of the IP address as a string."""
436
return str(self)
437
438
@property
439
def version(self):
440
msg = '%200s has no version specified' % (type(self),)
441
raise NotImplementedError(msg)
442
443
def _check_int_address(self, address):
444
if address < 0:
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,
450
self._version))
451
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))
458
459
def _ip_int_from_prefix(self, prefixlen=None):
460
"""Turn the prefix length netmask into a int for comparison.
461
462
Args:
463
prefixlen: An integer, the prefix length.
464
465
Returns:
466
An integer.
467
468
"""
469
if prefixlen is None:
470
prefixlen = self._prefixlen
471
return self._ALL_ONES ^ (self._ALL_ONES >> prefixlen)
472
473
def _prefix_from_ip_int(self, ip_int, mask=32):
474
"""Return prefix length from the decimal netmask.
475
476
Args:
477
ip_int: An integer, the IP address.
478
mask: The netmask. Defaults to 32.
479
480
Returns:
481
An integer, the prefix length.
482
483
"""
484
return mask - _count_righthand_zero_bits(ip_int, mask)
485
486
def _ip_string_from_prefix(self, prefixlen=None):
487
"""Turn a prefix length into a dotted decimal string.
488
489
Args:
490
prefixlen: An integer, the netmask prefix length.
491
492
Returns:
493
A string, the dotted decimal netmask string.
494
495
"""
496
if not prefixlen:
497
prefixlen = self._prefixlen
498
return self._string_from_ip_int(self._ip_int_from_prefix(prefixlen))
499
500
501
class _BaseAddress(_IPAddressBase):
502
503
"""A generic IP object.
504
505
This IP class contains the version independent methods which are
506
used by single IP addresses.
507
508
"""
509
510
def __init__(self, address):
511
if (not isinstance(address, bytes)
512
and '/' in str(address)):
513
raise AddressValueError("Unexpected '/' in %r" % address)
514
515
def __int__(self):
516
return self._ip
517
518
def __eq__(self, other):
519
try:
520
return (self._ip == other._ip
521
and self._version == other._version)
522
except AttributeError:
523
return NotImplemented
524
525
def __lt__(self, other):
526
if self._version != other._version:
527
raise TypeError('%s and %s are not of the same version' % (
528
self, other))
529
if not isinstance(other, _BaseAddress):
530
raise TypeError('%s and %s are not of the same type' % (
531
self, other))
532
if self._ip != other._ip:
533
return self._ip < other._ip
534
return False
535
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)
542
543
def __sub__(self, other):
544
if not isinstance(other, int):
545
return NotImplemented
546
return self.__class__(int(self) - other)
547
548
def __repr__(self):
549
return '%s(%r)' % (self.__class__.__name__, str(self))
550
551
def __str__(self):
552
return str(self._string_from_ip_int(self._ip))
553
554
def __hash__(self):
555
return hash(hex(int(self._ip)))
556
557
def _get_address_key(self):
558
return (self._version, self)
559
560
561
class _BaseNetwork(_IPAddressBase):
562
563
"""A generic IP network object.
564
565
This IP class contains the version independent methods which are
566
used by networks.
567
568
"""
569
def __init__(self, address):
570
self._cache = {}
571
572
def __repr__(self):
573
return '%s(%r)' % (self.__class__.__name__, str(self))
574
575
def __str__(self):
576
return '%s/%d' % (self.network_address, self.prefixlen)
577
578
def hosts(self):
579
"""Generate Iterator over usable hosts in a network.
580
581
This is like __iter__ except it doesn't return the network
582
or broadcast addresses.
583
584
"""
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)
589
590
def __iter__(self):
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)
595
596
def __getitem__(self, n):
597
network = int(self.network_address)
598
broadcast = int(self.broadcast_address)
599
if n >= 0:
600
if network + n > broadcast:
601
raise IndexError
602
return self._address_class(network + n)
603
else:
604
n += 1
605
if broadcast + n < network:
606
raise IndexError
607
return self._address_class(broadcast + n)
608
609
def __lt__(self, other):
610
if self._version != other._version:
611
raise TypeError('%s and %s are not of the same version' % (
612
self, other))
613
if not isinstance(other, _BaseNetwork):
614
raise TypeError('%s and %s are not of the same type' % (
615
self, other))
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
620
return False
621
622
def __eq__(self, other):
623
try:
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
629
630
def __hash__(self):
631
return hash(int(self.network_address) ^ int(self.netmask))
632
633
def __contains__(self, other):
634
# always false if one is v4 and the other is v6.
635
if self._version != other._version:
636
return False
637
# dealing with another network.
638
if isinstance(other, _BaseNetwork):
639
return False
640
# dealing with another address
641
else:
642
# address
643
return (int(self.network_address) <= int(other._ip) <=
644
int(self.broadcast_address))
645
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)))
652
653
@property
654
def broadcast_address(self):
655
x = self._cache.get('broadcast_address')
656
if x is None:
657
x = self._address_class(int(self.network_address) |
658
int(self.hostmask))
659
self._cache['broadcast_address'] = x
660
return x
661
662
@property
663
def hostmask(self):
664
x = self._cache.get('hostmask')
665
if x is None:
666
x = self._address_class(int(self.netmask) ^ self._ALL_ONES)
667
self._cache['hostmask'] = x
668
return x
669
670
@property
671
def with_prefixlen(self):
672
return '%s/%d' % (self.network_address, self._prefixlen)
673
674
@property
675
def with_netmask(self):
676
return '%s/%s' % (self.network_address, self.netmask)
677
678
@property
679
def with_hostmask(self):
680
return '%s/%s' % (self.network_address, self.hostmask)
681
682
@property
683
def num_addresses(self):
684
"""Number of hosts in the current subnet."""
685
return int(self.broadcast_address) - int(self.network_address) + 1
686
687
@property
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)
694
695
@property
696
def prefixlen(self):
697
return self._prefixlen
698
699
def address_exclude(self, other):
700
"""Remove an address from a larger block.
701
702
For example:
703
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')]
709
710
or IPv6:
711
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'),
719
...
720
ip_network('2001:db8:8000::/33')]
721
722
Args:
723
other: An IPv4Network or IPv6Network object of the same type.
724
725
Returns:
726
An iterator of the the IPv(4|6)Network objects which is self
727
minus other.
728
729
Raises:
730
TypeError: If self and other are of difffering address
731
versions, or if other is not a network object.
732
ValueError: If other is not completely contained by self.
733
734
"""
735
if not self._version == other._version:
736
raise TypeError("%s and %s are not of the same version" % (
737
self, other))
738
739
if not isinstance(other, _BaseNetwork):
740
raise TypeError("%s is not a network object" % other)
741
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))
745
if other == self:
746
raise StopIteration
747
748
# Make sure we're comparing the network of other.
749
other = other.__class__('%s/%s' % (other.network_address,
750
other.prefixlen))
751
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):
756
yield s2
757
s1, s2 = s1.subnets()
758
elif (other.network_address >= s2.network_address and
759
other.broadcast_address <= s2.broadcast_address):
760
yield s1
761
s1, s2 = s2.subnets()
762
else:
763
# If we got here, there's a bug somewhere.
764
raise AssertionError('Error performing exclusion: '
765
's1: %s s2: %s other: %s' %
766
(s1, s2, other))
767
if s1 == other:
768
yield s2
769
elif s2 == other:
770
yield s1
771
else:
772
# If we got here, there's a bug somewhere.
773
raise AssertionError('Error performing exclusion: '
774
's1: %s s2: %s other: %s' %
775
(s1, s2, other))
776
777
def compare_networks(self, other):
778
"""Compare two IP objects.
779
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'
785
786
Args:
787
other: An IP object.
788
789
Returns:
790
If the IP versions of self and other are the same, returns:
791
792
-1 if self < other:
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')
796
0 if self == other
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')
800
1 if self > other
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')
804
805
Raises:
806
TypeError if the IP versions are different.
807
808
"""
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' % (
812
self, other))
813
# self._version == other._version below here:
814
if self.network_address < other.network_address:
815
return -1
816
if self.network_address > other.network_address:
817
return 1
818
# self.network_address == other.network_address below here:
819
if self.netmask < other.netmask:
820
return -1
821
if self.netmask > other.netmask:
822
return 1
823
return 0
824
825
def _get_networks_key(self):
826
"""Network-only key function.
827
828
Returns an object that identifies this address' network and
829
netmask. This function is a suitable "key" argument for sorted()
830
and list.sort().
831
832
"""
833
return (self._version, self.network_address, self.netmask)
834
835
def subnets(self, prefixlen_diff=1, new_prefix=None):
836
"""The subnets which join to make the current subnet.
837
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.
841
842
Args:
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.
849
850
Returns:
851
An iterator of IPv(4|6) objects.
852
853
Raises:
854
ValueError: The prefixlen_diff is too small or too large.
855
OR
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)
859
860
"""
861
if self._prefixlen == self._max_prefixlen:
862
yield self
863
return
864
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
871
872
if prefixlen_diff < 0:
873
raise ValueError('prefix length diff must be > 0')
874
new_prefixlen = self._prefixlen + prefixlen_diff
875
876
if not self._is_valid_netmask(str(new_prefixlen)):
877
raise ValueError(
878
'prefix length diff %d is invalid for netblock %s' % (
879
new_prefixlen, self))
880
881
first = self.__class__('%s/%s' %
882
(self.network_address,
883
self._prefixlen + prefixlen_diff))
884
885
yield first
886
current = first
887
while True:
888
broadcast = current.broadcast_address
889
if broadcast == self.broadcast_address:
890
return
891
new_addr = self._address_class(int(broadcast) + 1)
892
current = self.__class__('%s/%s' % (new_addr,
893
new_prefixlen))
894
895
yield current
896
897
def supernet(self, prefixlen_diff=1, new_prefix=None):
898
"""The supernet containing the current network.
899
900
Args:
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.
905
906
Returns:
907
An IPv4 network object.
908
909
Raises:
910
ValueError: If self.prefixlen - prefixlen_diff < 0. I.e., you have
911
a negative prefix length.
912
OR
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
915
smaller network)
916
917
"""
918
if self._prefixlen == 0:
919
return self
920
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
927
928
if self.prefixlen - prefixlen_diff < 0:
929
raise ValueError(
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),
935
strict=False)
936
return t.__class__('%s/%d' % (t.network_address, t.prefixlen))
937
938
@property
939
def is_multicast(self):
940
"""Test if the address is reserved for multicast use.
941
942
Returns:
943
A boolean, True if the address is a multicast address.
944
See RFC 2373 2.7 for details.
945
946
"""
947
return (self.network_address.is_multicast and
948
self.broadcast_address.is_multicast)
949
950
@property
951
def is_reserved(self):
952
"""Test if the address is otherwise IETF reserved.
953
954
Returns:
955
A boolean, True if the address is within one of the
956
reserved IPv6 Network ranges.
957
958
"""
959
return (self.network_address.is_reserved and
960
self.broadcast_address.is_reserved)
961
962
@property
963
def is_link_local(self):
964
"""Test if the address is reserved for link-local.
965
966
Returns:
967
A boolean, True if the address is reserved per RFC 4291.
968
969
"""
970
return (self.network_address.is_link_local and
971
self.broadcast_address.is_link_local)
972
973
@property
974
def is_private(self):
975
"""Test if this address is allocated for private networks.
976
977
Returns:
978
A boolean, True if the address is reserved per RFC 4193.
979
980
"""
981
return (self.network_address.is_private and
982
self.broadcast_address.is_private)
983
984
@property
985
def is_unspecified(self):
986
"""Test if the address is unspecified.
987
988
Returns:
989
A boolean, True if this is the unspecified address as defined in
990
RFC 2373 2.5.2.
991
992
"""
993
return (self.network_address.is_unspecified and
994
self.broadcast_address.is_unspecified)
995
996
@property
997
def is_loopback(self):
998
"""Test if the address is a loopback address.
999
1000
Returns:
1001
A boolean, True if the address is a loopback address as defined in
1002
RFC 2373 2.5.3.
1003
1004
"""
1005
return (self.network_address.is_loopback and
1006
self.broadcast_address.is_loopback)
1007
1008
1009
class _BaseV4:
1010
1011
"""Base IPv4 object.
1012
1013
The following methods are used by IPv4 objects in both single IP
1014
addresses and networks.
1015
1016
"""
1017
1018
# Equivalent to 255.255.255.255 or 32 bits of 1's.
1019
_ALL_ONES = (2**IPV4LENGTH) - 1
1020
_DECIMAL_DIGITS = frozenset('0123456789')
1021
1022
# the valid octets for host and netmasks. only useful for IPv4.
1023
_valid_mask_octets = frozenset((255, 254, 252, 248, 240, 224, 192, 128, 0))
1024
1025
def __init__(self, address):
1026
self._version = 4
1027
self._max_prefixlen = IPV4LENGTH
1028
1029
def _explode_shorthand_ip_string(self):
1030
return str(self)
1031
1032
def _ip_int_from_string(self, ip_str):
1033
"""Turn the given IP string into an integer for comparison.
1034
1035
Args:
1036
ip_str: A string, the IP ip_str.
1037
1038
Returns:
1039
The IP ip_str as an integer.
1040
1041
Raises:
1042
AddressValueError: if ip_str isn't a valid IPv4 Address.
1043
1044
"""
1045
if not ip_str:
1046
raise AddressValueError('Address cannot be empty')
1047
1048
octets = ip_str.split('.')
1049
if len(octets) != 4:
1050
raise AddressValueError("Expected 4 octets in %r" % ip_str)
1051
1052
try:
1053
return int.from_bytes(map(self._parse_octet, octets), 'big')
1054
except ValueError as exc:
1055
raise AddressValueError("%s in %r" % (exc, ip_str))
1056
1057
def _parse_octet(self, octet_str):
1058
"""Convert a decimal octet into an integer.
1059
1060
Args:
1061
octet_str: A string, the number to parse.
1062
1063
Returns:
1064
The octet as an integer.
1065
1066
Raises:
1067
ValueError: if the octet isn't strictly a decimal from [0..255].
1068
1069
"""
1070
if not octet_str:
1071
raise ValueError("Empty octet not permitted")
1072
# Whitelist the characters, since int() allows a lot of bizarre stuff.
1073
if not self._DECIMAL_DIGITS.issuperset(octet_str):
1074
msg = "Only decimal digits permitted in %r"
1075
raise ValueError(msg % octet_str)
1076
# We do the length check second, since the invalid character error
1077
# is likely to be more informative for the user
1078
if len(octet_str) > 3:
1079
msg = "At most 3 characters permitted in %r"
1080
raise ValueError(msg % octet_str)
1081
# Convert to integer (we know digits are legal)
1082
octet_int = int(octet_str, 10)
1083
# Any octets that look like they *might* be written in octal,
1084
# and which don't look exactly the same in both octal and
1085
# decimal are rejected as ambiguous
1086
if octet_int > 7 and octet_str[0] == '0':
1087
msg = "Ambiguous (octal/decimal) value in %r not permitted"
1088
raise ValueError(msg % octet_str)
1089
if octet_int > 255:
1090
raise ValueError("Octet %d (> 255) not permitted" % octet_int)
1091
return octet_int
1092
1093
def _string_from_ip_int(self, ip_int):
1094
"""Turns a 32-bit integer into dotted decimal notation.
1095
1096
Args:
1097
ip_int: An integer, the IP address.
1098
1099
Returns:
1100
The IP address as a string in dotted decimal notation.
1101
1102
"""
1103
return '.'.join(map(str, ip_int.to_bytes(4, 'big')))
1104
1105
def _is_valid_netmask(self, netmask):
1106
"""Verify that the netmask is valid.
1107
1108
Args:
1109
netmask: A string, either a prefix or dotted decimal
1110
netmask.
1111
1112
Returns:
1113
A boolean, True if the prefix represents a valid IPv4
1114
netmask.
1115
1116
"""
1117
mask = netmask.split('.')
1118
if len(mask) == 4:
1119
try:
1120
for x in mask:
1121
if int(x) not in self._valid_mask_octets:
1122
return False
1123
except ValueError:
1124
# Found something that isn't an integer or isn't valid
1125
return False
1126
for idx, y in enumerate(mask):
1127
if idx > 0 and y > mask[idx - 1]:
1128
return False
1129
return True
1130
try:
1131
netmask = int(netmask)
1132
except ValueError:
1133
return False
1134
return 0 <= netmask <= self._max_prefixlen
1135
1136
def _is_hostmask(self, ip_str):
1137
"""Test if the IP string is a hostmask (rather than a netmask).
1138
1139
Args:
1140
ip_str: A string, the potential hostmask.
1141
1142
Returns:
1143
A boolean, True if the IP string is a hostmask.
1144
1145
"""
1146
bits = ip_str.split('.')
1147
try:
1148
parts = [x for x in map(int, bits) if x in self._valid_mask_octets]
1149
except ValueError:
1150
return False
1151
if len(parts) != len(bits):
1152
return False
1153
if parts[0] < parts[-1]:
1154
return True
1155
return False
1156
1157
@property
1158
def max_prefixlen(self):
1159
return self._max_prefixlen
1160
1161
@property
1162
def version(self):
1163
return self._version
1164
1165
1166
class IPv4Address(_BaseV4, _BaseAddress):
1167
1168
"""Represent and manipulate single IPv4 Addresses."""
1169
1170
def __init__(self, address):
1171
1172
"""
1173
Args:
1174
address: A string or integer representing the IP
1175
1176
Additionally, an integer can be passed, so
1177
IPv4Address('192.0.2.1') == IPv4Address(3221225985).
1178
or, more generally
1179
IPv4Address(int(IPv4Address('192.0.2.1'))) ==
1180
IPv4Address('192.0.2.1')
1181
1182
Raises:
1183
AddressValueError: If ipaddress isn't a valid IPv4 address.
1184
1185
"""
1186
_BaseAddress.__init__(self, address)
1187
_BaseV4.__init__(self, address)
1188
1189
# Efficient constructor from integer.
1190
if isinstance(address, int):
1191
self._check_int_address(address)
1192
self._ip = address
1193
return
1194
1195
# Constructing from a packed address
1196
if isinstance(address, bytes):
1197
self._check_packed_address(address, 4)
1198
self._ip = int.from_bytes(address, 'big')
1199
return
1200
1201
# Assume input argument to be string or any object representation
1202
# which converts into a formatted IP string.
1203
addr_str = str(address)
1204
self._ip = self._ip_int_from_string(addr_str)
1205
1206
@property
1207
def packed(self):
1208
"""The binary representation of this address."""
1209
return v4_int_to_packed(self._ip)
1210
1211
@property
1212
def is_reserved(self):
1213
"""Test if the address is otherwise IETF reserved.
1214
1215
Returns:
1216
A boolean, True if the address is within the
1217
reserved IPv4 Network range.
1218
1219
"""
1220
reserved_network = IPv4Network('240.0.0.0/4')
1221
return self in reserved_network
1222
1223
@property
1224
def is_private(self):
1225
"""Test if this address is allocated for private networks.
1226
1227
Returns:
1228
A boolean, True if the address is reserved per RFC 1918.
1229
1230
"""
1231
private_10 = IPv4Network('10.0.0.0/8')
1232
private_172 = IPv4Network('172.16.0.0/12')
1233
private_192 = IPv4Network('192.168.0.0/16')
1234
return (self in private_10 or
1235
self in private_172 or
1236
self in private_192)
1237
1238
@property
1239
def is_multicast(self):
1240
"""Test if the address is reserved for multicast use.
1241
1242
Returns:
1243
A boolean, True if the address is multicast.
1244
See RFC 3171 for details.
1245
1246
"""
1247
multicast_network = IPv4Network('224.0.0.0/4')
1248
return self in multicast_network
1249
1250
@property
1251
def is_unspecified(self):
1252
"""Test if the address is unspecified.
1253
1254
Returns:
1255
A boolean, True if this is the unspecified address as defined in
1256
RFC 5735 3.
1257
1258
"""
1259
unspecified_address = IPv4Address('0.0.0.0')
1260
return self == unspecified_address
1261
1262
@property
1263
def is_loopback(self):
1264
"""Test if the address is a loopback address.
1265
1266
Returns:
1267
A boolean, True if the address is a loopback per RFC 3330.
1268
1269
"""
1270
loopback_network = IPv4Network('127.0.0.0/8')
1271
return self in loopback_network
1272
1273
@property
1274
def is_link_local(self):
1275
"""Test if the address is reserved for link-local.
1276
1277
Returns:
1278
A boolean, True if the address is link-local per RFC 3927.
1279
1280
"""
1281
linklocal_network = IPv4Network('169.254.0.0/16')
1282
return self in linklocal_network
1283
1284
1285
class IPv4Interface(IPv4Address):
1286
1287
def __init__(self, address):
1288
if isinstance(address, (bytes, int)):
1289
IPv4Address.__init__(self, address)
1290
self.network = IPv4Network(self._ip)
1291
self._prefixlen = self._max_prefixlen
1292
return
1293
1294
addr = _split_optional_netmask(address)
1295
IPv4Address.__init__(self, addr[0])
1296
1297
self.network = IPv4Network(address, strict=False)
1298
self._prefixlen = self.network._prefixlen
1299
1300
self.netmask = self.network.netmask
1301
self.hostmask = self.network.hostmask
1302
1303
def __str__(self):
1304
return '%s/%d' % (self._string_from_ip_int(self._ip),
1305
self.network.prefixlen)
1306
1307
def __eq__(self, other):
1308
address_equal = IPv4Address.__eq__(self, other)
1309
if not address_equal or address_equal is NotImplemented:
1310
return address_equal
1311
try:
1312
return self.network == other.network
1313
except AttributeError:
1314
# An interface with an associated network is NOT the
1315
# same as an unassociated address. That's why the hash
1316
# takes the extra info into account.
1317
return False
1318
1319
def __lt__(self, other):
1320
address_less = IPv4Address.__lt__(self, other)
1321
if address_less is NotImplemented:
1322
return NotImplemented
1323
try:
1324
return self.network < other.network
1325
except AttributeError:
1326
# We *do* allow addresses and interfaces to be sorted. The
1327
# unassociated address is considered less than all interfaces.
1328
return False
1329
1330
def __hash__(self):
1331
return self._ip ^ self._prefixlen ^ int(self.network.network_address)
1332
1333
@property
1334
def ip(self):
1335
return IPv4Address(self._ip)
1336
1337
@property
1338
def with_prefixlen(self):
1339
return '%s/%s' % (self._string_from_ip_int(self._ip),
1340
self._prefixlen)
1341
1342
@property
1343
def with_netmask(self):
1344
return '%s/%s' % (self._string_from_ip_int(self._ip),
1345
self.netmask)
1346
1347
@property
1348
def with_hostmask(self):
1349
return '%s/%s' % (self._string_from_ip_int(self._ip),
1350
self.hostmask)
1351
1352
1353
class IPv4Network(_BaseV4, _BaseNetwork):
1354
1355
"""This class represents and manipulates 32-bit IPv4 network + addresses..
1356
1357
Attributes: [examples for IPv4Network('192.0.2.0/27')]
1358
.network_address: IPv4Address('192.0.2.0')
1359
.hostmask: IPv4Address('0.0.0.31')
1360
.broadcast_address: IPv4Address('192.0.2.32')
1361
.netmask: IPv4Address('255.255.255.224')
1362
.prefixlen: 27
1363
1364
"""
1365
# Class to use when creating address objects
1366
_address_class = IPv4Address
1367
1368
def __init__(self, address, strict=True):
1369
1370
"""Instantiate a new IPv4 network object.
1371
1372
Args:
1373
address: A string or integer representing the IP [& network].
1374
'192.0.2.0/24'
1375
'192.0.2.0/255.255.255.0'
1376
'192.0.0.2/0.0.0.255'
1377
are all functionally the same in IPv4. Similarly,
1378
'192.0.2.1'
1379
'192.0.2.1/255.255.255.255'
1380
'192.0.2.1/32'
1381
are also functionaly equivalent. That is to say, failing to
1382
provide a subnetmask will create an object with a mask of /32.
1383
1384
If the mask (portion after the / in the argument) is given in
1385
dotted quad form, it is treated as a netmask if it starts with a
1386
non-zero field (e.g. /255.0.0.0 == /8) and as a hostmask if it
1387
starts with a zero field (e.g. 0.255.255.255 == /8), with the
1388
single exception of an all-zero mask which is treated as a
1389
netmask == /0. If no mask is given, a default of /32 is used.
1390
1391
Additionally, an integer can be passed, so
1392
IPv4Network('192.0.2.1') == IPv4Network(3221225985)
1393
or, more generally
1394
IPv4Interface(int(IPv4Interface('192.0.2.1'))) ==
1395
IPv4Interface('192.0.2.1')
1396
1397
Raises:
1398
AddressValueError: If ipaddress isn't a valid IPv4 address.
1399
NetmaskValueError: If the netmask isn't valid for
1400
an IPv4 address.
1401
ValueError: If strict is True and a network address is not
1402
supplied.
1403
1404
"""
1405
1406
_BaseV4.__init__(self, address)
1407
_BaseNetwork.__init__(self, address)
1408
1409
# Constructing from a packed address
1410
if isinstance(address, bytes):
1411
self.network_address = IPv4Address(address)
1412
self._prefixlen = self._max_prefixlen
1413
self.netmask = IPv4Address(self._ALL_ONES)
1414
#fixme: address/network test here
1415
return
1416
1417
# Efficient constructor from integer.
1418
if isinstance(address, int):
1419
self.network_address = IPv4Address(address)
1420
self._prefixlen = self._max_prefixlen
1421
self.netmask = IPv4Address(self._ALL_ONES)
1422
#fixme: address/network test here.
1423
return
1424
1425
# Assume input argument to be string or any object representation
1426
# which converts into a formatted IP prefix string.
1427
addr = _split_optional_netmask(address)
1428
self.network_address = IPv4Address(self._ip_int_from_string(addr[0]))
1429
1430
if len(addr) == 2:
1431
mask = addr[1].split('.')
1432
1433
if len(mask) == 4:
1434
# We have dotted decimal netmask.
1435
if self._is_valid_netmask(addr[1]):
1436
self.netmask = IPv4Address(self._ip_int_from_string(
1437
addr[1]))
1438
elif self._is_hostmask(addr[1]):
1439
self.netmask = IPv4Address(
1440
self._ip_int_from_string(addr[1]) ^ self._ALL_ONES)
1441
else:
1442
raise NetmaskValueError('%r is not a valid netmask'
1443
% addr[1])
1444
1445
self._prefixlen = self._prefix_from_ip_int(int(self.netmask))
1446
else:
1447
# We have a netmask in prefix length form.
1448
if not self._is_valid_netmask(addr[1]):
1449
raise NetmaskValueError('%r is not a valid netmask'
1450
% addr[1])
1451
self._prefixlen = int(addr[1])
1452
self.netmask = IPv4Address(self._ip_int_from_prefix(
1453
self._prefixlen))
1454
else:
1455
self._prefixlen = self._max_prefixlen
1456
self.netmask = IPv4Address(self._ip_int_from_prefix(
1457
self._prefixlen))
1458
1459
if strict:
1460
if (IPv4Address(int(self.network_address) & int(self.netmask)) !=
1461
self.network_address):
1462
raise ValueError('%s has host bits set' % self)
1463
self.network_address = IPv4Address(int(self.network_address) &
1464
int(self.netmask))
1465
1466
if self._prefixlen == (self._max_prefixlen - 1):
1467
self.hosts = self.__iter__
1468
1469
1470
class _BaseV6:
1471
1472
"""Base IPv6 object.
1473
1474
The following methods are used by IPv6 objects in both single IP
1475
addresses and networks.
1476
1477
"""
1478
1479
_ALL_ONES = (2**IPV6LENGTH) - 1
1480
_HEXTET_COUNT = 8
1481
_HEX_DIGITS = frozenset('0123456789ABCDEFabcdef')
1482
1483
def __init__(self, address):
1484
self._version = 6
1485
self._max_prefixlen = IPV6LENGTH
1486
1487
def _ip_int_from_string(self, ip_str):
1488
"""Turn an IPv6 ip_str into an integer.
1489
1490
Args:
1491
ip_str: A string, the IPv6 ip_str.
1492
1493
Returns:
1494
An int, the IPv6 address
1495
1496
Raises:
1497
AddressValueError: if ip_str isn't a valid IPv6 Address.
1498
1499
"""
1500
if not ip_str:
1501
raise AddressValueError('Address cannot be empty')
1502
1503
parts = ip_str.split(':')
1504
1505
# An IPv6 address needs at least 2 colons (3 parts).
1506
_min_parts = 3
1507
if len(parts) < _min_parts:
1508
msg = "At least %d parts expected in %r" % (_min_parts, ip_str)
1509
raise AddressValueError(msg)
1510
1511
# If the address has an IPv4-style suffix, convert it to hexadecimal.
1512
if '.' in parts[-1]:
1513
try:
1514
ipv4_int = IPv4Address(parts.pop())._ip
1515
except AddressValueError as exc:
1516
raise AddressValueError("%s in %r" % (exc, ip_str))
1517
parts.append('%x' % ((ipv4_int >> 16) & 0xFFFF))
1518
parts.append('%x' % (ipv4_int & 0xFFFF))
1519
1520
# An IPv6 address can't have more than 8 colons (9 parts).
1521
# The extra colon comes from using the "::" notation for a single
1522
# leading or trailing zero part.
1523
_max_parts = self._HEXTET_COUNT + 1
1524
if len(parts) > _max_parts:
1525
msg = "At most %d colons permitted in %r" % (_max_parts-1, ip_str)
1526
raise AddressValueError(msg)
1527
1528
# Disregarding the endpoints, find '::' with nothing in between.
1529
# This indicates that a run of zeroes has been skipped.
1530
skip_index = None
1531
for i in range(1, len(parts) - 1):
1532
if not parts[i]:
1533
if skip_index is not None:
1534
# Can't have more than one '::'
1535
msg = "At most one '::' permitted in %r" % ip_str
1536
raise AddressValueError(msg)
1537
skip_index = i
1538
1539
# parts_hi is the number of parts to copy from above/before the '::'
1540
# parts_lo is the number of parts to copy from below/after the '::'
1541
if skip_index is not None:
1542
# If we found a '::', then check if it also covers the endpoints.
1543
parts_hi = skip_index
1544
parts_lo = len(parts) - skip_index - 1
1545
if not parts[0]:
1546
parts_hi -= 1
1547
if parts_hi:
1548
msg = "Leading ':' only permitted as part of '::' in %r"
1549
raise AddressValueError(msg % ip_str) # ^: requires ^::
1550
if not parts[-1]:
1551
parts_lo -= 1
1552
if parts_lo:
1553
msg = "Trailing ':' only permitted as part of '::' in %r"
1554
raise AddressValueError(msg % ip_str) # :$ requires ::$
1555
parts_skipped = self._HEXTET_COUNT - (parts_hi + parts_lo)
1556
if parts_skipped < 1:
1557
msg = "Expected at most %d other parts with '::' in %r"
1558
raise AddressValueError(msg % (self._HEXTET_COUNT-1, ip_str))
1559
else:
1560
# Otherwise, allocate the entire address to parts_hi. The
1561
# endpoints could still be empty, but _parse_hextet() will check
1562
# for that.
1563
if len(parts) != self._HEXTET_COUNT:
1564
msg = "Exactly %d parts expected without '::' in %r"
1565
raise AddressValueError(msg % (self._HEXTET_COUNT, ip_str))
1566
if not parts[0]:
1567
msg = "Leading ':' only permitted as part of '::' in %r"
1568
raise AddressValueError(msg % ip_str) # ^: requires ^::
1569
if not parts[-1]:
1570
msg = "Trailing ':' only permitted as part of '::' in %r"
1571
raise AddressValueError(msg % ip_str) # :$ requires ::$
1572
parts_hi = len(parts)
1573
parts_lo = 0
1574
parts_skipped = 0
1575
1576
try:
1577
# Now, parse the hextets into a 128-bit integer.
1578
ip_int = 0
1579
for i in range(parts_hi):
1580
ip_int <<= 16
1581
ip_int |= self._parse_hextet(parts[i])
1582
ip_int <<= 16 * parts_skipped
1583
for i in range(-parts_lo, 0):
1584
ip_int <<= 16
1585
ip_int |= self._parse_hextet(parts[i])
1586
return ip_int
1587
except ValueError as exc:
1588
raise AddressValueError("%s in %r" % (exc, ip_str))
1589
1590
def _parse_hextet(self, hextet_str):
1591
"""Convert an IPv6 hextet string into an integer.
1592
1593
Args:
1594
hextet_str: A string, the number to parse.
1595
1596
Returns:
1597
The hextet as an integer.
1598
1599
Raises:
1600
ValueError: if the input isn't strictly a hex number from
1601
[0..FFFF].
1602
1603
"""
1604
# Whitelist the characters, since int() allows a lot of bizarre stuff.
1605
if not self._HEX_DIGITS.issuperset(hextet_str):
1606
raise ValueError("Only hex digits permitted in %r" % hextet_str)
1607
# We do the length check second, since the invalid character error
1608
# is likely to be more informative for the user
1609
if len(hextet_str) > 4:
1610
msg = "At most 4 characters permitted in %r"
1611
raise ValueError(msg % hextet_str)
1612
# Length check means we can skip checking the integer value
1613
return int(hextet_str, 16)
1614
1615
def _compress_hextets(self, hextets):
1616
"""Compresses a list of hextets.
1617
1618
Compresses a list of strings, replacing the longest continuous
1619
sequence of "0" in the list with "" and adding empty strings at
1620
the beginning or at the end of the string such that subsequently
1621
calling ":".join(hextets) will produce the compressed version of
1622
the IPv6 address.
1623
1624
Args:
1625
hextets: A list of strings, the hextets to compress.
1626
1627
Returns:
1628
A list of strings.
1629
1630
"""
1631
best_doublecolon_start = -1
1632
best_doublecolon_len = 0
1633
doublecolon_start = -1
1634
doublecolon_len = 0
1635
for index, hextet in enumerate(hextets):
1636
if hextet == '0':
1637
doublecolon_len += 1
1638
if doublecolon_start == -1:
1639
# Start of a sequence of zeros.
1640
doublecolon_start = index
1641
if doublecolon_len > best_doublecolon_len:
1642
# This is the longest sequence of zeros so far.
1643
best_doublecolon_len = doublecolon_len
1644
best_doublecolon_start = doublecolon_start
1645
else:
1646
doublecolon_len = 0
1647
doublecolon_start = -1
1648
1649
if best_doublecolon_len > 1:
1650
best_doublecolon_end = (best_doublecolon_start +
1651
best_doublecolon_len)
1652
# For zeros at the end of the address.
1653
if best_doublecolon_end == len(hextets):
1654
hextets += ['']
1655
hextets[best_doublecolon_start:best_doublecolon_end] = ['']
1656
# For zeros at the beginning of the address.
1657
if best_doublecolon_start == 0:
1658
hextets = [''] + hextets
1659
1660
return hextets
1661
1662
def _string_from_ip_int(self, ip_int=None):
1663
"""Turns a 128-bit integer into hexadecimal notation.
1664
1665
Args:
1666
ip_int: An integer, the IP address.
1667
1668
Returns:
1669
A string, the hexadecimal representation of the address.
1670
1671
Raises:
1672
ValueError: The address is bigger than 128 bits of all ones.
1673
1674
"""
1675
if ip_int is None:
1676
ip_int = int(self._ip)
1677
1678
if ip_int > self._ALL_ONES:
1679
raise ValueError('IPv6 address is too large')
1680
1681
hex_str = '%032x' % ip_int
1682
hextets = ['%x' % int(hex_str[x:x+4], 16) for x in range(0, 32, 4)]
1683
1684
hextets = self._compress_hextets(hextets)
1685
return ':'.join(hextets)
1686
1687
def _explode_shorthand_ip_string(self):
1688
"""Expand a shortened IPv6 address.
1689
1690
Args:
1691
ip_str: A string, the IPv6 address.
1692
1693
Returns:
1694
A string, the expanded IPv6 address.
1695
1696
"""
1697
if isinstance(self, IPv6Network):
1698
ip_str = str(self.network_address)
1699
elif isinstance(self, IPv6Interface):
1700
ip_str = str(self.ip)
1701
else:
1702
ip_str = str(self)
1703
1704
ip_int = self._ip_int_from_string(ip_str)
1705
hex_str = '%032x' % ip_int
1706
parts = [hex_str[x:x+4] for x in range(0, 32, 4)]
1707
if isinstance(self, (_BaseNetwork, IPv6Interface)):
1708
return '%s/%d' % (':'.join(parts), self._prefixlen)
1709
return ':'.join(parts)
1710
1711
@property
1712
def max_prefixlen(self):
1713
return self._max_prefixlen
1714
1715
@property
1716
def version(self):
1717
return self._version
1718
1719
1720
class IPv6Address(_BaseV6, _BaseAddress):
1721
1722
"""Represent and manipulate single IPv6 Addresses."""
1723
1724
def __init__(self, address):
1725
"""Instantiate a new IPv6 address object.
1726
1727
Args:
1728
address: A string or integer representing the IP
1729
1730
Additionally, an integer can be passed, so
1731
IPv6Address('2001:db8::') ==
1732
IPv6Address(42540766411282592856903984951653826560)
1733
or, more generally
1734
IPv6Address(int(IPv6Address('2001:db8::'))) ==
1735
IPv6Address('2001:db8::')
1736
1737
Raises:
1738
AddressValueError: If address isn't a valid IPv6 address.
1739
1740
"""
1741
_BaseAddress.__init__(self, address)
1742
_BaseV6.__init__(self, address)
1743
1744
# Efficient constructor from integer.
1745
if isinstance(address, int):
1746
self._check_int_address(address)
1747
self._ip = address
1748
return
1749
1750
# Constructing from a packed address
1751
if isinstance(address, bytes):
1752
self._check_packed_address(address, 16)
1753
self._ip = int.from_bytes(address, 'big')
1754
return
1755
1756
# Assume input argument to be string or any object representation
1757
# which converts into a formatted IP string.
1758
addr_str = str(address)
1759
self._ip = self._ip_int_from_string(addr_str)
1760
1761
@property
1762
def packed(self):
1763
"""The binary representation of this address."""
1764
return v6_int_to_packed(self._ip)
1765
1766
@property
1767
def is_multicast(self):
1768
"""Test if the address is reserved for multicast use.
1769
1770
Returns:
1771
A boolean, True if the address is a multicast address.
1772
See RFC 2373 2.7 for details.
1773
1774
"""
1775
multicast_network = IPv6Network('ff00::/8')
1776
return self in multicast_network
1777
1778
@property
1779
def is_reserved(self):
1780
"""Test if the address is otherwise IETF reserved.
1781
1782
Returns:
1783
A boolean, True if the address is within one of the
1784
reserved IPv6 Network ranges.
1785
1786
"""
1787
reserved_networks = [IPv6Network('::/8'), IPv6Network('100::/8'),
1788
IPv6Network('200::/7'), IPv6Network('400::/6'),
1789
IPv6Network('800::/5'), IPv6Network('1000::/4'),
1790
IPv6Network('4000::/3'), IPv6Network('6000::/3'),
1791
IPv6Network('8000::/3'), IPv6Network('A000::/3'),
1792
IPv6Network('C000::/3'), IPv6Network('E000::/4'),
1793
IPv6Network('F000::/5'), IPv6Network('F800::/6'),
1794
IPv6Network('FE00::/9')]
1795
1796
return any(self in x for x in reserved_networks)
1797
1798
@property
1799
def is_link_local(self):
1800
"""Test if the address is reserved for link-local.
1801
1802
Returns:
1803
A boolean, True if the address is reserved per RFC 4291.
1804
1805
"""
1806
linklocal_network = IPv6Network('fe80::/10')
1807
return self in linklocal_network
1808
1809
@property
1810
def is_site_local(self):
1811
"""Test if the address is reserved for site-local.
1812
1813
Note that the site-local address space has been deprecated by RFC 3879.
1814
Use is_private to test if this address is in the space of unique local
1815
addresses as defined by RFC 4193.
1816
1817
Returns:
1818
A boolean, True if the address is reserved per RFC 3513 2.5.6.
1819
1820
"""
1821
sitelocal_network = IPv6Network('fec0::/10')
1822
return self in sitelocal_network
1823
1824
@property
1825
def is_private(self):
1826
"""Test if this address is allocated for private networks.
1827
1828
Returns:
1829
A boolean, True if the address is reserved per RFC 4193.
1830
1831
"""
1832
private_network = IPv6Network('fc00::/7')
1833
return self in private_network
1834
1835
@property
1836
def is_unspecified(self):
1837
"""Test if the address is unspecified.
1838
1839
Returns:
1840
A boolean, True if this is the unspecified address as defined in
1841
RFC 2373 2.5.2.
1842
1843
"""
1844
return self._ip == 0
1845
1846
@property
1847
def is_loopback(self):
1848
"""Test if the address is a loopback address.
1849
1850
Returns:
1851
A boolean, True if the address is a loopback address as defined in
1852
RFC 2373 2.5.3.
1853
1854
"""
1855
return self._ip == 1
1856
1857
@property
1858
def ipv4_mapped(self):
1859
"""Return the IPv4 mapped address.
1860
1861
Returns:
1862
If the IPv6 address is a v4 mapped address, return the
1863
IPv4 mapped address. Return None otherwise.
1864
1865
"""
1866
if (self._ip >> 32) != 0xFFFF:
1867
return None
1868
return IPv4Address(self._ip & 0xFFFFFFFF)
1869
1870
@property
1871
def teredo(self):
1872
"""Tuple of embedded teredo IPs.
1873
1874
Returns:
1875
Tuple of the (server, client) IPs or None if the address
1876
doesn't appear to be a teredo address (doesn't start with
1877
2001::/32)
1878
1879
"""
1880
if (self._ip >> 96) != 0x20010000:
1881
return None
1882
return (IPv4Address((self._ip >> 64) & 0xFFFFFFFF),
1883
IPv4Address(~self._ip & 0xFFFFFFFF))
1884
1885
@property
1886
def sixtofour(self):
1887
"""Return the IPv4 6to4 embedded address.
1888
1889
Returns:
1890
The IPv4 6to4-embedded address if present or None if the
1891
address doesn't appear to contain a 6to4 embedded address.
1892
1893
"""
1894
if (self._ip >> 112) != 0x2002:
1895
return None
1896
return IPv4Address((self._ip >> 80) & 0xFFFFFFFF)
1897
1898
1899
class IPv6Interface(IPv6Address):
1900
1901
def __init__(self, address):
1902
if isinstance(address, (bytes, int)):
1903
IPv6Address.__init__(self, address)
1904
self.network = IPv6Network(self._ip)
1905
self._prefixlen = self._max_prefixlen
1906
return
1907
1908
addr = _split_optional_netmask(address)
1909
IPv6Address.__init__(self, addr[0])
1910
self.network = IPv6Network(address, strict=False)
1911
self.netmask = self.network.netmask
1912
self._prefixlen = self.network._prefixlen
1913
self.hostmask = self.network.hostmask
1914
1915
def __str__(self):
1916
return '%s/%d' % (self._string_from_ip_int(self._ip),
1917
self.network.prefixlen)
1918
1919
def __eq__(self, other):
1920
address_equal = IPv6Address.__eq__(self, other)
1921
if not address_equal or address_equal is NotImplemented:
1922
return address_equal
1923
try:
1924
return self.network == other.network
1925
except AttributeError:
1926
# An interface with an associated network is NOT the
1927
# same as an unassociated address. That's why the hash
1928
# takes the extra info into account.
1929
return False
1930
1931
def __lt__(self, other):
1932
address_less = IPv6Address.__lt__(self, other)
1933
if address_less is NotImplemented:
1934
return NotImplemented
1935
try:
1936
return self.network < other.network
1937
except AttributeError:
1938
# We *do* allow addresses and interfaces to be sorted. The
1939
# unassociated address is considered less than all interfaces.
1940
return False
1941
1942
def __hash__(self):
1943
return self._ip ^ self._prefixlen ^ int(self.network.network_address)
1944
1945
@property
1946
def ip(self):
1947
return IPv6Address(self._ip)
1948
1949
@property
1950
def with_prefixlen(self):
1951
return '%s/%s' % (self._string_from_ip_int(self._ip),
1952
self._prefixlen)
1953
1954
@property
1955
def with_netmask(self):
1956
return '%s/%s' % (self._string_from_ip_int(self._ip),
1957
self.netmask)
1958
1959
@property
1960
def with_hostmask(self):
1961
return '%s/%s' % (self._string_from_ip_int(self._ip),
1962
self.hostmask)
1963
1964
@property
1965
def is_unspecified(self):
1966
return self._ip == 0 and self.network.is_unspecified
1967
1968
@property
1969
def is_loopback(self):
1970
return self._ip == 1 and self.network.is_loopback
1971
1972
1973
class IPv6Network(_BaseV6, _BaseNetwork):
1974
1975
"""This class represents and manipulates 128-bit IPv6 networks.
1976
1977
Attributes: [examples for IPv6('2001:db8::1000/124')]
1978
.network_address: IPv6Address('2001:db8::1000')
1979
.hostmask: IPv6Address('::f')
1980
.broadcast_address: IPv6Address('2001:db8::100f')
1981
.netmask: IPv6Address('ffff:ffff:ffff:ffff:ffff:ffff:ffff:fff0')
1982
.prefixlen: 124
1983
1984
"""
1985
1986
# Class to use when creating address objects
1987
_address_class = IPv6Address
1988
1989
def __init__(self, address, strict=True):
1990
"""Instantiate a new IPv6 Network object.
1991
1992
Args:
1993
address: A string or integer representing the IPv6 network or the
1994
IP and prefix/netmask.
1995
'2001:db8::/128'
1996
'2001:db8:0000:0000:0000:0000:0000:0000/128'
1997
'2001:db8::'
1998
are all functionally the same in IPv6. That is to say,
1999
failing to provide a subnetmask will create an object with
2000
a mask of /128.
2001
2002
Additionally, an integer can be passed, so
2003
IPv6Network('2001:db8::') ==
2004
IPv6Network(42540766411282592856903984951653826560)
2005
or, more generally
2006
IPv6Network(int(IPv6Network('2001:db8::'))) ==
2007
IPv6Network('2001:db8::')
2008
2009
strict: A boolean. If true, ensure that we have been passed
2010
A true network address, eg, 2001:db8::1000/124 and not an
2011
IP address on a network, eg, 2001:db8::1/124.
2012
2013
Raises:
2014
AddressValueError: If address isn't a valid IPv6 address.
2015
NetmaskValueError: If the netmask isn't valid for
2016
an IPv6 address.
2017
ValueError: If strict was True and a network address was not
2018
supplied.
2019
2020
"""
2021
_BaseV6.__init__(self, address)
2022
_BaseNetwork.__init__(self, address)
2023
2024
# Efficient constructor from integer.
2025
if isinstance(address, int):
2026
self.network_address = IPv6Address(address)
2027
self._prefixlen = self._max_prefixlen
2028
self.netmask = IPv6Address(self._ALL_ONES)
2029
return
2030
2031
# Constructing from a packed address
2032
if isinstance(address, bytes):
2033
self.network_address = IPv6Address(address)
2034
self._prefixlen = self._max_prefixlen
2035
self.netmask = IPv6Address(self._ALL_ONES)
2036
return
2037
2038
# Assume input argument to be string or any object representation
2039
# which converts into a formatted IP prefix string.
2040
addr = _split_optional_netmask(address)
2041
2042
self.network_address = IPv6Address(self._ip_int_from_string(addr[0]))
2043
2044
if len(addr) == 2:
2045
if self._is_valid_netmask(addr[1]):
2046
self._prefixlen = int(addr[1])
2047
else:
2048
raise NetmaskValueError('%r is not a valid netmask'
2049
% addr[1])
2050
else:
2051
self._prefixlen = self._max_prefixlen
2052
2053
self.netmask = IPv6Address(self._ip_int_from_prefix(self._prefixlen))
2054
if strict:
2055
if (IPv6Address(int(self.network_address) & int(self.netmask)) !=
2056
self.network_address):
2057
raise ValueError('%s has host bits set' % self)
2058
self.network_address = IPv6Address(int(self.network_address) &
2059
int(self.netmask))
2060
2061
if self._prefixlen == (self._max_prefixlen - 1):
2062
self.hosts = self.__iter__
2063
2064
def _is_valid_netmask(self, prefixlen):
2065
"""Verify that the netmask/prefixlen is valid.
2066
2067
Args:
2068
prefixlen: A string, the netmask in prefix length format.
2069
2070
Returns:
2071
A boolean, True if the prefix represents a valid IPv6
2072
netmask.
2073
2074
"""
2075
try:
2076
prefixlen = int(prefixlen)
2077
except ValueError:
2078
return False
2079
return 0 <= prefixlen <= self._max_prefixlen
2080
2081
@property
2082
def is_site_local(self):
2083
"""Test if the address is reserved for site-local.
2084
2085
Note that the site-local address space has been deprecated by RFC 3879.
2086
Use is_private to test if this address is in the space of unique local
2087
addresses as defined by RFC 4193.
2088
2089
Returns:
2090
A boolean, True if the address is reserved per RFC 3513 2.5.6.
2091
2092
"""
2093
return (self.network_address.is_site_local and
2094
self.broadcast_address.is_site_local)
Loggerhead is a web-based interface for Breezy
Version: 2.0.1