# vim: set ts=4 et sw=4 tw=80
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.

import ipaddr
import socket
import hmac
import hashlib
import passlib.utils  # for saslprep
import copy
import random
import operator
import os
import platform
import six
import string
import time
from functools import reduce
from string import Template
from twisted.internet import reactor, protocol
from twisted.internet.task import LoopingCall
from twisted.internet.address import IPv4Address
from twisted.internet.address import IPv6Address

MAGIC_COOKIE = 0x2112A442

REQUEST = 0
INDICATION = 1
SUCCESS_RESPONSE = 2
ERROR_RESPONSE = 3

BINDING = 0x001
ALLOCATE = 0x003
REFRESH = 0x004
SEND = 0x006
DATA_MSG = 0x007
CREATE_PERMISSION = 0x008
CHANNEL_BIND = 0x009

# STUN spec chose silly values for these
STUN_IPV4 = 1
STUN_IPV6 = 2

MAPPED_ADDRESS = 0x0001
USERNAME = 0x0006
MESSAGE_INTEGRITY = 0x0008
ERROR_CODE = 0x0009
UNKNOWN_ATTRIBUTES = 0x000A
LIFETIME = 0x000D
DATA_ATTR = 0x0013
XOR_PEER_ADDRESS = 0x0012
REALM = 0x0014
NONCE = 0x0015
XOR_RELAYED_ADDRESS = 0x0016
REQUESTED_TRANSPORT = 0x0019
DONT_FRAGMENT = 0x001A
XOR_MAPPED_ADDRESS = 0x0020
SOFTWARE = 0x8022
ALTERNATE_SERVER = 0x8023
FINGERPRINT = 0x8028

STUN_PORT = 3478
STUNS_PORT = 5349

TURN_REDIRECT_PORT = 3479
TURNS_REDIRECT_PORT = 5350


def unpack_uint(bytes_buf):
    result = 0
    for byte in bytes_buf:
        result = (result << 8) + byte
    return result


def pack_uint(value, width):
    if value < 0:
        raise ValueError("Invalid value: {}".format(value))
    buf = bytearray([0] * width)
    for i in range(0, width):
        buf[i] = (value >> (8 * (width - i - 1))) & 0xFF

    return buf


def unpack(bytes_buf, format_array):
    results = ()
    for width in format_array:
        results = results + (unpack_uint(bytes_buf[0:width]),)
        bytes_buf = bytes_buf[width:]
    return results


def pack(values, format_array):
    if len(values) != len(format_array):
        raise ValueError()
    buf = bytearray()
    for i in range(0, len(values)):
        buf.extend(pack_uint(values[i], format_array[i]))
    return buf


def bitwise_pack(source, dest, start_bit, num_bits):
    if num_bits <= 0 or num_bits > start_bit + 1:
        raise ValueError(
            "Invalid num_bits: {}, start_bit = {}".format(num_bits, start_bit)
        )
    last_bit = start_bit - num_bits + 1
    source = source >> last_bit
    dest = dest << num_bits
    mask = (1 << num_bits) - 1
    dest += source & mask
    return dest


def to_ipaddress(protocol, host, port):
    if ":" not in host:
        return IPv4Address(protocol, host, port)

    return IPv6Address(protocol, host, port)


class StunAttribute(object):
    """
    Represents a STUN attribute in a raw format, according to the following:

     0                   1                   2                   3
     0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    |   StunAttribute.attr_type     |  Length (derived as needed)   |
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    |           StunAttribute.data (variable length)             ....
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    """

    __attr_header_fmt = [2, 2]
    __attr_header_size = reduce(operator.add, __attr_header_fmt)

    def __init__(self, attr_type=0, buf=bytearray()):
        self.attr_type = attr_type
        self.data = buf

    def build(self):
        buf = pack((self.attr_type, len(self.data)), self.__attr_header_fmt)
        buf.extend(self.data)
        # add padding if necessary
        if len(buf) % 4:
            buf.extend([0] * (4 - (len(buf) % 4)))
        return buf

    def parse(self, buf):
        if self.__attr_header_size > len(buf):
            raise Exception("truncated at attribute: incomplete header")

        self.attr_type, length = unpack(buf, self.__attr_header_fmt)
        length += self.__attr_header_size

        if length > len(buf):
            raise Exception("truncated at attribute: incomplete contents")

        self.data = buf[self.__attr_header_size : length]

        # verify padding
        while length % 4:
            if buf[length]:
                raise ValueError("Non-zero padding")
            length += 1

        return length


