def getHost(self): """ Returns a UNIXAddress. This indicates the server's address. """ return address.UNIXAddress(self.socket.getsockname())
def _fromConnectedSocket(cls, fileDescriptor, factory, reactor): """ Create a new L{Server} based on an existing connected I{SOCK_STREAM} socket. Arguments are the same as to L{Server.__init__}, except where noted. @param fileDescriptor: An integer file descriptor associated with a connected socket. The socket must be in non-blocking mode. Any additional attributes desired, such as I{FD_CLOEXEC}, must also be set already. @return: A new instance of C{cls} wrapping the socket given by C{fileDescriptor}. """ skt = socket.fromfd(fileDescriptor, socket.AF_UNIX, socket.SOCK_STREAM) protocolAddr = address.UNIXAddress(skt.getsockname()) proto = factory.buildProtocol(protocolAddr) if proto is None: skt.close() return # FIXME: is this a suitable sessionno? sessionno = 0 self = cls(skt, proto, skt.getpeername(), None, sessionno, reactor) self.repstr = "<%s #%s on %s>" % (self.protocol.__class__.__name__, self.sessionno, skt.getsockname()) self.logstr = "%s,%s,%s" % (self.protocol.__class__.__name__, self.sessionno, skt.getsockname()) proto.makeConnection(self) return self
def setCopyableState(self, state): """ Initialize this L{twisted.web.distrib.Request} based on the copied state so that it closely resembles a L{twisted.web.server.Request}. """ for k in "host", "client": tup = state[k] addrdesc = {"INET": "TCP", "UNIX": "UNIX"}[tup[0]] addr = { "TCP": lambda: address.IPv4Address(addrdesc, tup[1], tup[2]), "UNIX": lambda: address.UNIXAddress(tup[1]), }[addrdesc]() state[k] = addr state["requestHeaders"] = Headers(dict(state["requestHeaders"])) pb.RemoteCopy.setCopyableState(self, state) # Emulate the local request interface -- self.content = BytesIO(self.content_data) self.finish = self.remote.remoteMethod("finish") self.setHeader = self.remote.remoteMethod("setHeader") self.addCookie = self.remote.remoteMethod("addCookie") self.setETag = self.remote.remoteMethod("setETag") self.setResponseCode = self.remote.remoteMethod("setResponseCode") self.setLastModified = self.remote.remoteMethod("setLastModified") # To avoid failing if a resource tries to write a very long string # all at once, this one will be handled slightly differently. self._write = self.remote.remoteMethod("write")
def setCopyableState(self, state): """ Initialize this L{twisted.web.distrib.Request} based on the copied state so that it closely resembles a L{twisted.web.server.Request}. """ for k in 'host', 'client': tup = state[k] addrdesc = {'INET': 'TCP', 'UNIX': 'UNIX'}[tup[0]] addr = {'TCP': lambda: address.IPv4Address(addrdesc, tup[1], tup[2], _bwHack='INET'), 'UNIX': lambda: address.UNIXAddress(tup[1])}[addrdesc]() state[k] = addr state['requestHeaders'] = Headers(dict(state['requestHeaders'])) pb.RemoteCopy.setCopyableState(self, state) # Emulate the local request interface -- self.content = cStringIO.StringIO(self.content_data) self.finish = self.remote.remoteMethod('finish') self.setHeader = self.remote.remoteMethod('setHeader') self.addCookie = self.remote.remoteMethod('addCookie') self.setETag = self.remote.remoteMethod('setETag') self.setResponseCode = self.remote.remoteMethod('setResponseCode') self.setLastModified = self.remote.remoteMethod('setLastModified') # To avoid failing if a resource tries to write a very long string # all at once, this one will be handled slightly differently. self._write = self.remote.remoteMethod('write')
def allConnected(args): serverProtocol, clientProtocol = args # Incidental assertion which may or may not be redundant with some # other test. This probably deserves its own test method. self.assertEqual(clientFactory.peerAddresses, [address.UNIXAddress(filename)]) clientProtocol.transport.loseConnection() serverProtocol.transport.loseConnection()
def __init__(self, filename, connector, reactor=None, checkPID=0): _SendmsgMixin.__init__(self) # Normalise the filename using UNIXAddress filename = address.UNIXAddress(filename).name self.connector = connector self.realAddress = self.addr = filename if checkPID and not lockfile.isLocked(filename + b".lock"): self._finishInit(None, None, error.BadFileError(filename), reactor) self._finishInit(self.doConnect, self.createInternetSocket(), None, reactor)
def _portStuff((serverProtocol, clientProto)): # Incidental assertion which may or may not be redundant with some # other test. This probably deserves its own test method. self.assertEqual(clientFactory.peerAddresses, [address.UNIXAddress(filename)]) clientProto.transport.loseConnection() serverProtocol.transport.loseConnection() return unixPort.stopListening()
def buildProtocol(self, addr): # os.path.samefile fails on ('', '') if self.peername or addr.name: self.testcase.assertEquals(address.UNIXAddress(self.peername), addr, '%r != %r' % (self.peername, addr.name)) else: self.testcase.assertEquals(self.peername, addr.name) self.protocol = p = MyProtocol() self.protocol.deferred = self.deferred return p
def test_describe(self): f = transit.InboundConnectionFactory(None) addrH = address.HostnameAddress("example.com", 1234) self.assertEqual(f._describePeer(addrH), "<-example.com:1234") addr4 = address.IPv4Address("TCP", "1.2.3.4", 1234) self.assertEqual(f._describePeer(addr4), "<-1.2.3.4:1234") addr6 = address.IPv6Address("TCP", "::1", 1234) self.assertEqual(f._describePeer(addr6), "<-::1:1234") addrU = address.UNIXAddress("/dev/unlikely") self.assertEqual(f._describePeer(addrU), "<-UNIXAddress('/dev/unlikely')")
def getHost(self): """Returns a UNIXAddress. This indicates the server's address. """ if sys.version_info > (2, 5) or _inFilesystemNamespace(self.port): path = self.socket.getsockname() else: # Abstract namespace sockets aren't well supported on Python 2.4. # getsockname() always returns ''. path = self.port return address.UNIXAddress(path)
def setCopyableState(self, state): for k in 'host', 'client': tup = state[k] addrdesc = {'INET': 'TCP', 'UNIX': 'UNIX'}[tup[0]] addr = {'TCP': lambda: address.IPv4Address(addrdesc, tup[1], tup[2], _bwHack='INET'), 'UNIX': lambda: address.UNIXAddress(tup[1])}[addrdesc]() state[k] = addr pb.RemoteCopy.setCopyableState(self, state) # Emulate the local request interface -- self.content = cStringIO.StringIO(self.content_data) self.write = self.remote.remoteMethod('write') self.finish = self.remote.remoteMethod('finish') self.setHeader = self.remote.remoteMethod('setHeader') self.addCookie = self.remote.remoteMethod('addCookie') self.setETag = self.remote.remoteMethod('setETag') self.setResponseCode = self.remote.remoteMethod('setResponseCode') self.setLastModified = self.remote.remoteMethod('setLastModified')
def test_validUNIXHeaderResolves_getPeerHost(self): """ Test if UNIX headers result in the correct host and peer data. """ factory = HAProxyWrappingFactory(Factory.forProtocol(StaticProtocol)) proto = factory.buildProtocol( address.UNIXAddress(b'/home/test/sockets/server.sock'), ) transport = StringTransportWithDisconnection() proto.makeConnection(transport) proto.dataReceived(self.UNIXHEADER) self.assertEqual(proto.getPeer().name, b'/home/tests/mysockets/sock') self.assertEqual( proto.wrappedProtocol.transport.getPeer().name, b'/home/tests/mysockets/sock', ) self.assertEqual(proto.getHost().name, b'/home/tests/mysockets/sock') self.assertEqual( proto.wrappedProtocol.transport.getHost().name, b'/home/tests/mysockets/sock', )
def buildProtocol(self, addr): self.testcase.assertEquals(address.UNIXAddress(self.name), addr) self.protocol = MyProtocol() self.protocol.deferred = self.deferred return self.protocol
def cbConnMade(proto): expected = address.UNIXAddress(peername) self.assertEqual(serverFactory.peerAddresses, [expected]) self.assertEqual(proto.transport.getPeer(), expected)
def _buildAddr(self, name): return address.UNIXAddress(name)
def getPeer(self): return address.UNIXAddress(self.hostname)
def getPeer(self): return address.UNIXAddress(self.remoteaddr)
def getHost(self): return address.UNIXAddress(self.socket.getsockname())
def getDestination(self): return address.UNIXAddress(self.address)
def getHost(self): return address.UNIXAddress(None)
def parse(cls, line): """ Parse a bytestring as a full PROXY protocol header. @param line: A bytestring that represents a valid HAProxy PROXY protocol version 2 header. @type line: bytes @return: A L{_interfaces.IProxyInfo} containing the parsed data. @raises InvalidProxyHeader: If the bytestring does not represent a valid PROXY header. """ prefix = line[:12] addrInfo = None with convertError(IndexError, InvalidProxyHeader): # Use single value slices to ensure bytestring values are returned # instead of int in PY3. versionCommand = ord(line[12:13]) familyProto = ord(line[13:14]) if prefix != cls.PREFIX: raise InvalidProxyHeader() version, command = versionCommand & _HIGH, versionCommand & _LOW if version not in cls.VERSIONS or command not in cls.COMMANDS: raise InvalidProxyHeader() if cls.COMMANDS[command] == _LOCALCOMMAND: return _info.ProxyInfo(line, None, None) family, netproto = familyProto & _HIGH, familyProto & _LOW with convertError(ValueError, InvalidNetworkProtocol): family = NetFamily.lookupByValue(family) netproto = NetProtocol.lookupByValue(netproto) if ( family is NetFamily.UNSPEC or netproto is NetProtocol.UNSPEC ): return _info.ProxyInfo(line, None, None) addressFormat = cls.ADDRESSFORMATS[familyProto] addrInfo = line[16:16+struct.calcsize(addressFormat)] if family is NetFamily.UNIX: with convertError(struct.error, MissingAddressData): source, dest = struct.unpack(addressFormat, addrInfo) return _info.ProxyInfo( line, address.UNIXAddress(source.rstrip(b'\x00')), address.UNIXAddress(dest.rstrip(b'\x00')), ) addrType = 'TCP' if netproto is NetProtocol.DGRAM: addrType = 'UDP' addrCls = address.IPv4Address addrParser = cls._bytesToIPv4 if family is NetFamily.INET6: addrCls = address.IPv6Address addrParser = cls._bytesToIPv6 with convertError(struct.error, MissingAddressData): info = struct.unpack(addressFormat, addrInfo) source, dest, sPort, dPort = info return _info.ProxyInfo( line, addrCls(addrType, addrParser(source), sPort), addrCls(addrType, addrParser(dest), dPort), )
def test_remote_ip_unix(self): self.con.transport = Mock() self.con.transport.getHost.return_value.name = "rawr" self.con.transport.getPeer.return_value = address.UNIXAddress("rawr") ip = self.con._remote_ip self.assertTrue(ip)