Tooltron

# This code was mostly based on ipaddr-py

# Copyright 2007 Google Inc. http://code.google.com/p/ipaddr-py/

# Licensed under the Apache License, Version 2.0 (the "License").

from django.core.exceptions import ValidationError

def clean_ipv6_address(ip_str, unpack_ipv4=False,

        error_message="This is not a valid IPv6 address"):

    """

    Cleans a IPv6 address string.

    Validity is checked by calling is_valid_ipv6_address() - if an

    invalid address is passed, ValidationError is raised.

    Replaces the longest continious zero-sequence with "::" and

    removes leading zeroes and makes sure all hextets are lowercase.

    Args:

        ip_str: A valid IPv6 address.

        unpack_ipv4: if an IPv4-mapped address is found,

        return the plain IPv4 address (default=False).

        error_message: A error message for in the ValidationError.

    Returns:

        A compressed IPv6 address, or the same value

    """

    best_doublecolon_start = -1

    best_doublecolon_len = 0

    doublecolon_start = -1

    doublecolon_len = 0

    if not is_valid_ipv6_address(ip_str):

        raise ValidationError(error_message)

    # This algorithm can only handle fully exploded

    # IP strings

    ip_str = _explode_shorthand_ip_string(ip_str)

    ip_str = _sanitize_ipv4_mapping(ip_str)

    # If needed, unpack the IPv4 and return straight away

    # - no need in running the rest of the algorithm

    if unpack_ipv4:

        ipv4_unpacked = _unpack_ipv4(ip_str)

        if ipv4_unpacked:

            return ipv4_unpacked

    hextets = ip_str.split(":")

    for index in range(len(hextets)):

        # Remove leading zeroes

        hextets[index] = hextets[index].lstrip('0')

        if not hextets[index]:

            hextets[index] = '0'

        # Determine best hextet to compress

        if hextets[index] == '0':

            doublecolon_len += 1

            if doublecolon_start == -1:

                # Start of a sequence of zeros.

                doublecolon_start = index

            if doublecolon_len > best_doublecolon_len:

                # This is the longest sequence of zeros so far.

                best_doublecolon_len = doublecolon_len

                best_doublecolon_start = doublecolon_start

        else:

            doublecolon_len = 0

            doublecolon_start = -1

    # Compress the most suitable hextet

    if best_doublecolon_len > 1:

        best_doublecolon_end = (best_doublecolon_start +

                                best_doublecolon_len)

        # For zeros at the end of the address.

        if best_doublecolon_end == len(hextets):

            hextets += ['']

        hextets[best_doublecolon_start:best_doublecolon_end] = ['']

        # For zeros at the beginning of the address.

        if best_doublecolon_start == 0:

            hextets = [''] + hextets

    result = ":".join(hextets)

    return result.lower()

def _sanitize_ipv4_mapping(ip_str):

    """

    Sanitize IPv4 mapping in a expanded IPv6 address.

    This converts ::ffff:0a0a:0a0a to ::ffff:10.10.10.10.

    If there is nothing to sanitize, returns an unchanged

    string.

    Args:

        ip_str: A string, the expanded IPv6 address.

    Returns:

        The sanitized output string, if applicable.

    """

    if not ip_str.lower().startswith('0000:0000:0000:0000:0000:ffff:'):

        # not an ipv4 mapping

        return ip_str

    hextets = ip_str.split(':')

    if '.' in hextets[-1]:

        # already sanitized

        return ip_str

    ipv4_address = "%d.%d.%d.%d" % (

        int(hextets[6][0:2], 16),

        int(hextets[6][2:4], 16),

        int(hextets[7][0:2], 16),

        int(hextets[7][2:4], 16),

    )

    result = ':'.join(hextets[0:6])

    result += ':' + ipv4_address

    return result

