Posted on |


The purpose of the TELNET Protocol is to provide a fairly general, bi-directional, eight-bit byte oriented communications facility.  Its primary goal is to allow a standard method of interfacing terminal devices and terminal-oriented processes to each other. It is envisioned that the protocol may also be used for terminal-terminal communication and process-process communication.

A TELNET connection is a Transmission Control Protocol (TCP) connection used to transmit data with interspersed TELNET control information. The TELNET Protocol is built upon three main ideas:

  1. The concept of a Network Virtual Terminal
  2. The principle of negotiated options
  3. A symmetric view of terminals and processes.

1.  When a TELNET connection is first established, each end is assumed to originate and terminate at a “Network Virtual Terminal”, or NVT.  An NVT is an imaginary device which provides a standard, network-wide, intermediate representation of a canonical terminal. This eliminates the need for “server” and “user” hosts to keep information about the characteristics of each other’s terminals and terminal handling conventions.  All hosts, both user, and server map their local device characteristics and conventions so as to appear to be dealing with an NVT over the network, and each can assume a similar mapping by the other party.  The NVT is intended to strike a balance between being overly restricted (not providing hosts a rich enough vocabulary for mapping into their local character sets), and being overly inclusive (penalizing users with modest terminals).


2.  The principle of negotiated options takes cognizance of the fact that many hosts will wish to provide additional services over and above those available within an NVT, and many users will have sophisticated terminals and would like to have elegant, rather than minimal, services.  Independent of, but structured within the TELNET Protocol are various “options” that will be sanctioned and may be used with the “DO, DON’T, WILL, WON’T” structure (discussed below) to allow a user and server to agree to use a more elaborate (or perhaps just different) set of conventions for their TELNET connection.  Such options could include changing the character set, the echo mode, etc.


The basic strategy for setting up the use of options is to have either party (or both) initiate a request that some option takes effect.  The other party may then either accept or reject the request.  If the request is accepted the option immediately takes effect; if it is rejected the associated aspect of the connection remains as specified for an NVT.  Clearly, a party may always refuse a request to enable, and must never refuse a request to disable some option since all parties must be prepared to support the NVT. The syntax of option negotiation has been set up so that if both parties request an option simultaneously, each will see the other’s request as the positive acknowledgment of its own.

3.  The symmetry of the negotiation syntax can potentially lead to nonterminating acknowledgment loops — each party seeing the incoming commands not as acknowledgments but as new requests which must be acknowledged.  To prevent such loops, the following rules prevail:
a.    Parties may only request a change in option status; i.e., a party may not send out a “request” merely to announce what mode it is in.
b.    If a party receives what appears to be a request to enter some mode it is already in, the request should not be acknowledged. This non-response is essential to prevent endless loops in the negotiation.  It is required that a response be sent to requests for a change of mode — even if the mode is not changed.

c.  Whenever one party sends an option command to a second party, whether as a request or an acknowledgment, and use of the option will have any effect on the processing of the data being sent from the first party to the second, then the command must be inserted in the data stream at the point where it is desired that it take effect.  (It should be noted that some time will elapse between the transmission of a request and the receipt of an acknowledgment, which may be negative.  Thus, a host may wish to buffer data, after requesting an option, until it learns whether the request is accepted or rejected, in order to hide the  “uncertainty period” from the user.)


Option requests are likely to flurry back and forth when a TELNET connection is first established, as each party attempts to get the best possible service from the other party.  Beyond that, however, options can be used to dynamically modify the characteristics of the connection to suit changing local conditions.  For example, the NVT uses a transmission discipline well suited to the many “line at a time” applications such as BASIC, but poorly suited to the many “character at a time” applications such as NLS.  A server might elect to devote the extra processor overhead required for a “character at a time” discipline when it was suitable for the local process and would negotiate an appropriate option. However, rather than then being permanently burdened with the extra processing overhead, it could switch (i.e., negotiate) back to NVT when the detailed control was no longer necessary.


It is possible for requests initiated by processes to stimulate a nonterminating request loop if the process responds to a rejection by merely re-requesting the option.  To prevent such loops from occurring, rejected requests should not be repeated until something changes.  Operationally, this can mean the process is running a different program, or the user has given another command, or whatever makes sense in the context of the given process and the given option. A good rule of thumb is that a re-request should only occur as a result of subsequent information from the other end of the connection or when demanded by local human intervention.