class StunMessage(object):
    """
    Represents a STUN message. Contains a method, msg_class, cookie,
    transaction_id, and attributes (as an array of StunAttribute).

    Has various functions for getting/adding attributes.
    """

    def __init__(self):
        self.method = 0
        self.msg_class = 0
        self.cookie = MAGIC_COOKIE
        self.transaction_id = 0
        self.attributes = []

    #      0                   1                   2                   3
    #      0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
    #     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    #     |0 0|M M M M M|C|M M M|C|M M M M|         Message Length        |
    #     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    #     |                         Magic Cookie                          |
    #     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    #     |                                                               |
    #     |                     Transaction ID (96 bits)                  |
    #     |                                                               |
    #     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    __header_fmt = [2, 2, 4, 12]
    __header_size = reduce(operator.add, __header_fmt)

    # Returns how many bytes were parsed if buf was large enough, or how many
    # bytes we would have needed if not. Throws if buf is malformed.
    def parse(self, buf):
        min_buf_size = self.__header_size
        if len(buf) < min_buf_size:
            return min_buf_size

        message_type, length, cookie, self.transaction_id = unpack(
            buf, self.__header_fmt
        )
        min_buf_size += length
        if len(buf) < min_buf_size:
            return min_buf_size

        # Avert your eyes...
        self.method = bitwise_pack(message_type, 0, 13, 5)
        self.msg_class = bitwise_pack(message_type, 0, 8, 1)
        self.method = bitwise_pack(message_type, self.method, 7, 3)
        self.msg_class = bitwise_pack(message_type, self.msg_class, 4, 1)
        self.method = bitwise_pack(message_type, self.method, 3, 4)

        if cookie != self.cookie:
            raise Exception("Invalid cookie: {}".format(cookie))

        buf = buf[self.__header_size : min_buf_size]
        while len(buf):
            attr = StunAttribute()
            length = attr.parse(buf)
            buf = buf[length:]
            self.attributes.append(attr)

        return min_buf_size

    # stop_after_attr_type is useful for calculating MESSAGE-DIGEST
    def build(self, stop_after_attr_type=0):
        attrs = bytearray()
        for attr in self.attributes:
            attrs.extend(attr.build())
            if attr.attr_type == stop_after_attr_type:
                break

        message_type = bitwise_pack(self.method, 0, 11, 5)
        message_type = bitwise_pack(self.msg_class, message_type, 1, 1)
        message_type = bitwise_pack(self.method, message_type, 6, 3)
        message_type = bitwise_pack(self.msg_class, message_type, 0, 1)
        message_type = bitwise_pack(self.method, message_type, 3, 4)

        message = pack(
            (message_type, len(attrs), self.cookie, self.transaction_id),
            self.__header_fmt,
        )
        message.extend(attrs)

        return message

    def add_error_code(self, code, phrase=None):
        #      0                   1                   2                   3
        #      0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
        #     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
        #     |           Reserved, should be 0         |Class|     Number    |
        #     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
        #     |      Reason Phrase (variable)                                ..
        #     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
        error_code_fmt = [3, 1]
        error_code = pack((code // 100, code % 100), error_code_fmt)
        if phrase != None:
            error_code.extend(bytearray(phrase, "utf-8"))
        self.attributes.append(StunAttribute(ERROR_CODE, error_code))

    #     0                   1                   2                   3
    #     0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
    #    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    #    |x x x x x x x x|    Family     |         X-Port                |
    #    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    #    |                X-Address (Variable)
    #    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    __v4addr_fmt = [1, 1, 2, 4]
    __v6addr_fmt = [1, 1, 2, 16]
    __v4addr_size = reduce(operator.add, __v4addr_fmt)
    __v6addr_size = reduce(operator.add, __v6addr_fmt)

    def add_address(self, ip_address, version, port, attr_type):
        if version == STUN_IPV4:
            address = pack((0, STUN_IPV4, port, ip_address), self.__v4addr_fmt)
        elif version == STUN_IPV6:
            address = pack((0, STUN_IPV6, port, ip_address), self.__v6addr_fmt)
        else:
            raise ValueError("Invalid ip version: {}".format(version))
        self.attributes.append(StunAttribute(attr_type, address))

    def get_xaddr(self, ip_addr, version):
        if version == STUN_IPV4:
            return self.cookie ^ ip_addr
        elif version == STUN_IPV6:
            return ((self.cookie << 96) + self.transaction_id) ^ ip_addr
        else:
            raise ValueError("Invalid family: {}".format(version))

    def get_xport(self, port):
        return (self.cookie >> 16) ^ port

    def add_xor_address(self, addr_port, attr_type):
        ip_address = ipaddr.IPAddress(addr_port.host)
        version = STUN_IPV6 if ip_address.version == 6 else STUN_IPV4
        xaddr = self.get_xaddr(int(ip_address), version)
        xport = self.get_xport(addr_port.port)
        self.add_address(xaddr, version, xport, attr_type)

    def add_data(self, buf):
        self.attributes.append(StunAttribute(DATA_ATTR, buf))

    def find(self, attr_type):
        for attr in self.attributes:
            if attr.attr_type == attr_type:
                return attr
        return None

    def get_xor_address(self, attr_type):
        addr_attr = self.find(attr_type)
        if not addr_attr:
            return None

        padding, family, xport, xaddr = unpack(addr_attr.data, self.__v4addr_fmt)
        addr_ctor = IPv4Address
        if family == STUN_IPV6:
            padding, family, xport, xaddr = unpack(addr_attr.data, self.__v6addr_fmt)
            addr_ctor = IPv6Address
        elif family != STUN_IPV4:
            raise ValueError("Invalid family: {}".format(family))

        return addr_ctor(
            "UDP",
            str(ipaddr.IPAddress(self.get_xaddr(xaddr, family))),
            self.get_xport(xport),
        )

    def add_nonce(self, nonce):
        self.attributes.append(StunAttribute(NONCE, bytearray(nonce, "utf-8")))

    def add_realm(self, realm):
        self.attributes.append(StunAttribute(REALM, bytearray(realm, "utf-8")))

    def calculate_message_digest(self, username, realm, password):
        digest_buf = self.build(MESSAGE_INTEGRITY)
        # Trim off the MESSAGE-INTEGRITY attr
        digest_buf = digest_buf[: len(digest_buf) - 24]
        password = passlib.utils.saslprep(six.text_type(password))
        key_string = "{}:{}:{}".format(username, realm, password)
        md5 = hashlib.md5()
        md5.update(bytearray(key_string, "utf-8"))
        key = md5.digest()
        return bytearray(hmac.new(key, digest_buf, hashlib.sha1).digest())

    def add_lifetime(self, lifetime):
        self.attributes.append(StunAttribute(LIFETIME, pack_uint(lifetime, 4)))

    def get_lifetime(self):
        lifetime_attr = self.find(LIFETIME)
        if not lifetime_attr:
            return None
        return unpack_uint(lifetime_attr.data[0:4])

    def get_username(self):
        username = self.find(USERNAME)
        if not username:
            return None
        return str(username.data)

    def add_message_integrity(self, username, realm, password):
        dummy_value = bytearray([0] * 20)
        self.attributes.append(StunAttribute(MESSAGE_INTEGRITY, dummy_value))
        digest = self.calculate_message_digest(username, realm, password)
        self.find(MESSAGE_INTEGRITY).data = digest

    def add_alternate_server(self, host, port):
        address = ipaddr.IPAddress(host)
        version = STUN_IPV6 if address.version == 6 else STUN_IPV4
        self.add_address(int(address), version, port, ALTERNATE_SERVER)


class Allocation(protocol.DatagramProtocol):
    """
    Comprises the socket for a TURN allocation, a back-reference to the
    transport we will forward received traffic on, the allocator's address and
    username, the set of permissions for the allocation, and the allocation's
    expiry.
    """

    def __init__(self, other_transport_handler, allocator_address, username):
        self.permissions = set()  # str, int tuples
        # Handler to use when sending stuff that arrives on the allocation
        self.other_transport_handler = other_transport_handler
        self.allocator_address = allocator_address
        self.username = username
        self.expiry = time.time()
        self.port = reactor.listenUDP(0, self, interface=v4_address)

    def datagramReceived(self, data, address):
        host = address[0]
        port = address[1]
        if not host in self.permissions:
            print(
                "Dropping packet from {}:{}, no permission on allocation {}".format(
                    host, port, self.transport.getHost()
                )
            )
            return

        data_indication = StunMessage()
        data_indication.method = DATA_MSG
        data_indication.msg_class = INDICATION
        data_indication.transaction_id = random.getrandbits(96)

        # Only handles UDP allocations. Doubtful that we need more than this.
        data_indication.add_xor_address(
            to_ipaddress("UDP", host, port), XOR_PEER_ADDRESS
        )
        data_indication.add_data(data)

        self.other_transport_handler.write(
            data_indication.build(), self.allocator_address
        )

    def close(self):
        self.port.stopListening()
        self.port = None


class StunHandler(object):
    """
    Frames and handles STUN messages. This is the core logic of the TURN
    server, along with Allocation.
    """

    def __init__(self, transport_handler):
        self.client_address = None
        self.data = bytearray()
        self.transport_handler = transport_handler

    def data_received(self, data, address):
        self.data += data
        while True:
            stun_message = StunMessage()
            parsed_len = stun_message.parse(self.data)
            if parsed_len > len(self.data):
                break
            self.data = self.data[parsed_len:]

            response = self.handle_stun(stun_message, address)
            if response:
                self.transport_handler.write(response, address)

    def handle_stun(self, stun_message, address):
        self.client_address = address
        if stun_message.msg_class == INDICATION:
            if stun_message.method == SEND:
                self.handle_send_indication(stun_message)
            else:
                print(
                    "Dropping unknown indication method: {}".format(stun_message.method)
                )
            return None

        if stun_message.msg_class != REQUEST:
            print("Dropping STUN response, method: {}".format(stun_message.method))
            return None

        if stun_message.method == BINDING:
            return self.make_success_response(stun_message).build()
        elif stun_message.method == ALLOCATE:
            return self.handle_allocation(stun_message).build()
        elif stun_message.method == REFRESH:
            return self.handle_refresh(stun_message).build()
        elif stun_message.method == CREATE_PERMISSION:
            return self.handle_permission(stun_message).build()
        else:
            return self.make_error_response(
                stun_message,
                400,
                ("Unsupported STUN request, method: {}".format(stun_message.method)),
            ).build()

    def get_allocation_tuple(self):
        return (
            self.client_address.host,
            self.client_address.port,
            self.transport_handler.transport.getHost().type,
            self.transport_handler.transport.getHost().host,
            self.transport_handler.transport.getHost().port,
        )

    def handle_allocation(self, request):
        allocate_response = self.check_long_term_auth(request)
        if allocate_response.msg_class == SUCCESS_RESPONSE:
            if self.get_allocation_tuple() in allocations:
                return self.make_error_response(
                    request,
                    437,
                    (
                        "Duplicate allocation request for tuple {}".format(
                            self.get_allocation_tuple()
                        )
                    ),
                )

            allocation = Allocation(
                self.transport_handler, self.client_address, request.get_username()
            )

            allocate_response.add_xor_address(
                allocation.transport.getHost(), XOR_RELAYED_ADDRESS
            )

            lifetime = request.get_lifetime()
            if lifetime == None:
                return self.make_error_response(
                    request, 400, "Missing lifetime attribute in allocation request"
                )

            lifetime = min(lifetime, 3600)
            allocate_response.add_lifetime(lifetime)
            allocation.expiry = time.time() + lifetime

            allocate_response.add_message_integrity(turn_user, turn_realm, turn_pass)
            allocations[self.get_allocation_tuple()] = allocation
        return allocate_response

    def handle_refresh(self, request):
        refresh_response = self.check_long_term_auth(request)
        if refresh_response.msg_class == SUCCESS_RESPONSE:
            try:
                allocation = allocations[self.get_allocation_tuple()]
            except KeyError:
                return self.make_error_response(
                    request,
                    437,
                    (
                        "Refresh request for non-existing allocation, tuple {}".format(
                            self.get_allocation_tuple()
                        )
                    ),
                )

            if allocation.username != request.get_username():
                return self.make_error_response(
                    request,
                    441,
                    (
                        "Refresh request with wrong user, exp {}, got {}".format(
                            allocation.username, request.get_username()
                        )
                    ),
                )

            lifetime = request.get_lifetime()
            if lifetime == None:
                return self.make_error_response(
                    request, 400, "Missing lifetime attribute in allocation request"
                )

            lifetime = min(lifetime, 3600)
            refresh_response.add_lifetime(lifetime)
            allocation.expiry = time.time() + lifetime

            refresh_response.add_message_integrity(turn_user, turn_realm, turn_pass)
        return refresh_response

    def handle_permission(self, request):
        permission_response = self.check_long_term_auth(request)
        if permission_response.msg_class == SUCCESS_RESPONSE:
            try:
                allocation = allocations[self.get_allocation_tuple()]
            except KeyError:
                return self.make_error_response(
                    request,
                    437,
                    (
                        "No such allocation for permission request, tuple {}".format(
                            self.get_allocation_tuple()
                        )
                    ),
                )

            if allocation.username != request.get_username():
                return self.make_error_response(
                    request,
                    441,
                    (
                        "Permission request with wrong user, exp {}, got {}".format(
                            allocation.username, request.get_username()
                        )
                    ),
                )

            # TODO: Handle multiple XOR-PEER-ADDRESS
            peer_address = request.get_xor_address(XOR_PEER_ADDRESS)
            if not peer_address:
                return self.make_error_response(
                    request, 400, "Missing XOR-PEER-ADDRESS on permission request"
                )

            permission_response.add_message_integrity(turn_user, turn_realm, turn_pass)
            allocation.permissions.add(peer_address.host)

        return permission_response

    def handle_send_indication(self, indication):
        try:
            allocation = allocations[self.get_allocation_tuple()]
        except KeyError:
            print(
                "Dropping send indication; no allocation for tuple {}".format(
                    self.get_allocation_tuple()
                )
            )
            return

        peer_address = indication.get_xor_address(XOR_PEER_ADDRESS)
        if not peer_address:
            print("Dropping send indication, missing XOR-PEER-ADDRESS")
            return

        data_attr = indication.find(DATA_ATTR)
        if not data_attr:
            print("Dropping send indication, missing DATA")
            return

        if indication.find(DONT_FRAGMENT):
            print("Dropping send indication, DONT-FRAGMENT set")
            return

        if not peer_address.host in allocation.permissions:
            print(
                "Dropping send indication, no permission for {} on tuple {}".format(
                    peer_address.host, self.get_allocation_tuple()
                )
            )
            return

        allocation.transport.write(
            data_attr.data, (peer_address.host, peer_address.port)
        )

    def make_success_response(self, request):
        response = copy.deepcopy(request)
        response.attributes = []
        response.add_xor_address(self.client_address, XOR_MAPPED_ADDRESS)
        response.msg_class = SUCCESS_RESPONSE
        return response

    def make_error_response(self, request, code, reason=None):
        if reason:
            print("{}: rejecting with {}".format(reason, code))
        response = copy.deepcopy(request)
        response.attributes = []
        response.add_error_code(code, reason)
        response.msg_class = ERROR_RESPONSE
        return response

    def make_challenge_response(self, request, reason=None):
        response = self.make_error_response(request, 401, reason)
        # 65 means the hex encoding will need padding half the time
        response.add_nonce("{:x}".format(random.getrandbits(65)))
        response.add_realm(turn_realm)
        return response

    def check_long_term_auth(self, request):
        message_integrity = request.find(MESSAGE_INTEGRITY)
        if not message_integrity:
            return self.make_challenge_response(request)

        username = request.find(USERNAME)
        realm = request.find(REALM)
        nonce = request.find(NONCE)
        if not username or not realm or not nonce:
            return self.make_error_response(
                request, 400, "Missing either USERNAME, NONCE, or REALM"
            )

        if username.data.decode("utf-8") != turn_user:
            return self.make_challenge_response(
                request, "Wrong user {}, exp {}".format(username.data, turn_user)
            )

        expected_message_digest = request.calculate_message_digest(
            turn_user, turn_realm, turn_pass
        )
        if message_integrity.data != expected_message_digest:
            return self.make_challenge_response(request, "Incorrect message disgest")

        return self.make_success_response(request)


class StunRedirectHandler(StunHandler):
    """
    Frames and handles STUN messages by redirecting to the "real" server port.
    Performs the redirect with auth, so does a 401 to unauthed requests.
    Can be used to test port-based redirect handling.
    """

    def __init__(self, transport_handler):
        super(StunRedirectHandler, self).__init__(transport_handler)

    def handle_stun(self, stun_message, address):
        self.client_address = address
        if stun_message.msg_class == REQUEST:
            challenge_response = self.check_long_term_auth(stun_message)

            if challenge_response.msg_class == SUCCESS_RESPONSE:
                return self.make_redirect_response(stun_message).build()

            return challenge_response.build()

    def make_redirect_response(self, request):
        response = self.make_error_response(request, 300, "Try alternate")
        port = STUN_PORT
        if self.transport_handler.transport.getHost().port == TURNS_REDIRECT_PORT:
            port = STUNS_PORT

        response.add_alternate_server(
            self.transport_handler.transport.getHost().host, port
        )

        response.add_message_integrity(turn_user, turn_realm, turn_pass)
        return response


class UdpStunHandler(protocol.DatagramProtocol):
    """
    Represents a UDP listen port for TURN.
    """

    def datagramReceived(self, data, address):
        stun_handler = StunHandler(self)
        stun_handler.data_received(data, to_ipaddress("UDP", address[0], address[1]))

    def write(self, data, address):
        self.transport.write(bytes(data), (address.host, address.port))


class UdpStunRedirectHandler(protocol.DatagramProtocol):
    """
    Represents a UDP listen port for TURN that will redirect.
    """

    def datagramReceived(self, data, address):
        stun_handler = StunRedirectHandler(self)
        stun_handler.data_received(data, to_ipaddress("UDP", address[0], address[1]))

    def write(self, data, address):
        self.transport.write(bytes(data), (address.host, address.port))


class TcpStunHandlerFactory(protocol.Factory):
    """
    Represents a TCP listen port for TURN.
    """

    def buildProtocol(self, addr):
        return TcpStunHandler(addr)


class TcpStunHandler(protocol.Protocol):
    """
    Represents a connected TCP port for TURN.
    """

    def __init__(self, addr):
        self.address = addr
        self.stun_handler = None

    def dataReceived(self, data):
        # This needs to persist, since it handles framing
        if not self.stun_handler:
            self.stun_handler = StunHandler(self)
        self.stun_handler.data_received(data, self.address)

    def connectionLost(self, reason):
        print("Lost connection from {}".format(self.address))
        # Destroy allocations that this connection made
        keys_to_delete = []
        for key, allocation in allocations.items():
            if allocation.other_transport_handler == self:
                print("Closing allocation due to dropped connection: {}".format(key))
                keys_to_delete.append(key)
                allocation.close()

        for key in keys_to_delete:
            del allocations[key]

    def write(self, data, address):
        self.transport.write(bytes(data))


class TcpStunRedirectHandlerFactory(protocol.Factory):
    """
    Represents a TCP listen port for TURN that will redirect.
    """

    def buildProtocol(self, addr):
        return TcpStunRedirectHandler(addr)


class TcpStunRedirectHandler(protocol.DatagramProtocol):
    def __init__(self, addr):
        self.address = addr
        self.stun_handler = None

    def dataReceived(self, data):
        # This needs to persist, since it handles framing. Framing matters here
        # because we do a round of auth before redirecting.
        if not self.stun_handler:
            self.stun_handler = StunRedirectHandler(self)
        self.stun_handler.data_received(data, self.address)

    def write(self, data, address):
        self.transport.write(bytes(data))

    def connectionLost(self, reason):
        print("Lost connection from {}".format(self.address))


def get_default_route(family):
    dummy_socket = socket.socket(family, socket.SOCK_DGRAM)
    if family is socket.AF_INET:
        dummy_socket.connect(("8.8.8.8", 53))
    else:
        dummy_socket.connect(("2001:4860:4860::8888", 53))

    default_route = dummy_socket.getsockname()[0]
    dummy_socket.close()
    return default_route


turn_user = "foo"
turn_pass = "bar"
turn_realm = "mozilla.invalid"
allocations = {}
v4_address = get_default_route(socket.AF_INET)
try:
    v6_address = get_default_route(socket.AF_INET6)
except:
    v6_address = ""


def prune_allocations():
    now = time.time()
    keys_to_delete = []
    for key, allocation in allocations.items():
        if allocation.expiry < now:
            print("Allocation expired: {}".format(key))
            keys_to_delete.append(key)
            allocation.close()

    for key in keys_to_delete:
        del allocations[key]


CERT_FILE = "selfsigned.crt"
KEY_FILE = "private.key"


def create_self_signed_cert(name):
    # pyOpenSSL used to have some wrappers to help with this, but those have
    # been deprecated, and they have instructed users to use stuff from
    # cryptography.hazmat directly. This strikes me as a bad idea, but here we
    # go...

    from cryptography.hazmat.primitives.asymmetric import rsa
    from cryptography import x509
    from cryptography.x509.oid import NameOID
    from cryptography.hazmat.primitives import hashes
    import datetime
    from cryptography.hazmat.primitives import serialization

    # Not ideal, but in order to avoid generating certs with duplicate serial
    # numbers, we don't regenerate if there's one there already. If we wanted
    # to regenerate, we'd need to load the cert if it was there, determine its
    # serial number, and then make a new cert with a higher serial number.
    if os.path.isfile(CERT_FILE) and os.path.isfile(KEY_FILE):
        return

    # Key size does not need to be big, this is a self-signed cert for testing,
    # but I'm going to use something common to avoid warnings that might come
    # up in the future.
    # Why 65537? Because the documentation says so, citing a document written
    # by Colin Percival in 2009. Will this ever be out of date? Is it out of
    # date already? Who knows!
    key = rsa.generate_private_key(key_size=2048, public_exponent=65537)

    subject = x509.Name(
        [
            x509.NameAttribute(NameOID.COUNTRY_NAME, "US"),
            x509.NameAttribute(NameOID.STATE_OR_PROVINCE_NAME, "TX"),
            x509.NameAttribute(NameOID.LOCALITY_NAME, "Dallas"),
            x509.NameAttribute(NameOID.ORGANIZATION_NAME, "Mozilla test iceserver"),
            x509.NameAttribute(NameOID.COMMON_NAME, name),
        ]
    )

    # create a self-signed cert
    cert = (
        x509.CertificateBuilder()
        .subject_name(subject)
        .issuer_name(subject)
        .serial_number(1000)
        .not_valid_before(datetime.datetime.now(datetime.timezone.utc))
        .not_valid_after(
            datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(days=365)
        )
        .public_key(key.public_key())
        .add_extension(
            x509.SubjectAlternativeName([x509.DNSName(name)]),
            critical=False,
        )
        .sign(key, hashes.SHA256())
    )

    open(CERT_FILE, "wb").write(cert.public_bytes(encoding=serialization.Encoding.PEM))
    open(KEY_FILE, "wb").write(
        key.private_bytes(
            encoding=serialization.Encoding.PEM,
            format=serialization.PrivateFormat.PKCS8,
            encryption_algorithm=serialization.NoEncryption(),
        )
    )


if __name__ == "__main__":
    random.seed()

    if platform.system() == "Windows":
        # Windows is finicky about allowing real interfaces to talk to loopback.
        interface_4 = v4_address
        interface_6 = v6_address
        hostname = socket.gethostname()
    else:
        # Our linux builders do not have a hostname that resolves to the real
        # interface.
        interface_4 = "127.0.0.1"
        interface_6 = "::1"
        hostname = "localhost"

    reactor.listenUDP(STUN_PORT, UdpStunHandler(), interface=interface_4)
    reactor.listenTCP(STUN_PORT, TcpStunHandlerFactory(), interface=interface_4)

    reactor.listenUDP(
        TURN_REDIRECT_PORT, UdpStunRedirectHandler(), interface=interface_4
    )
    reactor.listenTCP(
        TURN_REDIRECT_PORT, TcpStunRedirectHandlerFactory(), interface=interface_4
    )

    try:
        reactor.listenUDP(STUN_PORT, UdpStunHandler(), interface=interface_6)
        reactor.listenTCP(STUN_PORT, TcpStunHandlerFactory(), interface=interface_6)

        reactor.listenUDP(
            TURN_REDIRECT_PORT, UdpStunRedirectHandler(), interface=interface_6
        )
        reactor.listenTCP(
            TURN_REDIRECT_PORT, TcpStunRedirectHandlerFactory(), interface=interface_6
        )
    except:
        pass

    try:
        from twisted.internet import ssl
        from OpenSSL import SSL

        create_self_signed_cert(hostname)
        tls_context_factory = ssl.DefaultOpenSSLContextFactory(
            KEY_FILE, CERT_FILE, SSL.TLSv1_2_METHOD
        )
        reactor.listenSSL(
            STUNS_PORT,
            TcpStunHandlerFactory(),
            tls_context_factory,
            interface=interface_4,
        )

        try:
            reactor.listenSSL(
                STUNS_PORT,
                TcpStunHandlerFactory(),
                tls_context_factory,
                interface=interface_6,
            )

            reactor.listenSSL(
                TURNS_REDIRECT_PORT,
                TcpStunRedirectHandlerFactory(),
                tls_context_factory,
                interface=interface_6,
            )
        except:
            pass

        f = open(CERT_FILE, "r")
        lines = f.readlines()
        lines.pop(0)  # Remove BEGIN CERTIFICATE
        lines.pop()  # Remove END CERTIFICATE
        # pylint --py3k: W1636 W1649
        lines = list(map(str.strip, lines))
        certbase64 = "".join(lines)  # pylint --py3k: W1649

        turns_url = ', "turns:' + hostname + '"'
        cert_prop = ', "cert":"' + certbase64 + '"'
    except:
        turns_url = ""
        cert_prop = ""
        pass

    allocation_pruner = LoopingCall(prune_allocations)
    allocation_pruner.start(1)

    template = Template(
        '[\
{"urls":["stun:$hostname", "stun:$hostname?transport=tcp"]}, \
{"username":"$user","credential":"$pwd","turn_redirect_port":"$TURN_REDIRECT_PORT","turns_redirect_port":"$TURNS_REDIRECT_PORT","urls": \
["turn:$hostname", "turn:$hostname?transport=tcp" $turns_url] \
$cert_prop}]'  # Hack to make it easier to override cert checks
    )

    print(
        template.substitute(
            user=turn_user,
            pwd=turn_pass,
            hostname=hostname,
            turns_url=turns_url,
            cert_prop=cert_prop,
            TURN_REDIRECT_PORT=TURN_REDIRECT_PORT,
            TURNS_REDIRECT_PORT=TURNS_REDIRECT_PORT,
        )
    )

    reactor.run()