def _unpack_ipv4(ip_str):

    """

    Unpack an IPv4 address that was mapped in a compressed IPv6 address.

    This converts 0000:0000:0000:0000:0000:ffff:10.10.10.10 to 10.10.10.10.

    If there is nothing to sanitize, returns None.

    Args:

        ip_str: A string, the expanded IPv6 address.

    Returns:

        The unpacked IPv4 address, or None if there was nothing to unpack.

    """

    if not ip_str.lower().startswith('0000:0000:0000:0000:0000:ffff:'):

        return None

    hextets = ip_str.split(':')

    return hextets[-1]

def is_valid_ipv6_address(ip_str):

    """

    Ensure we have a valid IPv6 address.

    Args:

        ip_str: A string, the IPv6 address.

    Returns:

        A boolean, True if this is a valid IPv6 address.

    """

    from django.core.validators import validate_ipv4_address

    # We need to have at least one ':'.

    if ':' not in ip_str:

        return False

    # We can only have one '::' shortener.

    if ip_str.count('::') > 1:

        return False

    # '::' should be encompassed by start, digits or end.

    if ':::' in ip_str:

        return False

    # A single colon can neither start nor end an address.

    if ((ip_str.startswith(':') and not ip_str.startswith('::')) or

            (ip_str.endswith(':') and not ip_str.endswith('::'))):

        return False

    # We can never have more than 7 ':' (1::2:3:4:5:6:7:8 is invalid)

    if ip_str.count(':') > 7:

        return False

    # If we have no concatenation, we need to have 8 fields with 7 ':'.

    if '::' not in ip_str and ip_str.count(':') != 7:

        # We might have an IPv4 mapped address.

        if ip_str.count('.') != 3:

            return False

    ip_str = _explode_shorthand_ip_string(ip_str)

    # Now that we have that all squared away, let's check that each of the

    # hextets are between 0x0 and 0xFFFF.

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

        if hextet.count('.') == 3:

            # If we have an IPv4 mapped address, the IPv4 portion has to

            # be at the end of the IPv6 portion.

            if not ip_str.split(':')[-1] == hextet:

                return False

            try:

                validate_ipv4_address(hextet)

            except ValidationError:

                return False

        else:

            try:

                # a value error here means that we got a bad hextet,

                # something like 0xzzzz

                if int(hextet, 16) < 0x0 or int(hextet, 16) > 0xFFFF:

                    return False

            except ValueError:

                return False

    return True

def _explode_shorthand_ip_string(ip_str):

    """

    Expand a shortened IPv6 address.

    Args:

        ip_str: A string, the IPv6 address.

    Returns:

        A string, the expanded IPv6 address.

    """

    if not _is_shorthand_ip(ip_str):

        # We've already got a longhand ip_str.

        return ip_str

    new_ip = []

    hextet = ip_str.split('::')

    # If there is a ::, we need to expand it with zeroes

    # to get to 8 hextets - unless there is a dot in the last hextet,

    # meaning we're doing v4-mapping

    if '.' in ip_str.split(':')[-1]:

        fill_to = 7

    else:

        fill_to = 8

    if len(hextet) > 1:

        sep = len(hextet[0].split(':')) + len(hextet[1].split(':'))

        new_ip = hextet[0].split(':')

        for _ in xrange(fill_to - sep):

            new_ip.append('0000')

        new_ip += hextet[1].split(':')

    else:

        new_ip = ip_str.split(':')

    # Now need to make sure every hextet is 4 lower case characters.

    # If a hextet is < 4 characters, we've got missing leading 0's.

    ret_ip = []

    for hextet in new_ip:

        ret_ip.append(('0' * (4 - len(hextet)) + hextet).lower())

    return ':'.join(ret_ip)

def _is_shorthand_ip(ip_str):

    """Determine if the address is shortened.

    Args:

        ip_str: A string, the IPv6 address.

    Returns:

        A boolean, True if the address is shortened.

    """

    if ip_str.count('::') == 1:

        return True

    if filter(lambda x: len(x) < 4, ip_str.split(':')):

        return True

    return False