def resolveHostName(self, resolutionReceiver, hostName, *args, **kwargs): portNumber = kwargs.pop('portNumber') r = Resolution(name=hostName) resolutionReceiver.resolutionBegan(r) if hostName in HOST_MAP: resolutionReceiver.addressResolved( IPv4Address('TCP', HOST_MAP[hostName], portNumber)) resolutionReceiver.resolutionComplete() return r
def test_request_state(self): url = "https://www.globaleaks.org/" request = forge_request(url) self.api.render(request) self.assertFalse(request.client_using_tor) self.assertEqual(request.responseCode, 200) request = forge_request(url, client_addr=IPv4Address( 'TCP', '127.0.0.1', 12345)) self.api.render(request) self.assertFalse(request.client_using_tor) self.assertEqual(request.responseCode, 200) request = forge_request(uri='http://127.0.0.1:8083/', client_addr=IPv4Address( 'TCP', '127.0.0.1', 12345)) self.api.render(request) self.assertTrue(request.client_using_tor) self.assertEqual(request.responseCode, 200)
class MiniUDP(DatagramProtocol): def datagramReceived(self, data, (host, port)): try: self.buffer += data print "Recieved data: ", repr(data) logdata = {'DATA': self.buffer.strip("\r\n\x00")} self.transport.getPeer = lambda: IPv4Address('UDP', host, port) self.factory.log(logdata=logdata, transport=self.transport) except Exception as e: print e pass
def _create_connection(self, addr, port): addr = IPv4Address('TCP', addr, port) sender = self._factory.buildProtocol(addr) client_proxy = portforward.ProxyClient() sender.makeConnection(self.transport) # portforward.ProxyClient is going to call setPeer but this # probably doesn't have it... setattr(sender, 'setPeer', lambda _: None) client_proxy.setPeer(sender) self._sender = sender return sender
def makeRequest(self, method=b"GET", clientAddress=None): """ Create a L{DummyRequest} (change me to create a L{twisted.web.http.Request} instead). """ if clientAddress is None: clientAddress = IPv4Address("TCP", "localhost", 1234) request = DummyRequest(b"/") request.method = method request.client = clientAddress return request
def setUp(self): ''' Set up a conencted state ''' self.transport = proto_helpers.StringTransportWithDisconnection() self.clock = task.Clock() MQTTBaseProtocol.callLater = self.clock.callLater self.factory = MQTTFactory(MQTTFactory.SUBSCRIBER) self.addr = IPv4Address('TCP', 'localhost', 1880) self._rebuild() self._connect()
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)
def test_login_reject_on_ip_filtering(self): State.tenant_cache[1]['ip_filter_authenticated_enable'] = True State.tenant_cache[1]['ip_filter_authenticated'] = '192.168.2.0/24' handler = self.request({ 'tid': 1, 'username': '******', 'password': helpers.VALID_PASSWORD1, 'token': '' }, client_addr=IPv4Address('TCP', '192.168.1.1', 12345)) yield self.assertFailure(handler.post(), errors.AccessLocationInvalid)
def setUp(self): self.factory = WebSocketClientFactory(protocols=['wamp.2.json']) self.factory.protocol = WebSocketClientProtocol self.factory.doStart() self.proto = self.factory.buildProtocol( IPv4Address('TCP', '127.0.0.1', 65534)) # self.transport = FakeTransport() self.transport = MagicMock() self.proto.transport = self.transport self.proto.connectionMade()
def test_login_success_on_ip_filtering(self): State.tenant_cache[1]['ip_filter']['admin'] = '192.168.2.0/24' handler = self.request({ 'tid': 1, 'username': '******', 'password': helpers.VALID_PASSWORD1, 'authcode': '' }, client_addr=IPv4Address('TCP', '192.168.2.1', 12345)) response = yield handler.post() self.assertTrue('session_id' in response) self.assertEqual(len(Sessions), 1)
def test_bwHackDeprecation(self): """ If a value is passed for the C{_bwHack} parameter to L{IPv4Address}, a deprecation warning is emitted. """ # Construct this for warning side-effects, disregard the actual object. IPv4Address("UDP", "127.0.0.3", 0, _bwHack="UDP") message = ( "twisted.internet.address.IPv4Address._bwHack is deprecated " "since Twisted 11.0") return self.assertDeprecations(self.test_bwHackDeprecation, message)
def test_getHost(self): """ L{IListeningPort.getHost} returns an L{IPv4Address} giving a dotted-quad of the IPv4 address the port is listening on as well as the port number. """ host, portNumber = findFreePort(type=SOCK_DGRAM) reactor = self.buildReactor() port = reactor.listenUDP(portNumber, DatagramProtocol(), interface=host) self.assertEqual(port.getHost(), IPv4Address('UDP', host, portNumber))
def test_log_message(self): # Should be possible to customize the message which is logged. TEST_STRING = "test-1234" factory = WhitelistingFactory( TestFactory(), [ip_network('127.0.0.1/32')], TEST_STRING ) self.assertEqual( factory.buildProtocol(IPv4Address('TCP', '127.0.0.2', 0)), None ) self.assertFalse("connection" in self.observer.messages[0][0]) self.assertTrue(TEST_STRING in self.observer.messages[0][0])
def from_db_tuple(cls, db: Tuple) -> "Member": """Instantiate a Member from a tuple created by Member.to_db_tuple()""" member = Member(db[0], None) member.signing_key = db[1] if db[1] is not None else None member.head = db[2] member.stake = db[3] if db[4] is not None and db[5] is not None: member.address = IPv4Address('TCP', db[4], db[5]) member.name = db[6] return member
def test_build(self): c = mock.Mock() alsoProvides(c, IDilationConnector) p0 = mock.Mock() c.build_protocol = mock.Mock(return_value=p0) f = InboundConnectionFactory(c) addr = IPv4Address("TCP", "1.2.3.4", 55) p = f.buildProtocol(addr) self.assertIdentical(p, p0) self.assertEqual(c.mock_calls, [mock.call.build_protocol(addr, "<-tcp:1.2.3.4:55")]) self.assertIdentical(p.factory, f)
def test_connect(self): reactor = MemoryReactorClock() reactor.running = True c = KafkaBrokerClient(reactor, 'kafka.example.com', 9092, 'clientId') c._connect() # Force a connection attempt c.connector.factory = c # MemoryReactor doesn't make this connection. # Build the protocol, like a real connector would addr = IPv4Address('TCP', '1.2.3.4', 9092) c.buildProtocol(addr) self.assertEqual(("<KafkaBrokerClient kafka.example.com:9092 " "clientId='clientId' connected>"), repr(c))
def connectSSL(self, host, port, factory, contextFactory, timeout=30, bindAddress=None): """ Fake L{IReactorSSL.connectSSL}, that logs the call and returns an L{IConnector}. """ self.sslClients.append((host, port, factory, contextFactory, timeout, bindAddress)) conn = _FakeConnector(IPv4Address('TCP', host, port)) factory.startedConnecting(conn) self.connectors.append(conn) return conn
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
def datagramReceived(self, data, host_and_port): try: snmp = SNMP(data) community = snmp.community.val requests = [x.oid.val for x in snmp.PDU.varbindlist] logdata = {'REQUESTS': requests, 'COMMUNITY_STRING': community} self.transport.getPeer = lambda: IPv4Address( 'UDP', host_and_port[0], host_and_port[1]) self.factory.log(logdata=logdata, transport=self.transport) except Exception as e: print(e) pass
def reset(self): """Delete the hashgraph and create a new one.""" DB.reset() new_me = Member.create() new_me.address = IPv4Address("TCP", bptc.ip, bptc.port) new_hashgraph = Hashgraph(new_me) self.hashgraph = new_hashgraph self.hashgraph.add_own_event( Event(self.hashgraph.me.verify_key, None, Parents(None, None)), True) self.last_push_sent = None self.last_push_received = None
def test_login_localhost_on_ip_filtering(self): State.tenant_cache[1]['ip_filter_authenticated_enable'] = True State.tenant_cache[1]['ip_filter_authenticated'] = '192.168.2.0/24' handler = self.request({ 'tid': 1, 'username': '******', 'password': helpers.VALID_PASSWORD1, 'token': '' }, client_addr=IPv4Address('TCP', '127.0.0.1', 12345)) response = yield handler.post() self.assertTrue('session_id' in response) self.assertEqual(len(Sessions), 1)
def test_build_protocol_custom_parameters(self): """Test building AMQClient instances with custom parameters.""" address = IPv4Address("TCP", "127.0.0.1", 5672) spec = "../specs/rabbitmq/amqp0-8.stripped.rabbitmq.xml" clock = Clock() factory = AMQFactory(spec=spec, clock=clock) factory.set_vhost("foo") factory.set_heartbeat(1) client = factory.buildProtocol(address) self.assertEqual("foo", client.vhost) self.assertEqual(spec, client.spec.file) self.assertEqual(1, client.heartbeatInterval) self.assertEqual(1, len(clock.getDelayedCalls()))
def listenSSL(self, port, factory, contextFactory, backlog=50, interface=''): """ Fake L{IReactorSSL.listenSSL}, that logs the call and returns an L{IListeningPort}. """ self.sslServers.append( (port, factory, contextFactory, backlog, interface)) return _FakePort(IPv4Address('TCP', '0.0.0.0', port))
def adoptStreamPort(self, fileno, addressFamily, factory): """ Fake L{IReactorSocket.adoptStreamPort}, that logs the call and returns an L{IListeningPort}. """ if addressFamily == AF_INET: addr = IPv4Address('TCP', '0.0.0.0', 1234) elif addressFamily == AF_INET6: addr = IPv6Address('TCP', '::', 1234) else: raise UnsupportedAddressFamily() self.adoptedPorts.append((fileno, addressFamily, factory)) return _FakePort(addr)
def handleQuery(self, message, protocol, address): if protocol.transport.socket.type == socket.SOCK_STREAM: self.peer_address = protocol.transport.getPeer() elif protocol.transport.socket.type == socket.SOCK_DGRAM: self.peer_address = IPv4Address('UDP', *address) else: print "Unexpected socket type %r" % protocol.transport.socket.type for resolver in self.resolver.resolvers: if hasattr(resolver, 'peer_address'): resolver.peer_address = self.peer_address return server.DNSServerFactory.handleQuery(self, message protocol, address)
def setUp(self): if False: # debug leftover reactor events import twisted.internet.base twisted.internet.base.DelayedCall.debug = True self.factory = WebSocketServerFactory(protocols=['wamp.2.json']) self.factory.protocol = WebSocketServerProtocol self.factory.doStart() self.proto = self.factory.buildProtocol(IPv4Address('TCP', '127.0.0.1', 65534)) self.transport = MagicMock() self.proto.transport = self.transport self.proto.connectionMade()
def connectSSL(self, host, port, factory, contextFactory, timeout=30, bindAddress=None): """ Fake L{reactor.connectSSL}, that logs the call and returns an L{IConnector}. """ self.sslClients.append( (host, port, factory, contextFactory, timeout, bindAddress)) return _FakeConnector(IPv4Address('TCP', host, port))
def test_whois_protocol_no_access_list(self, config_override, mock_pipeline_reactor): config_override({ 'sources': { 'TEST1': {} }, }) mock_transport = Mock() mock_transport.getPeer = lambda: IPv4Address('TCP', '127.0.0.1', 99999) mock_factory = Mock() mock_factory.current_connections = 10 receiver = WhoisQueryReceiver() receiver.transport = mock_transport receiver.factory = mock_factory receiver.connectionMade() assert receiver.peer_str == '[127.0.0.1]:99999' assert receiver.query_pipeline_thread.started assert receiver.timeOut == receiver.query_parser.timeout mock_transport.reset_mock() receiver.lineReceived(b' ') receiver.lineReceived(b' !v ') assert receiver.query_pipeline_thread.pipeline.get(block=False) == b' ' assert receiver.query_pipeline_thread.pipeline.get( block=False) == b' !v ' receiver.query_parser.timeout = 5 receiver.query_pipeline_thread.response_callback(b'response') assert mock_transport.mock_calls[0][0] == 'write' assert mock_transport.mock_calls[0][1][0] == b'response' assert mock_transport.mock_calls[1][0] == 'loseConnection' assert len(mock_transport.mock_calls) == 2 assert receiver.timeOut == receiver.query_parser.timeout mock_transport.reset_mock() receiver.query_pipeline_thread.lose_connection_callback() assert mock_transport.mock_calls[0][0] == 'loseConnection' assert len(mock_transport.mock_calls) == 1 mock_transport.reset_mock() receiver.query_parser.multiple_command_mode = True receiver.query_pipeline_thread.response_callback(b'response') assert mock_transport.mock_calls[0][0] == 'write' assert len(mock_transport.mock_calls) == 1 receiver.connectionLost() assert mock_factory.current_connections == 9
def testBuildProtocol(self): portno = self.getFreePort() f = AServerFactory(self, IPv4Address('TCP', '127.0.0.1', portno)) p = reactor.listenTCP(0, f) self.ports.append(p) spinUntil(lambda: p.connected) acf = AClientFactory(self, IPv4Address("TCP", "127.0.0.1", p.getHost().port)) reactor.connectTCP("127.0.0.1", p.getHost().port, acf, bindAddress=("127.0.0.1", portno)) spinUntil(lambda: acf.protocol is not None) self.ports.append(acf.protocol.transport) self.assert_(hasattr(self, "ran")) spinUntil(lambda: acf.protocol.lostCnx) del self.ran
def test_addresses(self): """ A client's transport's C{getHost} and C{getPeer} return L{IPv4Address} instances which give the dotted-quad string form of the local and remote endpoints of the connection respectively. """ host, port = findFreePort() reactor = self.buildReactor() server = reactor.listenTCP(0, serverFactoryFor(Protocol), interface=host) serverAddress = server.getHost() addresses = {'host': None, 'peer': None} class CheckAddress(Protocol): def makeConnection(self, transport): addresses['host'] = transport.getHost() addresses['peer'] = transport.getPeer() reactor.stop() clientFactory = Stop(reactor) clientFactory.protocol = CheckAddress reactor.connectTCP('localhost', server.getHost().port, clientFactory, bindAddress=('127.0.0.1', port)) reactor.installResolver(FakeResolver({'localhost': '127.0.0.1'})) self.runReactor(reactor) self.assertEqual(addresses['host'], IPv4Address('TCP', '127.0.0.1', port)) self.assertEqual(addresses['peer'], IPv4Address('TCP', '127.0.0.1', serverAddress.port))