RFC 2066
TELNET CHARSET Option
Title Block 🎀
RFC 2066: TELNET CHARSET Option 💖
Okay bestie, this one is by R. Gellens at Unisys, dated January 1997, and it's filed as an Experimental doc 🧪. There's no Obsoletes or Updates line in the header, so it isn't replacing or changing any other RFC 💅.
Status of this Memo ✨
This memo defines an Experimental Protocol for the Internet community. It is not an Internet standard of any kind 🙈. The authors are asking for discussion and suggestions for improvement, and distribution is unlimited 🌈.
Abstract 🦋
This doc describes a way for a TELNET client and server to pass along character set and translation info. Once it's in use, the app a TELNET user is running can send and receive data in the correct character set, which is so important 😭.
Either side can (subject to option negotiation) ask for a (new) character set to be used at any time. Iconic behavior 👑.
1. Command Names and Codes 💅
The CHARSET command and its sub-commands, with their codes:
CHARSET.......................42
REQUEST ....................01
ACCEPTED ...................02
REJECTED ...................03
TTABLE-IS ..................04
TTABLE-REJECTED ............05
TTABLE-ACK .................06
TTABLE-NAK .................07As a little convenience, the doc also copies the standard TELNET text and command codes it uses, excerpted from [1]. Read this part as the TELNET basics 🧚:
All TELNET commands consist of at least a two byte sequence: the
"Interpret as Command" (IAC) escape character followed by the code
for the command. The commands dealing with option negotiation are
three byte sequences, the third byte being the code for the option
referenced. ... [O]nly the IAC need be doubled to be sent as data,
and the other 255 codes may be passed transparently. The
following are [some of] the defined TELNET commands. Note that
these codes and code sequences have the indicated meaning only
when immediately preceded by an IAC.
NAME CODE MEANING
SE 240 End of subnegotiation parameters.
SB 250 Indicates that what follows is
subnegotiation of the indicated
option.
WILL 251 Indicates the desire to begin
performing, or confirmation that
you are now performing, the
indicated option.
WON'T 252 Indicates the refusal to perform,
or continue performing, the
indicated option.
DO 253 Indicates the request that the
other party perform, or
confirmation that you are expecting
the other party to perform, the
indicated option.
DON'T 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 255 Data Byte 255.2. Command Meanings 🍓
The meta-syntax is super simple. Most tokens are things already defined (like IAC). <> marks stuff that gets defined later, {} marks optional stuff, ellipses mean repeated sequences, and quotes are literal strings 🫶.
IAC WILL CHARSET
The sender REQUESTS permission to, or AGREES to, use CHARSET option subnegotiation to choose a character set 🔥.
IAC WON'T CHARSET
The sender REFUSES to use CHARSET option subnegotiation to choose a character set 🙅♀️.
IAC DO CHARSET
The sender REQUESTS that, or AGREES to have, the other side use CHARSET option subnegotiation to choose a character set ✨.
IAC DON'T CHARSET
The sender DEMANDS that the other side not use the CHARSET option subnegotiation 💀.
IAC SB CHARSET REQUEST
IAC SB CHARSET REQUEST { "[TTABLE ]" <Version> } <char set
list> IAC SE
Char set list:
<sep> <character set> { ... <sep> <character set> }This message starts a brand new CHARSET subnegotiation 🌸. Only a side that has received a DO CHARSET message and sent a WILL CHARSET message can send it, and those two can happen in either order.
The sender is asking that all text sent to it and by it be encoded in one of the listed character sets. Main character energy 👑.
If the string [TTABLE] shows up, the sender is willing to accept a mapping (translation table) between any character set in the <char set list> and any character set the receiver wants.
<Version> is an octet. Its binary value is the highest version level of the TTABLE-IS message that can be sent back in response. This field must not be zero. Check the TTABLE-IS message for the allowed version values 🧐.
<Char set list> is a sequence of 7-BIT ASCII printable characters. The first octet is the separator character, and it must not appear inside any character set name. The list ends with the IAC SE sequence. Case doesn't matter. It has one or more character sets, and they should be listed in order of preference, most preferred first 🎀.
<Sep> is a separator octet, and the sender picks its value. Examples are a space or a semicolon. Any value other than IAC is allowed. The obvious pick is a space or some other punctuation mark that doesn't show up in any of the character set names 💅.
<Character set> is a sequence of 7-BIT ASCII printable characters. Case doesn't matter 🦋.
If a requested character set name doesn't start with "X-" or "x-", it MUST be registered with the Internet Assigned Number Authority (IANA) [2]. No skipping that step, bestie 🫶.
The receiver can respond in one of four ways 🌈:
If the receiver is already sending text to the sender and expecting text from it, and the text is encoded in one of the listed character sets, it sends a positive acknowledgment (CHARSET ACCEPTED). It MUST NOT ignore the message. Ignoring it might be what some readings of the relevant RFCs ([1], [3]) suggest, but for determinacy it's not allowed 🙅♀️. This way the issuer never has to time out and guess at a response. And since nobody replies to a positive acknowledgment, you also dodge the never-ending subnegotiation that the RFCs were worried about when they said not to respond. Clever, right? 🧠
If the receiver can handle at least one of the listed character sets, it can send a positive acknowledgment for one of them. Normally it should pick the first set it can handle, though it may choose one based on its own preferences. After that, each side MUST encode subsequent text in the specified character set 🔥.
If the string [TTABLE] is there, and the receiver wants a character set that isn't in the <char set list>, and it's able to do that, it can send a translate table (TTABLE-IS) response 🧚.
If the receiver can't handle any of the listed character sets, it sends a negative acknowledgment (CHARSET REJECTED) 💀.
Here's the tricky one. It isn't valid to answer a CHARSET REQUEST with another CHARSET REQUEST. So if a CHARSET REQUEST shows up after you've already sent one, it means both sides sent them at the same time 😭. In that case, the server side MUST issue a negative acknowledgment, and the client side MUST respond to the one from the server 🫶.
IAC SB CHARSET ACCEPTED <Charset> IAC SE
This is the positive acknowledgment to a CHARSET REQUEST. The receiver of the request acknowledges it and accepts the character set it names ✨.
<Charset> is a character sequence that matches one of the character sets in the CHARSET REQUEST message. It ends with the IAC SE sequence.
Text messages that come after this response must now be coded in the named character set. This message ends the current CHARSET subnegotiation 🍓.
IAC SB CHARSET REJECTED IAC SE
This is the negative acknowledgment to a CHARSET REQUEST. The receiver acknowledges getting it, but refuses to use any of the requested character sets. Nothing can be sent in any of the listed character sets 🙈.
This message can also be sent by the sender of a TTABLE-IS message, if multiple TTABLE-NAK messages came back in response. This message ends the current CHARSET subnegotiation 💅.
IAC SB CHARSET TTABLE-IS <version> <syntax for version> IAC SE
When a CHARSET REQUEST was sent with [TTABLE] in it, the receiver of that request acknowledges it and sends back a pair of tables that define the mapping between the specified character sets 🦋.
<Version> is an octet whose binary value is the version level of this TTABLE-IS message. Different versions have different syntax. The lowest version level is one, since zero isn't valid, and the current highest version level is also one. This field exists so future TTABLE-SEND versions can be specified. For example, they could handle character sets with no simple one-to-one character-for-character translation, like some multi-octet character sets where translation algorithms or subsets need to be sent. Future-proofing is everything 🔮.
Syntax for Version 1
<sep> <char set name 1> <sep> < char size 1> < char count 1> <char
set name 2> <sep> <char size 2> <char count 2> <map 1> <map 2><Sep> is a separator octet, and the sender picks its value. Examples are a space or a semicolon. Any value other than IAC is allowed. The obvious pick is a space or another punctuation mark that doesn't show up in either of the character set names 🎀.
<Char set name 1> and <Char set name 2> are sequences of 7-BIT ASCII printable characters that name the two character sets the mapping is for. Each one ends with <sep>. Case doesn't matter. If a character set name doesn't start with "X-" or "x-", it MUST be registered with IANA. <Char set name 1> MUST be chosen from the <char set list> in the CHARSET REQUEST message. <Char set name 2> can be picked at random. Text on the wire MUST be encoded using <char set name 2> 💖.
<Char size 1> and <char size 2> are each a single octet. The binary value of the octet is the number of bits nominally needed for each character in the matching table. It SHOULD be a multiple of eight 🌈.
<Char count 1> and <char count 2> are each three-octet binary fields in Network Byte Order [6]. Each one says how many characters (out of the maximum 2**<char size>) are being sent in the matching map ✨.
Okay so bestie, the translate tables are where it gets spicy 🌶️. Each map is just a list of characters, and the index is literally the character's binary value. ✨
<Map1> and <Map 2> each consist of the corresponding <char count> number of characters. These characters form a mapping from all or part of the characters in one of the specified character sets to the correct characters in the other character set. If the indicated <char count> is less than 2**<char size>, the first <char count> characters are being mapped, and the remaining characters are assumed to not be changed (and thus map to themselves). That is, each map contains characters 0 through <char count> -1. <Map 1> maps from <char set name 1> to <char set name 2>. <Map 2> maps from <char set name 2> to <char set name 1>. Translation between the character sets is thus an obvious process of using the binary value of a character as an index into the appropriate map. The character at that index replaces the original character. If the index exceeds the <char count> for the map, no translation is performed for the character. 💅
🚨 Note to implementers: since TELNET works in octets, it is possible for octets of value 255 to appear "spontaneously" when using multi-octet or non-8-bit characters. All octets of value 255 (other than IAC) MUST be quoted to conform with TELNET requirements. This applies even to octets within a table, or text in a multi-octet character set. 🙈
The sender acknowledges the successful receipt of the translate table. Text messages which follow this response must now be coded in the character set specified as <char set name 2> of the TTABLE-IS message. This message terminates the current CHARSET subnegotiation. 🎀
IAC SB CHARSET TTABLE-ACK IAC SEThe sender reports the unsuccessful receipt of the translate table and requests that it be resent. If subsequent transmission attempts also fail, a TTABLE-REJECTED or CHARSET REJECTED message (depending on which side sends it) should be sent instead of additional futile TTABLE-IS and TTABLE-NAK messages. 😭
IAC SB CHARSET TTABLE-NAK IAC SEIn response to a TTABLE-IS message, the receiver of the TTABLE-IS message acknowledges its receipt and indicates it is unable to handle it. This message terminates the current CHARSET subnegotiation. 🥀
IAC SB CHARSET TTABLE-REJECTED IAC SEAny system which supports the CHARSET option MUST fully support the CHARSET REQUEST, ACCEPTED, REJECTED, and TTABLE-REJECTED subnegotiation messages. It MAY optionally fully support the TTABLE-IS, TTABLE-ACK, and TTABLE-NAK messages. If it does fully support the TTABLE-IS message, it MUST also fully support the TTABLE-ACK and TTABLE-NAK messages. 👑
3. Default 🌸
The default is WON'T CHARSET and DON'T CHARSET. So nothing gets negotiated unless somebody actually asks for it. 🧚
WON'T CHARSETDON'T CHARSET4. Motivation for the Option 💖
Many TELNET sessions need to transmit data which is not in 7-bit ASCII. This is usually done by negotiating BINARY, and using local conventions (or terminal type kluges) to determine the character set of the data. However, such methods tend not to interoperate well, and have difficulties when multiple character sets need to be supported by different sessions. 🙃
Many computer systems now utilize a variety of character sets. Increasingly, a server computer needs to document character sets or translate transmissions and receptions using different pairs of character sets on a per-application or per-connection basis. This is becoming more common as client and server computers become more geographically disperse. (And as servers are consolidated into ever-larger hubs, serving ever-wider areas.) In order for files, databases, etc. to contain correct data, the server must determine the character set in which the user is sending, and the character set in which the application expects to receive. 🗺️
In some cases, it is sufficient to determine the character set of the end user (because every application on the server expects to use the same character set, or because applications can handle the user's character set), but in other cases different server applications expect to use different character sets. In the former case, an initial CHARSET subnegotiation suffices. In the latter case, the server may need to initiate additional CHARSET subnegotiations as the user switches between applications. 🔁
At a minimum, the option described in this memo allows both sides to be clear as to which character set is being used. A minimal implementation would have the server send DO CHARSET, and the client send WILL CHARSET and CHARSET REQUEST. The server could then communicate the client's character set to applications using whatever means are appropriate. Such a server might refuse subsequent CHARSET REQUEST messages from the client (if it lacked the ability to communicate changed character set information to applications, for example). Another system might have a method whereby various applications could communicate to the TELNET server their character set needs and abilities, which the server would handle by initiating new CHARSET REQUEST negotiations as appropriate. 🦋
In some cases, servers may have a large set of clients which tend to connect often (such as daily) and over a long period of time (such as years). The server administrators may strongly prefer that the servers not do character set translation (to save CPU cycles when serving very large numbers of users). To avoid manually configuring each copy of the user TELNET software, the administrators might prefer that the software supports translate tables. (If the client software received a translate table from the server and stored it, the table would only need to be sent once.) 🍓
5. Description of the Option 🦄
When the client TELNET program is able to determine the user's character set it should offer to specify the character set by sending IAC WILL CHARSET. 🫶
If the server system is able to make use of this information, it replies with IAC DO CHARSET. The client TELNET is then free to request a character set in a subnegotiation at any time. ✨
Likewise, when the server is able to determine the expected character set(s) of the user's application(s), it should send IAC DO CHARSET to request that the client system specify the character set it is using. Or the server could send IAC WILL CHARSET to offer to specify the character sets. 💜
Once a character set has been determined, the server can either perform the translation between the user and application character sets itself, or request by additional CHARSET subnegotiations that the client system do so. 🔥
Once it has been established that both sides are capable of character set negotiation (that is, each side has received either a WILL CHARSET or a DO CHARSET message, and has also sent either a DO CHARSET or a WILL CHARSET message), subnegotiations can be requested at any time by whichever side has sent a WILL CHARSET message and also received a DO CHARSET message (this may be either or both sides). Once a CHARSET subnegotiation has started, it must be completed before additional CHARSET subnegotiations can be started (there must never be more than one CHARSET subnegotiation active at any given time). When a subnegotiation has completed, additional subnegotiations can be started at any time. 🧠
If either side violates this rule and attempts to start a CHARSET subnegotiation while one is already active, the other side MUST reject the new subnegotiation by sending a CHARSET REJECTED message. 🚫
Receipt of a CHARSET REJECTED or TTABLE-REJECTED message terminates the subnegotiation, leaving the character set unchanged. Receipt of a CHARSET ACCEPTED or TTABLE-ACK message terminates the subnegotiation, with the new character set in force. 🌈
In some cases, both the server and the client systems are able to perform translations and to send and receive in the character set(s) expected by the other side. In such cases, either side can request that the other use the character set it prefers. When both sides simultaneously make such a request (send CHARSET REQUEST messages), the server MUST reject the client's request by sending a CHARSET REJECTED message. The client system MUST respond to the server's request. (See the CHARSET REQUEST description, above.) 🤝
When the client system makes the request first, and the server is able to handle the requested character set(s), but prefers that the client system instead use the server's (user application) character set, it may reject the request, and issue a CHARSET REQUEST of its own. If the client system is unable to comply with the server's preference and issues a CHARSET REJECTED message, the server can issue a new CHARSET REQUEST message for one of the previous character sets (one of those which the client system originally requested). The client system would obviously accept this character set. 🎯
While a CHARSET subnegotiation is in progress, data SHOULD be queued. Once the CHARSET subnegotiation has terminated, the data can be sent (in the correct character set). 📦
Note that regardless of CHARSET negotiation, translation only applies to text (not commands), and only occurs when in BINARY mode [4]. If not in BINARY mode, all data is assumed to be in NVT ASCII [1]. 📝
Also note that the CHARSET option should be used with the END OF RECORD option [5] for block-mode terminals in order to be clear on what character represents the end of each record. 🧾
As an example of character set negotiation, consider a user on a workstation using TELNET to communicate with a server. In this example, the workstation normally uses the Cyrillic (ASCII) character set [2] but is capable of using EBCDIC-Cyrillic [2], and the server normally uses EBCDIC-Cyrillic. The server could handle the (ASCII) Cyrillic character set, but prefers that instead the client system uses the EBCDIC-Cyrillic character set. (This and the following examples do not show the full syntax of the subnegotiation messages.) 🎬
CLIENT SERVER
WILL CHARSET WILL CHARSET
DO CHARSET DO CHARSET
CHARSET REQUEST Cyrillic
EBCDIC-Cyrillic
CHARSET ACCEPTED EBCDIC-
CyrillicNow consider a case where the workstation can't handle EBCDIC-Cyrillic, but can accept a translate table: 🙌
CLIENT SERVER
WILL CHARSET WILL CHARSET
DO CHARSET DO CHARSET
CHARSET REQUEST [TTABLE] 1
Cyrillic
CHARSET TTABLE-IS 1 Cyrillic
EBCDIC-Cyrillic
CHARSET TTABLE-ACKFor another example, consider a case similar to the previous case, but now the user switches server applications in the middle of the session (denoted by ellipses), and the new application requires a different character set: 🔄
CLIENT SERVER
WILL CHARSET WILL CHARSET
DO CHARSET DO CHARSET
CHARSET REQUEST [TTABLE] 1
Cyrillic EBCDIC-INT
CHARSET TTABLE-IS 1 Cyrillic
EBCDIC-Cyrillic
CHARSET TTABLE-ACK
. . . . . .6. Security Considerations 🔐
Okay bestie, the security section is short and sweet 🥺. Security issues are not discussed in this memo. That's it, that's the whole section 💅
7. References 📚
- [1] Postel, J. and J. Reynolds, "Telnet Protocol Specification", STD 8, RFC 854, ISI, May 1983.
- [2] Reynolds, J., and J. Postel, "Assigned Numbers", STD 2, RFC 1700, ISI, October 1994.
- [3] Postel, J. and J. Reynolds, "Telnet Option Specifications", STD 8, RFC 855, ISI, May 1983.
- [4] Postel, J. and J. Reynolds, "Telnet Binary Transmission", STD 27, RFC 856, ISI, May 1983.
- [5] Postel, J., "Telnet End-Of-Record Option", RFC 885, ISI, December 1983.
- [6] Postel, J., "Internet Official Protocol Standards", STD 1, RFC 1920, IAB, March 1996.
These are the receipts for everything this memo leans on, so they're all here, every single one 🫶
8. Author's Address 🎀
The author is Randall Gellens of Unisys Corporation, and here's how to reach him:
Randall Gellens
Unisys Corporation
25725 Jeronimo Road
Mail Stop 237
Mission Viejo, CA 92691
USA
Phone: +1.714.380.6350
Fax: +1.714.380.5912
EMail: Randy@MV.Unisys.ComLook at that, a whole real person with a real mailing address. Main character energy 🦋✨
📦 where this page comes from
- ietf: rfc2066 1997-01
- 💖 girlified by claude-haiku-5-5 on : a language model's rewrite of the original, under its terms