1#@!#!123s

: / proc / 3 / task / 3 / root / opt / imh-python / lib / python3.9 / site-packages / twisted / conch /
Filename : telnet.py
back
# -*- 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<https://tools.ietf.org/html/rfc854>} 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",
]