# -*- test-case-name: twisted.conch.test.test_telnet -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Telnet protocol implementation. @author: Jean-Paul Calderone """ import struct from zope.interface import implementer from twisted.internet import defer, interfaces as iinternet, protocol from twisted.logger import Logger from twisted.python.compat import iterbytes def _chr(i: int) -> bytes: """Create a byte sequence of length 1. U{RFC 854} specifies codes in decimal, but Python can only handle L{bytes} literals in octal or hexadecimal. This helper function bridges that gap. @param i: The value of the only byte in the sequence. """ return bytes((i,)) MODE = _chr(1) EDIT = 1 TRAPSIG = 2 MODE_ACK = 4 SOFT_TAB = 8 LIT_ECHO = 16 # Characters gleaned from the various (and conflicting) RFCs. Not all of these # are correct. NULL = _chr(0) # No operation. BEL = _chr(7) # Produces an audible or visible signal (which does NOT move the # print head). BS = _chr(8) # Moves the print head one character position towards the left # margin. HT = _chr(9) # Moves the printer to the next horizontal tab stop. It remains # unspecified how either party determines or establishes where such tab stops # are located. LF = _chr(10) # Moves the printer to the next print line, keeping the same # horizontal position. VT = _chr(11) # Moves the printer to the next vertical tab stop. It remains # unspecified how either party determines or establishes where such tab stops # are located. FF = _chr(12) # Moves the printer to the top of the next page, keeping the same # horizontal position. CR = _chr(13) # Moves the printer to the left margin of the current line. ECHO = _chr(1) # User-to-Server: Asks the server to send Echos of the # transmitted data. SGA = _chr(3) # Suppress Go Ahead. Go Ahead is silly and most modern servers # should suppress it. NAWS = _chr(31) # Negotiate About Window Size. Indicate that information about # the size of the terminal can be communicated. LINEMODE = _chr(34) # Allow line buffering to be negotiated about. EOR = _chr(239) # End of Record (RFC 885) SE = _chr(240) # End of subnegotiation parameters. NOP = _chr(241) # No operation. DM = _chr(242) # "Data Mark": The data stream portion of a Synch. This should # always be accompanied by a TCP Urgent notification. BRK = _chr(243) # NVT character Break. IP = _chr(244) # The function Interrupt Process. AO = _chr(245) # The function Abort Output AYT = _chr(246) # The function Are You There. EC = _chr(247) # The function Erase Character. EL = _chr(248) # The function Erase Line GA = _chr(249) # The Go Ahead signal. SB = _chr(250) # Indicates that what follows is subnegotiation of the indicated # option. WILL = _chr(251) # Indicates the desire to begin performing, or confirmation # that you are now performing, the indicated option. WONT = _chr(252) # Indicates the refusal to perform, or continue performing, # the indicated option. DO = _chr(253) # Indicates the request that the other party perform, or # confirmation that you are expecting the other party to perform, the indicated # option. DONT = _chr(254) # Indicates the demand that the other party stop performing, # or confirmation that you are no longer expecting the other party to perform, # the indicated option. IAC = _chr(255) # Data Byte 255. Introduces a telnet command. LINEMODE_MODE = _chr(1) LINEMODE_EDIT = _chr(1) LINEMODE_TRAPSIG = _chr(2) LINEMODE_MODE_ACK = _chr(4) LINEMODE_SOFT_TAB = _chr(8) LINEMODE_LIT_ECHO = _chr(16) LINEMODE_FORWARDMASK = _chr(2) LINEMODE_SLC = _chr(3) LINEMODE_SLC_SYNCH = _chr(1) LINEMODE_SLC_BRK = _chr(2) LINEMODE_SLC_IP = _chr(3) LINEMODE_SLC_AO = _chr(4) LINEMODE_SLC_AYT = _chr(5) LINEMODE_SLC_EOR = _chr(6) LINEMODE_SLC_ABORT = _chr(7) LINEMODE_SLC_EOF = _chr(8) LINEMODE_SLC_SUSP = _chr(9) LINEMODE_SLC_EC = _chr(10) LINEMODE_SLC_EL = _chr(11) LINEMODE_SLC_EW = _chr(12) LINEMODE_SLC_RP = _chr(13) LINEMODE_SLC_LNEXT = _chr(14) LINEMODE_SLC_XON = _chr(15) LINEMODE_SLC_XOFF = _chr(16) LINEMODE_SLC_FORW1 = _chr(17) LINEMODE_SLC_FORW2 = _chr(18) LINEMODE_SLC_MCL = _chr(19) LINEMODE_SLC_MCR = _chr(20) LINEMODE_SLC_MCWL = _chr(21) LINEMODE_SLC_MCWR = _chr(22) LINEMODE_SLC_MCBOL = _chr(23) LINEMODE_SLC_MCEOL = _chr(24) LINEMODE_SLC_INSRT = _chr(25) LINEMODE_SLC_OVER = _chr(26) LINEMODE_SLC_ECR = _chr(27) LINEMODE_SLC_EWR = _chr(28) LINEMODE_SLC_EBOL = _chr(29) LINEMODE_SLC_EEOL = _chr(30) LINEMODE_SLC_DEFAULT = _chr(3) LINEMODE_SLC_VALUE = _chr(2) LINEMODE_SLC_CANTCHANGE = _chr(1) LINEMODE_SLC_NOSUPPORT = _chr(0) LINEMODE_SLC_LEVELBITS = _chr(3) LINEMODE_SLC_ACK = _chr(128) LINEMODE_SLC_FLUSHIN = _chr(64) LINEMODE_SLC_FLUSHOUT = _chr(32) LINEMODE_EOF = _chr(236) LINEMODE_SUSP = _chr(237) LINEMODE_ABORT = _chr(238) class ITelnetProtocol(iinternet.IProtocol): def unhandledCommand(command, argument): """ A command was received but not understood. @param command: the command received. @type command: L{str}, a single character. @param argument: the argument to the received command. @type argument: L{str}, a single character, or None if the command that was unhandled does not provide an argument. """ def unhandledSubnegotiation(command, data): """ A subnegotiation command was received but not understood. @param command: the command being subnegotiated. That is, the first byte after the SB command. @type command: L{str}, a single character. @param data: all other bytes of the subneogation. That is, all but the first bytes between SB and SE, with IAC un-escaping applied. @type data: L{bytes}, each a single character """ def enableLocal(option): """ Enable the given option locally. This should enable the given option on this side of the telnet connection and return True. If False is returned, the option will be treated as still disabled and the peer will be notified. @param option: the option to be enabled. @type option: L{bytes}, a single character. """ def enableRemote(option): """ Indicate whether the peer should be allowed to enable this option. Returns True if the peer should be allowed to enable this option, False otherwise. @param option: the option to be enabled. @type option: L{bytes}, a single character. """ def disableLocal(option): """ Disable the given option locally. Unlike enableLocal, this method cannot fail. The option must be disabled. @param option: the option to be disabled. @type option: L{bytes}, a single character. """ def disableRemote(option): """ Indicate that the peer has disabled this option. @param option: the option to be disabled. @type option: L{bytes}, a single character. """ class ITelnetTransport(iinternet.ITransport): def do(option): """ Indicate a desire for the peer to begin performing the given option. Returns a Deferred that fires with True when the peer begins performing the option, or fails with L{OptionRefused} when the peer refuses to perform it. If the peer is already performing the given option, the Deferred will fail with L{AlreadyEnabled}. If a negotiation regarding this option is already in progress, the Deferred will fail with L{AlreadyNegotiating}. Note: It is currently possible that this Deferred will never fire, if the peer never responds, or if the peer believes the option to already be enabled. """ def dont(option): """ Indicate a desire for the peer to cease performing the given option. Returns a Deferred that fires with True when the peer ceases performing the option. If the peer is not performing the given option, the Deferred will fail with L{AlreadyDisabled}. If negotiation regarding this option is already in progress, the Deferred will fail with L{AlreadyNegotiating}. Note: It is currently possible that this Deferred will never fire, if the peer never responds, or if the peer believes the option to already be disabled. """ def will(option): """ Indicate our willingness to begin performing this option locally. Returns a Deferred that fires with True when the peer agrees to allow us to begin performing this option, or fails with L{OptionRefused} if the peer refuses to allow us to begin performing it. If the option is already enabled locally, the Deferred will fail with L{AlreadyEnabled}. If negotiation regarding this option is already in progress, the Deferred will fail with L{AlreadyNegotiating}. Note: It is currently possible that this Deferred will never fire, if the peer never responds, or if the peer believes the option to already be enabled. """ def wont(option): """ Indicate that we will stop performing the given option. Returns a Deferred that fires with True when the peer acknowledges we have stopped performing this option. If the option is already disabled locally, the Deferred will fail with L{AlreadyDisabled}. If negotiation regarding this option is already in progress, the Deferred will fail with L{AlreadyNegotiating}. Note: It is currently possible that this Deferred will never fire, if the peer never responds, or if the peer believes the option to already be disabled. """ def requestNegotiation(about, data): """ Send a subnegotiation request. @param about: A byte indicating the feature being negotiated. @param data: Any number of L{bytes} containing specific information about the negotiation being requested. No values in this string need to be escaped, as this function will escape any value which requires it. """ class TelnetError(Exception): pass class NegotiationError(TelnetError): def __str__(self) -> str: return ( self.__class__.__module__ + "." + self.__class__.__name__ + ":" + repr(self.args[0]) ) class OptionRefused(NegotiationError): pass class AlreadyEnabled(NegotiationError): pass class AlreadyDisabled(NegotiationError): pass class AlreadyNegotiating(NegotiationError): pass @implementer(ITelnetProtocol) class TelnetProtocol(protocol.Protocol): _log = Logger() def unhandledCommand(self, command, argument): pass def unhandledSubnegotiation(self, command, data): pass def enableLocal(self, option): pass def enableRemote(self, option): pass def disableLocal(self, option): pass def disableRemote(self, option): pass class Telnet(protocol.Protocol): """ @ivar commandMap: A mapping of bytes to callables. When a telnet command is received, the command byte (the first byte after IAC) is looked up in this dictionary. If a callable is found, it is invoked with the argument of the command, or None if the command takes no argument. Values should be added to this dictionary if commands wish to be handled. By default, only WILL, WONT, DO, and DONT are handled. These should not be overridden, as this class handles them correctly and provides an API for interacting with them. @ivar negotiationMap: A mapping of bytes to callables. When a subnegotiation command is received, the command byte (the first byte after SB) is looked up in this dictionary. If a callable is found, it is invoked with the argument of the subnegotiation. Values should be added to this dictionary if subnegotiations are to be handled. By default, no values are handled. @ivar options: A mapping of option bytes to their current state. This state is likely of little use to user code. Changes should not be made to it. @ivar state: A string indicating the current parse state. It can take on the values "data", "escaped", "command", "newline", "subnegotiation", and "subnegotiation-escaped". Changes should not be made to it. @ivar transport: This protocol's transport object. """ # One of a lot of things state = "data" def __init__(self): self.options = {} self.negotiationMap = {} self.commandMap = { WILL: self.telnet_WILL, WONT: self.telnet_WONT, DO: self.telnet_DO, DONT: self.telnet_DONT, } def _write(self, data): self.transport.write(data) class _OptionState: """ Represents the state of an option on both sides of a telnet connection. @ivar us: The state of the option on this side of the connection. @ivar him: The state of the option on the other side of the connection. """ class _Perspective: """ Represents the state of an option on side of the telnet connection. Some options can be enabled on a particular side of the connection (RFC 1073 for example: only the client can have NAWS enabled). Other options can be enabled on either or both sides (such as RFC 1372: each side can have its own flow control state). @ivar state: C{'yes'} or C{'no'} indicating whether or not this option is enabled on one side of the connection. @ivar negotiating: A boolean tracking whether negotiation about this option is in progress. @ivar onResult: When negotiation about this option has been initiated by this side of the connection, a L{Deferred} which will fire with the result of the negotiation. L{None} at other times. """ state = "no" negotiating = False onResult = None def __str__(self) -> str: return self.state + ("*" * self.negotiating) def __init__(self): self.us = self._Perspective() self.him = self._Perspective() def __repr__(self) -> str: return f"<_OptionState us={self.us} him={self.him}>" def getOptionState(self, opt): return self.options.setdefault(opt, self._OptionState()) def _do(self, option): self._write(IAC + DO + option) def _dont(self, option): self._write(IAC + DONT + option) def _will(self, option): self._write(IAC + WILL + option) def _wont(self, option): self._write(IAC + WONT + option) def will(self, option): """ Indicate our willingness to enable an option. """ s = self.getOptionState(option) if s.us.negotiating or s.him.negotiating: return defer.fail(AlreadyNegotiating(option)) elif s.us.state == "yes": return defer.fail(AlreadyEnabled(option)) else: s.us.negotiating = True s.us.onResult = d = defer.Deferred() self._will(option) return d def wont(self, option): """ Indicate we are not willing to enable an option. """ s = self.getOptionState(option) if s.us.negotiating or s.him.negotiating: return defer.fail(AlreadyNegotiating(option)) elif s.us.state == "no": return defer.fail(AlreadyDisabled(option)) else: s.us.negotiating = True s.us.onResult = d = defer.Deferred() self._wont(option) return d def do(self, option): s = self.getOptionState(option) if s.us.negotiating or s.him.negotiating: return defer.fail(AlreadyNegotiating(option)) elif s.him.state == "yes": return defer.fail(AlreadyEnabled(option)) else: s.him.negotiating = True s.him.onResult = d = defer.Deferred() self._do(option) return d def dont(self, option): s = self.getOptionState(option) if s.us.negotiating or s.him.negotiating: return defer.fail(AlreadyNegotiating(option)) elif s.him.state == "no": return defer.fail(AlreadyDisabled(option)) else: s.him.negotiating = True s.him.onResult = d = defer.Deferred() self._dont(option) return d def requestNegotiation(self, about, data): """ Send a negotiation message for the option C{about} with C{data} as the payload. @param data: the payload @type data: L{bytes} @see: L{ITelnetTransport.requestNegotiation} """ data = data.replace(IAC, IAC * 2) self._write(IAC + SB + about + data + IAC + SE) def dataReceived(self, data): appDataBuffer = [] for b in iterbytes(data): if self.state == "data": if b == IAC: self.state = "escaped" elif b == b"\r": self.state = "newline" else: appDataBuffer.append(b) elif self.state == "escaped": if b == IAC: appDataBuffer.append(b) self.state = "data" elif b == SB: self.state = "subnegotiation" self.commands = [] elif b in (EOR, NOP, DM, BRK, IP, AO, AYT, EC, EL, GA): self.state = "data" if appDataBuffer: self.applicationDataReceived(b"".join(appDataBuffer)) del appDataBuffer[:] self.commandReceived(b, None) elif b in (WILL, WONT, DO, DONT): self.state = "command" self.command = b else: raise ValueError("Stumped", b) elif self.state == "command": self.state = "data" command = self.command del self.command if appDataBuffer: self.applicationDataReceived(b"".join(appDataBuffer)) del appDataBuffer[:] self.commandReceived(command, b) elif self.state == "newline": self.state = "data" if b == b"\n": appDataBuffer.append(b"\n") elif b == b"\0": appDataBuffer.append(b"\r") elif b == IAC: # IAC isn't really allowed after \r, according to the # RFC, but handling it this way is less surprising than # delivering the IAC to the app as application data. # The purpose of the restriction is to allow terminals # to unambiguously interpret the behavior of the CR # after reading only one more byte. CR LF is supposed # to mean one thing (cursor to next line, first column), # CR NUL another (cursor to first column). Absent the # NUL, it still makes sense to interpret this as CR and # then apply all the usual interpretation to the IAC. appDataBuffer.append(b"\r") self.state = "escaped" else: appDataBuffer.append(b"\r" + b) elif self.state == "subnegotiation": if b == IAC: self.state = "subnegotiation-escaped" else: self.commands.append(b) elif self.state == "subnegotiation-escaped": if b == SE: self.state = "data" commands = self.commands del self.commands if appDataBuffer: self.applicationDataReceived(b"".join(appDataBuffer)) del appDataBuffer[:] self.negotiate(commands) else: self.state = "subnegotiation" self.commands.append(b) else: raise ValueError("How'd you do this?") if appDataBuffer: self.applicationDataReceived(b"".join(appDataBuffer)) def connectionLost(self, reason): for state in self.options.values(): if state.us.onResult is not None: d = state.us.onResult state.us.onResult = None d.errback(reason) if state.him.onResult is not None: d = state.him.onResult state.him.onResult = None d.errback(reason) def applicationDataReceived(self, data): """ Called with application-level data. """ def unhandledCommand(self, command, argument): """ Called for commands for which no handler is installed. """ def commandReceived(self, command, argument): cmdFunc = self.commandMap.get(command) if cmdFunc is None: self.unhandledCommand(command, argument) else: cmdFunc(argument) def unhandledSubnegotiation(self, command, data): """ Called for subnegotiations for which no handler is installed. """ def negotiate(self, data): command, data = data[0], data[1:] cmdFunc = self.negotiationMap.get(command) if cmdFunc is None: self.unhandledSubnegotiation(command, data) else: cmdFunc(data) def telnet_WILL(self, option): s = self.getOptionState(option) self.willMap[s.him.state, s.him.negotiating](self, s, option) def will_no_false(self, state, option): # He is unilaterally offering to enable an option. if self.enableRemote(option): state.him.state = "yes" self._do(option) else: self._dont(option) def will_no_true(self, state, option): # Peer agreed to enable an option in response to our request. state.him.state = "yes" state.him.negotiating = False d = state.him.onResult state.him.onResult = None d.callback(True) assert self.enableRemote( option ), "enableRemote must return True in this context (for option {!r})".format( option ) def will_yes_false(self, state, option): # He is unilaterally offering to enable an already-enabled option. # Ignore this. pass def will_yes_true(self, state, option): # This is a bogus state. It is here for completeness. It will # never be entered. assert ( False ), "will_yes_true can never be entered, but was called with {!r}, {!r}".format( state, option, ) willMap = { ("no", False): will_no_false, ("no", True): will_no_true, ("yes", False): will_yes_false, ("yes", True): will_yes_true, } def telnet_WONT(self, option): s = self.getOptionState(option) self.wontMap[s.him.state, s.him.negotiating](self, s, option) def wont_no_false(self, state, option): # He is unilaterally demanding that an already-disabled option be/remain disabled. # Ignore this (although we could record it and refuse subsequent enable attempts # from our side - he can always refuse them again though, so we won't) pass def wont_no_true(self, state, option): # Peer refused to enable an option in response to our request. state.him.negotiating = False d = state.him.onResult state.him.onResult = None d.errback(OptionRefused(option)) def wont_yes_false(self, state, option): # Peer is unilaterally demanding that an option be disabled. state.him.state = "no" self.disableRemote(option) self._dont(option) def wont_yes_true(self, state, option): # Peer agreed to disable an option at our request. state.him.state = "no" state.him.negotiating = False d = state.him.onResult state.him.onResult = None d.callback(True) self.disableRemote(option) wontMap = { ("no", False): wont_no_false, ("no", True): wont_no_true, ("yes", False): wont_yes_false, ("yes", True): wont_yes_true, } def telnet_DO(self, option): s = self.getOptionState(option) self.doMap[s.us.state, s.us.negotiating](self, s, option) def do_no_false(self, state, option): # Peer is unilaterally requesting that we enable an option. if self.enableLocal(option): state.us.state = "yes" self._will(option) else: self._wont(option) def do_no_true(self, state, option): # Peer agreed to allow us to enable an option at our request. state.us.state = "yes" state.us.negotiating = False d = state.us.onResult state.us.onResult = None d.callback(True) self.enableLocal(option) def do_yes_false(self, state, option): # Peer is unilaterally requesting us to enable an already-enabled option. # Ignore this. pass def do_yes_true(self, state, option): # This is a bogus state. It is here for completeness. It will never be # entered. assert ( False ), "do_yes_true can never be entered, but was called with {!r}, {!r}".format( state, option, ) doMap = { ("no", False): do_no_false, ("no", True): do_no_true, ("yes", False): do_yes_false, ("yes", True): do_yes_true, } def telnet_DONT(self, option): s = self.getOptionState(option) self.dontMap[s.us.state, s.us.negotiating](self, s, option) def dont_no_false(self, state, option): # Peer is unilaterally demanding us to disable an already-disabled option. # Ignore this. pass def dont_no_true(self, state, option): # Offered option was refused. Fail the Deferred returned by the # previous will() call. state.us.negotiating = False d = state.us.onResult state.us.onResult = None d.errback(OptionRefused(option)) def dont_yes_false(self, state, option): # Peer is unilaterally demanding we disable an option. state.us.state = "no" self.disableLocal(option) self._wont(option) def dont_yes_true(self, state, option): # Peer acknowledged our notice that we will disable an option. state.us.state = "no" state.us.negotiating = False d = state.us.onResult state.us.onResult = None d.callback(True) self.disableLocal(option) dontMap = { ("no", False): dont_no_false, ("no", True): dont_no_true, ("yes", False): dont_yes_false, ("yes", True): dont_yes_true, } def enableLocal(self, option): """ Reject all attempts to enable options. """ return False def enableRemote(self, option): """ Reject all attempts to enable options. """ return False def disableLocal(self, option): """ Signal a programming error by raising an exception. L{enableLocal} must return true for the given value of C{option} in order for this method to be called. If a subclass of L{Telnet} overrides enableLocal to allow certain options to be enabled, it must also override disableLocal to disable those options. @raise NotImplementedError: Always raised. """ raise NotImplementedError( f"Don't know how to disable local telnet option {option!r}" ) def disableRemote(self, option): """ Signal a programming error by raising an exception. L{enableRemote} must return true for the given value of C{option} in order for this method to be called. If a subclass of L{Telnet} overrides enableRemote to allow certain options to be enabled, it must also override disableRemote tto disable those options. @raise NotImplementedError: Always raised. """ raise NotImplementedError( f"Don't know how to disable remote telnet option {option!r}" ) class ProtocolTransportMixin: def write(self, data): self.transport.write(data.replace(b"\n", b"\r\n")) def writeSequence(self, seq): self.transport.writeSequence(seq) def loseConnection(self): self.transport.loseConnection() def getHost(self): return self.transport.getHost() def getPeer(self): return self.transport.getPeer() class TelnetTransport(Telnet, ProtocolTransportMixin): """ @ivar protocol: An instance of the protocol to which this transport is connected, or None before the connection is established and after it is lost. @ivar protocolFactory: A callable which returns protocol instances which provide L{ITelnetProtocol}. This will be invoked when a connection is established. It is passed *protocolArgs and **protocolKwArgs. @ivar protocolArgs: A tuple of additional arguments to pass to protocolFactory. @ivar protocolKwArgs: A dictionary of additional arguments to pass to protocolFactory. """ disconnecting = False protocolFactory = None protocol = None def __init__(self, protocolFactory=None, *a, **kw): Telnet.__init__(self) if protocolFactory is not None: self.protocolFactory = protocolFactory self.protocolArgs = a self.protocolKwArgs = kw def connectionMade(self): if self.protocolFactory is not None: self.protocol = self.protocolFactory( *self.protocolArgs, **self.protocolKwArgs ) assert ITelnetProtocol.providedBy(self.protocol) try: factory = self.factory except AttributeError: pass else: self.protocol.factory = factory self.protocol.makeConnection(self) def connectionLost(self, reason): Telnet.connectionLost(self, reason) if self.protocol is not None: try: self.protocol.connectionLost(reason) finally: del self.protocol def enableLocal(self, option): return self.protocol.enableLocal(option) def enableRemote(self, option): return self.protocol.enableRemote(option) def disableLocal(self, option): return self.protocol.disableLocal(option) def disableRemote(self, option): return self.protocol.disableRemote(option) def unhandledSubnegotiation(self, command, data): self.protocol.unhandledSubnegotiation(command, data) def unhandledCommand(self, command, argument): self.protocol.unhandledCommand(command, argument) def applicationDataReceived(self, data): self.protocol.dataReceived(data) def write(self, data): ProtocolTransportMixin.write(self, data.replace(b"\xff", b"\xff\xff")) class TelnetBootstrapProtocol(TelnetProtocol, ProtocolTransportMixin): protocol = None def __init__(self, protocolFactory, *args, **kw): self.protocolFactory = protocolFactory self.protocolArgs = args self.protocolKwArgs = kw def connectionMade(self): self.transport.negotiationMap[NAWS] = self.telnet_NAWS self.transport.negotiationMap[LINEMODE] = self.telnet_LINEMODE for opt in (LINEMODE, NAWS, SGA): self.transport.do(opt).addErrback( lambda f: self._log.failure("Error do {opt!r}", f, opt=opt) ) for opt in (ECHO,): self.transport.will(opt).addErrback( lambda f: self._log.failure("Error setting will {opt!r}", f, opt=opt) ) self.protocol = self.protocolFactory(*self.protocolArgs, **self.protocolKwArgs) try: factory = self.factory except AttributeError: pass else: self.protocol.factory = factory self.protocol.makeConnection(self) def connectionLost(self, reason): if self.protocol is not None: try: self.protocol.connectionLost(reason) finally: del self.protocol def dataReceived(self, data): self.protocol.dataReceived(data) def enableLocal(self, opt): if opt == ECHO: return True elif opt == SGA: return True else: return False def enableRemote(self, opt): if opt == LINEMODE: self.transport.requestNegotiation(LINEMODE, MODE + LINEMODE_TRAPSIG) return True elif opt == NAWS: return True elif opt == SGA: return True else: return False def telnet_NAWS(self, data): # NAWS is client -> server *only*. self.protocol will # therefore be an ITerminalTransport, the `.protocol' # attribute of which will be an ITerminalProtocol. Maybe. # You know what, XXX TODO clean this up. if len(data) == 4: width, height = struct.unpack("!HH", b"".join(data)) self.protocol.terminalProtocol.terminalSize(width, height) else: self._log.error("Wrong number of NAWS bytes: {nbytes}", nbytes=len(data)) linemodeSubcommands = {LINEMODE_SLC: "SLC"} def telnet_LINEMODE(self, data): # linemodeSubcommand = data[0] # # XXX TODO: This should be enabled to parse linemode subnegotiation. # getattr(self, "linemode_" + self.linemodeSubcommands[linemodeSubcommand])( # data[1:] # ) pass def linemode_SLC(self, data): chunks = zip(*[iter(data)] * 3) for slcFunction, slcValue, slcWhat in chunks: # Later, we should parse stuff. "SLC", ord(slcFunction), ord(slcValue), ord(slcWhat) from twisted.protocols import basic class StatefulTelnetProtocol(basic.LineReceiver, TelnetProtocol): delimiter = b"\n" state = "Discard" def connectionLost(self, reason): basic.LineReceiver.connectionLost(self, reason) TelnetProtocol.connectionLost(self, reason) def lineReceived(self, line): oldState = self.state newState = getattr(self, "telnet_" + oldState)(line) if newState is not None: if self.state == oldState: self.state = newState else: self._log.warn("state changed and new state returned") def telnet_Discard(self, line): pass from twisted.cred import credentials class AuthenticatingTelnetProtocol(StatefulTelnetProtocol): """ A protocol which prompts for credentials and attempts to authenticate them. Username and password prompts are given (the password is obscured). When the information is collected, it is passed to a portal and an avatar implementing L{ITelnetProtocol} is requested. If an avatar is returned, it connected to this protocol's transport, and this protocol's transport is connected to it. Otherwise, the user is re-prompted for credentials. """ state = "User" protocol = None def __init__(self, portal): self.portal = portal def connectionMade(self): self.transport.write(b"Username: ") def connectionLost(self, reason): StatefulTelnetProtocol.connectionLost(self, reason) if self.protocol is not None: try: self.protocol.connectionLost(reason) self.logout() finally: del self.protocol, self.logout def telnet_User(self, line): self.username = line self.transport.will(ECHO) self.transport.write(b"Password: ") return "Password" def telnet_Password(self, line): username, password = self.username, line del self.username def login(ignored): creds = credentials.UsernamePassword(username, password) d = self.portal.login(creds, None, ITelnetProtocol) d.addCallback(self._cbLogin) d.addErrback(self._ebLogin) self.transport.wont(ECHO).addCallback(login) return "Discard" def _cbLogin(self, ial): interface, protocol, logout = ial assert interface is ITelnetProtocol self.protocol = protocol self.logout = logout self.state = "Command" protocol.makeConnection(self.transport) self.transport.protocol = protocol def _ebLogin(self, failure): self.transport.write(b"\nAuthentication failed\n") self.transport.write(b"Username: ") self.state = "User" __all__ = [ # Exceptions "TelnetError", "NegotiationError", "OptionRefused", "AlreadyNegotiating", "AlreadyEnabled", "AlreadyDisabled", # Interfaces "ITelnetProtocol", "ITelnetTransport", # Other stuff, protocols, etc. "Telnet", "TelnetProtocol", "TelnetTransport", "TelnetBootstrapProtocol", ]