twisted.internet.abstract.isIPv6Address

Here are the examples of the python api twisted.internet.abstract.isIPv6Address taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

16 Examples 7

Example 1

Project: twunnel Source File: proxy_server__https.py
Function: connection_made
    def connectionMade(self):
        twunnel.logger.log(3, "trace: HTTPSTunnelOutputProtocol.connectionMade")
        
        request = "CONNECT "
        
        if isIPv6Address(self.factory.address) == True:
            request = request + "[" + str(self.factory.address) + "]:" + str(self.factory.port)
        else:
            request = request + str(self.factory.address) + ":" + str(self.factory.port)
        
        request = request + " HTTP/1.1\r\n"
        
        if self.factory.configuration["PROXY_SERVER"]["ACCOUNT"]["NAME"] != "":
            request = request + "Proxy-Authorization: Basic " + base64.standard_b64encode(self.factory.configuration["PROXY_SERVER"]["ACCOUNT"]["NAME"] + ":" + self.factory.configuration["PROXY_SERVER"]["ACCOUNT"]["PASSWORD"]) + "\r\n"
        
        request = request + "\r\n"
        
        self.transport.write(request)

Example 2

Project: TwistedBot Source File: tcp.py
    def __init__(self, port, factory, backlog=50, interface='', reactor=None):
        """Initialize with a numeric port to listen on.
        """
        base.BasePort.__init__(self, reactor=reactor)
        self.port = port
        self.factory = factory
        self.backlog = backlog
        if abstract.isIPv6Address(interface):
            self.addressFamily = socket.AF_INET6
            self._addressType = address.IPv6Address
        self.interface = interface

Example 3

Project: TwistedBot Source File: tcp.py
    def __init__(self, host, port, factory, timeout, bindAddress, reactor=None):
        if isinstance(port, _portNameType):
            try:
                port = socket.getservbyname(port, 'tcp')
            except socket.error as e:
                raise error.ServiceNameUnknownError(string="%s (%r)" % (e, port))
        self.host, self.port = host, port
        if abstract.isIPv6Address(host):
            self._addressType = address.IPv6Address
        self.bindAddress = bindAddress
        base.BaseConnector.__init__(self, factory, timeout, reactor)

Example 4

Project: TwistedBot Source File: _endpointspy3.py
Function: connect
    def connect(self, protocolFactory):
        """
        Implement L{IStreamClientEndpoint.connect} to connect via TCP,
        once the hostname resolution is done.
        """
        if isIPv6Address(self._host):
            d = self._resolvedHostConnect(self._host, protocolFactory)
        else:
            d = self._nameResolution(self._host)
            d.addCallback(lambda result: result[0][self._GAI_ADDRESS]
                          [self._GAI_ADDRESS_HOST])
            d.addCallback(self._resolvedHostConnect, protocolFactory)
        return d

Example 5

Project: SubliminalCollaborator Source File: tcp.py
    def __init__(self, port, factory, backlog=50, interface='', reactor=None):
        self.port = port
        self.factory = factory
        self.backlog = backlog
        self.interface = interface
        self.reactor = reactor
        if isIPv6Address(interface):
            self.addressFamily = socket.AF_INET6
            self._addressType = address.IPv6Address

Example 6

Project: SubliminalCollaborator Source File: tcp.py
    def __init__(self, host, port, factory, timeout, bindAddress, reactor=None):
        if isinstance(port, types.StringTypes):
            try:
                port = socket.getservbyname(port, 'tcp')
            except socket.error, e:
                raise error.ServiceNameUnknownError(string="%s (%r)" % (e, port))
        self.host, self.port = host, port
        if abstract.isIPv6Address(host):
            self._addressType = address.IPv6Address
        self.bindAddress = bindAddress
        base.BaseConnector.__init__(self, factory, timeout, reactor)

Example 7

Project: SubliminalCollaborator Source File: test_abstract.py
    def test_scopeID(self):
        """
        An otherwise valid IPv6 address literal may also include a C{"%"}
        followed by an arbitrary scope identifier.
        """
        self.assertTrue(isIPv6Address("fe80::1%eth0"))
        self.assertTrue(isIPv6Address("fe80::2%1"))
        self.assertTrue(isIPv6Address("fe80::3%en2"))

Example 8

Project: SubliminalCollaborator Source File: test_abstract.py
    def test_invalidWithScopeID(self):
        """
        An otherwise invalid IPv6 address literal is still invalid with a
        trailing scope identifier.
        """
        self.assertFalse(isIPv6Address("%eth0"))
        self.assertFalse(isIPv6Address(":%eth0"))
        self.assertFalse(isIPv6Address("hello%eth0"))

Example 9

