Telnet output carriage-return disposition option
Negotiating how to handle carriage-return characters in Telnet output
Crocker, D., "Telnet output carriage-return disposition option", RFC 652, DOI 10.17487/RFC0652, October 1974, <https://www.rfc-editor.org/info/rfc652>.
@misc{rfc652,
series = {Request for Comments},
number = 652,
howpublished = {RFC 652},
publisher = {RFC Editor},
doi = {10.17487/RFC0652},
url = {https://www.rfc-editor.org/info/rfc652},
author = {D. Crocker},
title = {{Telnet output carriage-return disposition option}},
pagetotal = 4,
year = 1974,
month = oct,
} RFC text
Contents
Request for Comments: 652 D. Crocker (UCLA-NMC)
25 Oct. 74
NIC #31155
Online file: [ISI]<DCROCKER>NAOCRD.TXT
Telnet Output Carriage-Return Disposition Option
1. Command name and code
NAOCRD 10 (Negotiate About Output Carriage-Return Disposition)
2. Command meanings
In the following, we are discussing a simplex connection, as
described in the NAOL and NAOP Telnet options.
IAC DO NAOCRD The data sender requests or agrees to negotiate
about output carriage-return character
disposition with the data receiver. In the
case where agreement has been reached and in
the absence of further subnegotiations, the
data receiver is assumed to be handling output
carriage-returns.
IAC DON'T NAOCRD The data sender refuses to negotiate about
output carriage-return disposition with the
data receiver, or demands a return to the
unnegotiated default mode.
IAC WILL NAOCRD The data receiver requests or agrees to
negotiate about output carriage-return
disposition with the sender. In the case where
agreement has been reached and in the absence
of further subnegotiations, the data receiver
alone is assumed to be handling output
carriage-returns.
IAC WON'T NAOCRD The data receiver refuses to negotiate about
output carriage-return disposition, or demands
a return to the unnegotiated default mode.
IAC SB NAOCRD DS <8-bit value> IAC SE
The data sender specifies, with the 8-bit
value, which party should handle
carriage-returns and what their disposition
should be. The code for DS is 1.
Telnet NAOCRD Option Page 2
IAC SB NAOCRD DR <8-bit value> IAC SE The data receiver
specifies, with the 8-bit value, which party
should handle carriage-returns and what their
disposition should be. The code for DR is 0.
3. Default
DON'T NAOCRD/WON'T NAOCRD. In the default absence of
negotiations concerning which party, data sender or data receiver,
is handling output carriage-returns, neither party is required to
handle carriage-returns and neither party is prohibited from
handling them; but it is appropriate if at least the data receiver
handles carriage-returns, albeit primitively.
4. Motivation for the Option
Please refer to section 4 of the NAOL and of the NAOP Telnet
option descriptions.
5. Description of the Option
The data sender and the data receiver use the 8-bit value along
with the NAOCRD SB commands as follows:
8-bit value Meaning
0 Command sender suggests that he alone will
handle carriage-returns, for the connection.
1 to 250 Command sender suggests that the other party
alone should handle carriage-returns, but
suggests that a delay of the indicated value be
used. The value is the number of
character-times to wait or number of NULs to
insert in the data stream before sending the
next data character. (See qualification,
below.)
251 Not allowed, in order to be compatible with
related Telnet options.
252 Command sender suggests that the other party
alone handle carriage-returns, but suggests
that they be discarded.
253 Not allowed, in order to be compatible with
related Telnet options.
Telnet NAOCRD Option Page 3
254 Command sender suggests that the other party
alone should handle carriage-returns but
suggests waiting for a character to be
transmitted (on the other simplex connection)
before sending more data. (See qualification,
below.) Note that, due to the assynchrony of
the two simplex connections, phase problems can
occur with this option.
255 Command sender suggests that the other party
alone should handle carriage-returns and
suggests nothing about how it should be done.
The guiding rules are that:
(1) if neither data receiver nor data sender wants to handle
carriage-returns, the data receiver must do it, and
(2) if both data receiver and data sender want to handle
carriage-returns, the data sender gets to do it.
The reasoning for the former rule is that if neither wants to do
it, then the default in the NAOCRD option dominates. If both want
to do it, the sender, who is presumed to have special knowledge
about the data, should be allowed to do it, taking into account any
suggestions the receiver may make.
Note that carriage-return delays, controlled by the data sender,
must consist of NUL characters inserted immediately after the
character in question. This is necessary due to the assynchrony of
network transmissions. Due to the Telnet end-of-line convention,
with carriage-returns followed by a linefeed, any NULs that would
otherwise be placed after the carriage-return must be placed after
the linefeed, regardless of any modifications that may additionally
be made to the line feed (see NAOLFD Telnet option).
As with all option negotiations, neither party should suggest a
state already in effect except to refuse to negotiate; changes
should be acknowledged; and once refused, an option should not be
resuggested until "something changes" (e.g., another process
starts).
At any time, either party can disable further negotiation by
giving the appropriate WON'T NAOCRD or DON'T NAOCRD command.
AI ELI5
On this page
§1The Carriage-Return Problem
RFC 652 defines the NAOCRD (Negotiate About Output Carriage-Return Disposition) Telnet option, command code 10. The problem it addresses stems from the differences in how computers and terminals handle the carriage-return character (ASCII 13). Some systems move the cursor one space per carriage-return; others move to the beginning of the line; still others require a delay or insertion of null bytes before the next character to allow mechanical terminals time to return the carriage. When Telnet connects two systems with incompatible carriage-return behaviors, output can appear garbled or misaligned.
NAOCRD allows the data sender and receiver to negotiate during the Telnet session which party should handle carriage-return processing and what the disposition should be, ensuring both systems produce compatible display output.
When two computers talk over Telnet, they need to agree on what a carriage-return does. One might add a delay, another might move the cursor differently. Negotiating avoids confusion.
§2Negotiation and Disposition Codes
The option uses IAC (Interpret As Command) codes to negotiate: DO NAOCRD (sender requests or agrees to negotiate), DON'T NAOCRD (sender refuses), WILL NAOCRD (receiver requests or agrees), and WON'T NAOCRD (receiver refuses). Once both sides agree to negotiate, they exchange subnegotiation commands with an 8-bit disposition code indicating the desired carriage-return handling:
0: Command sender alone handles carriage-returns (no delay)1 to 250: Other party handles carriage-returns with a delay of 1 to 250 character-times or null insertions252: Other party handles carriage-returns but discards them254: Other party handles carriage-returns; sender will wait for a character on the reverse connection before sending more255: Other party handles carriage-returns; sender suggests nothing about method
Two rules govern the negotiation: if neither party wants to handle carriage-returns, the receiver must do it; if both want to, the sender prevails. These rules ensure a consistent outcome regardless of preferences.
They exchange codes saying who should handle the carriage-return and what kind of delay or skip should happen.
§3Historic Status and Legacy
RFC 652 is now classified as Historic, reflecting that modern systems have largely standardized on line-ending conventions and that Telnet itself is less widely used than in earlier eras. However, the RFC provides important insight into the diversity of early computing systems and the need for negotiation protocols to achieve interoperability. The NAOCRD approach—defining option codes and subnegotiation procedures—became the model for many other Telnet options that addressed similar terminal capability differences.
The RFC demonstrates the problem-solving approach of the early ARPANET community: when systems differ, define a negotiation method that lets them discover and adapt to each other's capabilities without requiring manual configuration or universal standards.
This option is no longer used because computers now handle these details automatically. But it shows how engineers solved the problem when machines worked very differently.