As much as possible, the TELNET protocol has been made server-user symmetrical so that it easily and naturally covers the user-user (linking) and server-server (cooperating processes) cases.  It is hoped, but not absolutely required, that options will further this intent.  In any case, it is explicitly acknowledged that symmetry is an operating principle rather than an ironclad rule.


The Network Virtual Terminal (NVT) is a bi-directional character device.  The NVT has a printer and a keyboard.  The printer responds to incoming data and the keyboard produces outgoing data which is sent over the TELNET connection and, if “echoes” are desired, to the NVT’s printer as well.  “Echoes” will not be expected to traverse the network (although options exist to enable a “remote” echoing mode of operation, no host is required to implement this option).  The code set is seven-bit USASCII in an eight-bit field, except as modified herein.  Any code conversion and timing considerations are local problems and do not affect the NVT.


Although a TELNET connection through the network is intrinsically full duplex, the NVT is to be viewed as a half-duplex device operating in a line-buffered mode. That is, unless and until options are negotiated to the contrary, the following default conditions pertain to the transmission of data over the TELNET connection:
1)    Insofar as the availability of local buffer space permits, data should be accumulated in the host where it is generated until a complete line of data is ready for transmission, or until some locally-defined explicit signal to transmit occurs. This signal could be generated either by a process or by a human user.
2)   When a process has completed sending data to an NVT printer and has no queued input from the NVT keyboard for further processing, the process must transmit the TELNET Go Ahead (GA) command.


As stated in the Introduction to this video, the primary goal of the TELNET protocol is the provision of a standard interfacing of terminal devices and terminal-oriented processes through the network.  Early experiences with this type of interconnection have shown that certain functions are implemented by most servers, but that the methods of invoking these functions differ widely.  For a human user who interacts with several server systems, these differences are highly frustrating.  TELNET, therefore, defines a standard representation for five of these functions, as described below.  These standard representations have standard, but not required, meanings (with the exception that the Interrupt Process (IP) function may be required by other protocols which use TELNET); that is, a system which does not provide the function to local users need not provide it to network users and may treat the standard representation for the function as a No-operation.  On the other hand, a system which does provide the function to a local user is obliged to provide the same function to a network user who transmits the standard representation for the function.

Interrupt Process (IP)

Many systems provide a function which suspends, interrupts,  aborts, or terminates the operation of a user process.  This function is frequently used when a user believes his process is in an unending loop, or when an unwanted process has been inadvertently activated.  IP is the standard representation for invoking this function.  It should be noted by implementers that IP may be required by other protocols which use TELNET, and therefore should be implemented if these other protocols are to be supported.

Abort Output (AO)

Many systems provide a function which allows a process, which is generating output, to run to completion but without sending the output to the user’s terminal. Further, this function typically clears any output already produced but not yet actually printed (or displayed) on the user’s terminal.  AO is the standard representation for invoking this function.  For example, some subsystem might normally accept a user’s command, send a long text string to the user’s terminal in response, and finally signal readiness to accept the next command by sending a “prompt” character (preceded by ) to the user’s terminal.  If the AO were received during the transmission of the text string, a reasonable implementation would be to suppress the remainder of the text string but transmit the prompt character and the preceding.

Are You There (AYT)

Many systems provide a function which provides the user with some visible (e.g., printable) evidence that the system is still up and running.  This function may be invoked by the user when the system is unexpectedly “silent” for a long time, because of the unanticipated (by the user) length of a computation, an unusually heavy system load, etc.  AYT is the standard representation for invoking this function.

Erase Character (EC)

Many systems provide a function which deletes the last preceding undeleted character or “print position”* from the stream of data being supplied by the user.  This function is typically used to edit keyboard input when typing mistakes are made.  EC is the standard representation for invoking this function.

Erase Line (EL)

Many systems provide a function which deletes all the data in the current “line” of input.  This function is typically used to edit keyboard input.  EL is the standard representation for invoking this function.

Books you may interested



Leave a Reply

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.