2

import math

     3

     4

def reverse_ipv4 (ip) :

     5

    """

     6

        Return in-addr.arpa reverse for given IPv4 prefix.

     7

    """

     8

     9

    # parse

    10

    octets = tuple(int(part) for part in ip.split('.'))

    11

    12

    for octet in octets :

    13

        assert 0 <= octet <= 255

    14

    15

    return '.'.join([str(octet) for octet in reversed(octets)] + ['in-addr', 'arpa'])

    16

    17

def reverse_ipv6 (ip6) :

    18

    """

    19

        Return ip6.arpa reverse for given IPv6 prefix.

    20

    """

    21

    22

    # XXX: this is broken for fd80::1?

    23

    parts = [int(part, 16) for part in ip6.split(':')]

    24

    parts = ['{0:04x}'.format(part) for part in parts]

    25

    parts = ''.join(parts)

    26

    27

    return '.'.join(tuple(reversed(parts)) + ( 'ip6', 'arpa'))

    28

    29

def reverse_label (prefix, address) :

    30

    """

    31

        Determine the correct label for the given IP address within the reverse zone for the given prefix.

    32

    33

        This includes all suffix octets (partially) covered by the prefix.

    34

    """

    35

    36

    assert prefix.version == address.version

    37

    assert address in prefix

    38

    39

    hostbits = prefix.max_prefixlen - prefix.prefixlen

    40

    41

    if prefix.version == 4 :

    42

        # pack into octets

    43

        octets = [ord(x) for x in address.packed]

    44

    45

        # take the suffix

    46

        octets = octets[-int(math.ceil(hostbits / 8.0)):]

    47

    48

        # reverse in decimal

    49

        return '.'.join(reversed(["{0:d}".format(x) for x in octets]))

    50

    51

    elif prefix.version == 6 :

    52

        # pack into nibbles

    53

        nibbles = [((ord(x) >> 4) & 0xf, ord(x) & 0xf) for x in address.packed]

    54

        nibbles = [nibble for nibblepair in nibbles for nibble in nibblepair]

    55

    56

        # take the suffix

    57

        nibbles = nibbles[-(hostbits / 4):]

    58

    60

        return '.'.join(reversed(["{0:x}".format(x) for x in nibbles]))

    61

    62

    else :

    63

        raise ValueError("unsupported address version: %s" % (prefix, ))

    64

    65

def _split_ipv6_parts (prefix) :

    66

    """

    67

        Split a partial IPv6 address into hexadecimal nibbles

    68

    """

    69

    70

    if prefix.endswith('::'):

    71

        prefix = prefix[:-2]

    72

    73

    for hextet in prefix.split(':') :

    74

        for nibble in hextet.rjust(4, '0') :

    75

            yield nibble

    76

    77

def _build_ipv6_parts (parts) :

    78

    """

    79

        Group an iterable of hexadecimal nibbles into hextets.

    80

    """

    81

    82

    for i in xrange(0, len(parts), 4) :

    84

    85

    # suffix ::

    86

    if len(parts) < 32 :

    89

    90

def parse_prefix (prefix) :

    91

    """

    93

    94

        Supports partial IPv4 prefixes on octet boundaries.

    95

        Supports partial IPv6 prefixes on nibble boundaries.

    96

        Supports IPv4 prefxies using "-" as the prefix separator in place of "/".

    97

   116

    """

   117

   120

    if '/' in prefix :

   122

   123

    elif '-' in prefix :

   125

   126

    elif '.' in prefix or prefix.isdigit() :

   127

        parts = prefix.rstrip('.').split('.')

   128

        prefixlen = len(parts) * 8

   129

   132

            prefixlen   = prefixlen,

   133

        ))

   134

   135

    elif ':' in prefix :

   136

        parts = list(_split_ipv6_parts(prefix))

   137

        prefixlen = len(parts) * 4

   138

   141

            prefixlen   = prefixlen,

   142

        ))

   143

   144

    else :

   145

        raise ValueError("Unrecognized IP prefix string: %s" % (prefix, ))

   146