Project: SubliminalCollaborator Source File: proto_helpers.py
    def listenTCP(self, port, factory, backlog=50, interface=''):
        """
        Fake L{reactor.listenTCP}, that logs the call and returns an
        L{IListeningPort}.
        """
        self.tcpServers.append((port, factory, backlog, interface))
        if isIPv6Address(interface):
            address = IPv6Address('TCP', interface, port)
        else:
            address = IPv4Address('TCP', '0.0.0.0', port)
        return _FakePort(address)

Example 10

Project: SubliminalCollaborator Source File: proto_helpers.py
    def connectTCP(self, host, port, factory, timeout=30, bindAddress=None):
        """
        Fake L{reactor.connectTCP}, that logs the call and returns an
        L{IConnector}.
        """
        self.tcpClients.append((host, port, factory, timeout, bindAddress))
        if isIPv6Address(host):
            conn = _FakeConnector(IPv6Address('TCP', host, port))
        else:
            conn = _FakeConnector(IPv4Address('TCP', host, port))
        factory.startedConnecting(conn)
        return conn

Example 11

Project: txircd Source File: cloaking.py
    def applyCloak(self, ip):
        if isIPv6Address(ip):
            return self.applyCloak6(ip)
        else:
            return self.applyCloak4(ip)

Example 12

Project: twunnel Source File: proxy_server__socks5.py
Function: process_data_state2
    def processDataState2(self):
        twunnel.logger.log(3, "trace: SOCKS5TunnelOutputProtocol.processDataState2")
        
        addressType = 0x03
        if isIPAddress(self.factory.address) == True:
            addressType = 0x01
        else:
            if isIPv6Address(self.factory.address) == True:
                addressType = 0x04
        
        request = struct.pack("!BBB", 0x05, 0x01, 0x00)
        
        if addressType == 0x01:
            address = self.factory.address
            address = socket.inet_pton(socket.AF_INET, address)
            address, = struct.unpack("!I", address)
            
            request = request + struct.pack("!BI", 0x01, address)
        else:
            if addressType == 0x03:
                address = self.factory.address
                addressLength = len(address)
                
                request = request + struct.pack("!BB%ds" % addressLength, 0x03, addressLength, address)
            else:
                if addressType == 0x04:
                    address = self.factory.address
                    address = socket.inet_pton(socket.AF_INET6, address)
                    address1, address2, address3, address4 = struct.unpack("!IIII", address)
                    
                    request = request + struct.pack("!BIIII", 0x04, address1, address2, address3, address4)
        
        port = self.factory.port
        
        request = request + struct.pack("!H", port)
        
        self.transport.write(request)
        
        self.dataState = 3
        
        return True

Example 13

Project: ccs-calendarserver Source File: localservers.py
    def check(self, ignoreIPLookupFailures=False):
        # Check whether this matches the current server
        parsed_uri = urlparse.urlparse(self.uri)
        if parsed_uri.hostname == config.ServerHostName:
            if parsed_uri.scheme == "http":
                if config.HTTPPort:
                    self.thisServer = parsed_uri.port in (config.HTTPPort,) + tuple(config.BindHTTPPorts)
            elif parsed_uri.scheme == "https":
                if config.SSLPort:
                    self.thisServer = parsed_uri.port in (config.SSLPort,) + tuple(config.BindSSLPorts)

        # Need to cache IP addresses
        try:
            ips = getIPsFromHost(parsed_uri.hostname)
        except socket.gaierror, e:
            msg = "Unable to lookup ip-addr for server '{}': {}".format(parsed_uri.hostname, str(e))
            log.error(msg)
            if ignoreIPLookupFailures:
                ips = ()
            else:
                raise ValueError(msg)
        self.ips = set(ips)

        actual_ips = set()
        for item in self.allowed_from_ips:
            if not isIPAddress(item) and not isIPv6Address(item):
                try:
                    ips = getIPsFromHost(item)
                except socket.gaierror, e:
                    msg = "Unable to lookup ip-addr for allowed-from '{}': {}".format(item, str(e))
                    log.error(msg)
                    if not ignoreIPLookupFailures:
                        raise ValueError(msg)
                else:
                    actual_ips.update(ips)
            else:
                actual_ips.add(item)
        self.allowed_from_ips = actual_ips

Example 14

Project: SubliminalCollaborator Source File: test_abstract.py
Function: test_empty
    def test_empty(self):
        """
        The empty string is not an IPv6 address literal.
        """
        self.assertFalse(isIPv6Address(""))

Example 15

Project: SubliminalCollaborator Source File: test_abstract.py
Function: test_colon
    def test_colon(self):
        """
        A single C{":"} is not an IPv6 address literal.
        """
        self.assertFalse(isIPv6Address(":"))

Example 16

Project: SubliminalCollaborator Source File: test_abstract.py
Function: test_loopback
    def test_loopback(self):
        """
        C{"::1"} is the IPv6 loopback address literal.
        """
        self.assertTrue(isIPv6Address("::1"))