RFC 5256

Internet Message Access Protocol - SORT and THREAD Extensions

📅 published June 2008, from ietf

Title Block 🎀

This one is RFC 5256, Internet Message Access Protocol - SORT and THREAD Extensions, from June 2008. It's a Standards Track doc, written by M. Crispin (Panda Programming) and K. Murchison (Carnegie Mellon University). The header doesn't list anything it obsoletes or updates, so there's nothing to chase there 💅

Status of This Memo 📜

This document specifies an Internet standards track protocol for the Internet community, and asks for discussion and suggestions for improvements. For the standardization state and status of this protocol, check the current edition of the "Internet Official Protocol Standards" (STD 1). Distribution of this memo is unlimited 🌸

Abstract ✨

Okay so this doc describes the base-level, server-based sorting and threading extensions to IMAP 💖 These extensions give IMAP clients that show sorted and threaded views a seriously big performance boost. Iconic behavior, honestly 🔥

1. Introduction 🦋

The SORT and THREAD extensions to the [IMAP] protocol let the server do the sorting and threading of messages. The client doesn't have to download all the data to do it itself, which is why it's especially useful for online clients, as described in [IMAP-MODELS] 🫶

A server that supports the base-level SORT extension says so with a capability name that starts with "SORT". Future upwards-compatible extensions to SORT will also start with "SORT", which shows they're built on top of this base level 🧚

A server that supports the THREAD extension says so with one or more capability names made of "THREAD=" followed by a supported threading algorithm name, as described in this document. This leaves room for future upwards-compatible extensions too 💜

A server that implements SORT and/or THREAD MUST collate strings in accordance with the requirements of I18NLEVEL=1, as described in [IMAP-I18N]. It SHOULD also implement and advertise the I18NLEVEL=1 extension. Alternatively, a server MAY implement I18NLEVEL=2 (or higher) and follow the rules of that level 🌈

Discussion: SORT and THREAD are actually several years older than [IMAP-I18N]. When this was written, every known server implementation of SORT and THREAD followed the I18NLEVEL=1 rules, but they don't necessarily advertise it. As discussed in section 4.5 of [IMAP-I18N], all server implementations should eventually be updated to comply with I18NLEVEL=2 🙈

Historical note: the REFERENCES threading algorithm is based on the [THREADING] algorithm written and used in "Netscape Mail and News" versions 2.0 through 3.0. Throwback alert 🍓

2. Terminology 💅

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in [KEYWORDS]. These are the official requirement words, so pay attention to them 👑

The word "can" (not "may") refers to a possible circumstance or situation, as opposed to an optional facility of the protocol. Yes, the difference matters, bestie 🙈

"User" means a human user, whereas "client" means the software the user is running. Not the same thing, periodt ✨

In examples, "C:" and "S:" mark lines sent by the client and the server, respectively 🎀

2.1. Base Subject 🧁

Subject sorting and threading use the "base subject", which is the subject with certain subject artifacts stripped off. Those artifacts are complicated enough that the formal syntax for subject extraction rules is ambiguous, so this procedure is the way to find the "base subject". It uses the [ABNF] formal syntax rules described in section 5 💖

(1) Convert any RFC 2047 encoded-words in the subject to [UTF-8], as described in "Internationalization Considerations". Convert all tabs and continuations to space. Convert all multiple spaces to a single space.

(2) Remove all trailing text of the subject that matches the subj-trailer ABNF. Repeat until no more matches are possible.

(3) Remove all prefix text of the subject that matches the subj-leader ABNF.

(4) If there is prefix text of the subject that matches the subj-blob ABNF, and removing that prefix leaves a non-empty subj-base, then remove the prefix text.

(5) Repeat (3) and (4) until no matches remain.

Note: you can defer step (2) until step (6), but then step (4) has to check for subj-trailer.

(6) If the resulting text begins with the subj-fwd-hdr ABNF and ends with the subj-fwd-trl ABNF, remove the subj-fwd-hdr and subj-fwd-trl, and repeat from step (2).

(7) The resulting text is the "base subject" used in the SORT.

All servers and disconnected clients (as described in [IMAP-MODELS]) MUST use exactly this algorithm to determine the "base subject". If they didn't, a user could get inconsistent results depending on whether they're connected or disconnected. Nobody wants that drama 😭

2.2. Sent Date 📅

In this document, "sent date" means the date and time from the Date: header, adjusted by time zone and normalized to UTC. For example, "31 Dec 2000 16:01:33 -0800" is equivalent to the UTC date and time of "1 Jan 2001 00:01:33 +0000". Time zone math, but make it cute 🕰️

If the time zone is invalid, the date and time SHOULD be treated as UTC. If the time is also invalid, the time SHOULD be treated as 00:00:00. If there is no valid date or time, the date and time SHOULD be treated as 00:00:00 on the earliest possible date 🌙

This is different from the date-related criteria in the SEARCH command (described in section 6.4.4 of [IMAP]). Those only use the date, not the time, and they aren't adjusted by time zone. So don't mix them up, okay? 🙅‍♀️

If the sent date can't be determined (the Date: header is missing or can't be parsed), the INTERNALDATE for that message is used as the sent date 🧚

When two sent dates match exactly, the order the two messages appear in the mailbox (that is, by sequence number) is the tie-breaker that decides their order 🎀

3. Additional Commands 🧸

These commands are extensions to the [IMAP] base protocol 💜

The section headings are meant to line up with where they'd be in the main document if they were part of the base specification 🦋

BASE.6.4.SORT. SORT Command 🍒

Arguments:  sort program
            charset specification
            searching criteria (one or more)

Data:       untagged responses: SORT

Result:     OK - sort completed
            NO - sort error: can't sort that charset or
                 criteria
            BAD - command unknown or arguments invalid

The SORT command is a variant of SEARCH with sorting semantics for the results. Before the searching criteria argument there are two arguments: a parenthesized list of sort criteria, and the searching charset 💖

The charset argument is mandatory (unlike SEARCH). It shows the [CHARSET] of the strings in the searching criteria. The US-ASCII and [UTF-8] charsets MUST be implemented. All other charsets are optional 🌸

There's also a UID SORT command that returns unique identifiers instead of message sequence numbers. Heads up: UID SORT and SORT have separate searching criteria for message sequence numbers and UIDs, so the arguments to UID SORT are interpreted the same way as in SORT. This is like UID SEARCH, not like UID COPY, UID FETCH, or UID STORE 🙈

The SORT command first searches the mailbox for messages that match the given searching criteria, using the charset argument to interpret the strings in those criteria. Then it returns the matching messages in an untagged SORT response, sorted by one or more sort criteria ✨

Sorting is in ascending order. Earlier dates sort before later dates. Smaller sizes sort before larger sizes. Strings are sorted by the ascending values set by their collation algorithm (see "Internationalization Considerations") 🔥

If two or more messages exactly match on the sorting criteria, they're sorted by the order they appear in the mailbox. In other words, there's an implicit sort criterion of "sequence number" 🧁

When there are multiple sort criteria, the result is sorted in the priority order the criteria appear in. For example, (SUBJECT DATE) sorts messages by their base subject text first, and then, for messages with the same base subject text, by their sent date 💅

Untagged EXPUNGE responses are NOT permitted while the server is responding to a SORT command, but they ARE permitted during a UID SORT command. Wait, sorry, the original says "not permitted" and "permitted" so I'm keeping it plain: EXPUNGE is not permitted during SORT, but it is permitted during UID SORT 🙃

The defined sort criteria are below. Check the Formal Syntax section for the exact syntax of the arguments. If the associated RFC-822 header for a particular criterion is absent, it's treated as the empty string. The empty string always collates before non-empty strings 🫶

ARRIVAL Internal date and time of the message. This is different from the ON criteria in SEARCH, which only uses the internal date 📬

CC [IMAP] addr-mailbox of the first "cc" address 💌

DATE Sent date and time, as described in section 2.2 🗓️

FROM [IMAP] addr-mailbox of the first "From" address 📮

REVERSE Followed by another sort criterion, it has the effect of that criterion but in reverse (descending) order 🔄

Note: REVERSE only reverses a single criterion. It does NOT affect the implicit "sequence number" sort criterion if all the other criteria are identical. So REVERSE SUBJECT is not the same as a reverse ordering of a SUBJECT sort. You can avoid this by adding more criteria, e.g., SUBJECT DATE vs. REVERSE SUBJECT REVERSE DATE. In general, though, it's better (and faster, if the client has a "reverse current ordering" command) to reverse the results in the client instead of issuing a new SORT 🧠

SIZE Size of the message in octets 📏

SUBJECT Base subject text 🎀

TO [IMAP] addr-mailbox of the first "To" address 💜

Example:

C: A282 SORT (SUBJECT) UTF-8 SINCE 1-Feb-1994
S: * SORT 2 84 882
S: A282 OK SORT completed
C: A283 SORT (SUBJECT REVERSE DATE) UTF-8 ALL
S: * SORT 5 3 4 1 2
S: A283 OK SORT completed
C: A284 SORT (SUBJECT) US-ASCII TEXT "not in mailbox"
S: * SORT
S: A284 OK SORT completed

BASE.6.4.THREAD. THREAD Command 🧵

Arguments:  threading algorithm
            charset specification
            searching criteria (one or more)

Data:       untagged responses: THREAD

Result:     OK - thread completed
            NO - thread error: can't thread that charset or
                 criteria
            BAD - command unknown or arguments invalid

The THREAD command is a variant of SEARCH with threading semantics for the results. Before the searching criteria argument there are two arguments: a threading algorithm and the searching charset 🌈

There is also a UID THREAD command that returns unique identifiers instead of message sequence numbers 🦋. Heads up, though: searching criteria for message sequence numbers and UIDs are separate things, so the arguments to UID THREAD get interpreted the same way as in THREAD 🧠. This is giving the same vibe as UID SEARCH, not UID COPY, UID FETCH, or UID STORE 💅.

The THREAD command first searches the mailbox for messages that match the given searching criteria, using the charset argument to interpret strings in those criteria 🔍. Then it returns the matching messages in an untagged THREAD response, threaded according to the threading algorithm you picked 🧵✨.

All collation is in ascending order 📈. Earlier dates collate before later dates, and strings get collated by ascending values set by their collation algorithm (see "Internationalization Considerations") 🌍.

Untagged EXPUNGE responses are NOT permitted while the server is responding to a THREAD command 🙅‍♀️, but they ARE permitted during a UID THREAD command 💖.

Okay, the defined threading algorithms are next, and they're all so different bestie 🌸.

ORDEREDSUBJECT

The ORDEREDSUBJECT threading algorithm is also called "poor man's threading" 🥲💀. The searched messages get sorted by base subject and then by sent date. After that they're split into separate threads, where each thread holds messages with the same base subject text 🧶. Last step: the threads get sorted by the sent date of the first message in each thread 📅.

The top level, or "root," in ORDEREDSUBJECT threading holds the first message of every thread 👑. All messages in the root are siblings of each other 🫶. The second message of a thread is the child of the first message, and any later messages in the thread are siblings of the second message, which makes them children of the message at the root 🌳. So there are no grandchildren in ORDEREDSUBJECT threading 🙅‍♀️.

Children in ORDEREDSUBJECT threading do not have descendents 🌿. Client implementations SHOULD treat descendents of a child in a server response as being siblings of that child 💅.

REFERENCES

The REFERENCES threading algorithm is the main-character one 👑🔥. It threads the searched messages by grouping them into parent/child relationships based on which messages are replies to others 🧵💜. Those relationships get built two ways: by reconstructing a message's ancestry from the references inside it, and by checking the original (not base) subject of a message to see if it's a reply to, or a forward of, another message 🕵️‍♀️.

Note: "Message ID" in the following description refers to a normalized form of the msg-id in [RFC2822]. The actual text in RFC 2822 may use quoting, resulting in multiple ways of expressing the same Message ID. Implementations of the REFERENCES threading algorithm MUST normalize any msg-id in order to avoid false non-matches due to differences in quoting 🎀.

For example, the msg-id

<"01KF8JCEOCBS0045PS"@xxx.yyy.com>

and the msg-id

<01KF8JCEOCBS0045PS@xxx.yyy.com>

MUST be interpreted as being the same Message ID 🤯.

The references used for rebuilding a message's ancestry are found using these rules 🔎:

If a message contains a References header line, then use the Message IDs in the References header line as the references ✨.
If a message does not contain a References header line, or the References header line does not contain any valid Message IDs, then use the first (if any) valid Message ID found in the In-Reply-To header line as the only reference (parent) for this message 💌.

Note: Although [RFC2822] permits multiple Message IDs in the In-Reply-To header, in actual practice this discipline has not been followed 🙃. For example, In-Reply-To headers have been observed with message addresses after the Message ID, and there are no good heuristics for software to determine the difference. This is not a problem with the References header, however 🫠.

If a message does not contain an In-Reply-To header line, or the In-Reply-To header line does not contain a valid Message ID, then the message does not have any references (NIL) 🥀.

A message counts as a reply or forward if the base subject extraction rules, applied to the original subject, remove any of the following: a subj-refwd, a "(fwd)" subj-trailer, or a subj-fwd-hdr and subj-fwd-trl 📨💅.

The REFERENCES algorithm is WAY more complex than ORDEREDSUBJECT 😭. It has six main steps, and they're outlined in detail below 📋✨.

(1) For each searched message:
- (A) Using the Message IDs in the message's references, link the corresponding messages (those whose Message-ID header line contains the given reference Message ID) together as parent/child. Make the first reference the parent of the second (and the second a child of the first), the second the parent of the third (and the third a child of the second), etc. The following rules govern the creation of these links 🔗:
  - If a message does not contain a Message-ID header line, or the Message-ID header line does not contain a valid Message ID, then assign a unique Message ID to this message 🆔.
  - If two or more messages have the same Message ID, then only use that Message ID in the first (lowest sequence number) message, and assign a unique Message ID to each of the subsequent messages with a duplicate of that Message ID 👯‍♀️.
  - If no message can be found with a given Message ID, create a dummy message with this ID. Use this dummy message for all subsequent references to this ID 👻.
  - If a message already has a parent, don't change the existing link. This is done because the References header line may have been truncated by a Mail User Agent (MUA). As a result, there is no guarantee that the messages corresponding to adjacent Message IDs in the References header line are parent and child 🥺.
  - Do not create a parent/child link if creating that link would introduce a loop. For example, before making message A the parent of B, make sure that A is not a descendent of B 🔁🚫.

Note: Message ID comparisons are case-sensitive 🔠.

(B) Create a parent/child link between the last reference (or NIL if there are no references) and the current message. If the current message already has a parent, it is probably the result of a truncated References header line, so break the current parent/child link before creating the new correct one. As in step 1.A, do not create the parent/child link if creating that link would introduce a loop. Note that if this message has no references, it will now have no parent 💫.

Note: The parent/child links created in steps 1.A and 1.B MUST be kept consistent with one another at ALL times 🚨.

(2) Gather together all of the messages that have no parents and make them all children (siblings of one another) of a dummy parent (the "root"). These messages constitute the first (head) message of the threads created thus far 🌱.
(3) Prune dummy messages from the thread tree. Traverse each thread under the root, and for each message 🪓:
- If it is a dummy message with NO children, delete it.
- If it is a dummy message with children, delete it, but promote its children to the current level. In other words, splice them in with the dummy's siblings.
- Do not promote the children if doing so would make them children of the root, unless there is only one child 🙅‍♀️.
(4) Sort the messages under the root (top-level siblings only) by sent date as described in section 2.2. In the case of a dummy message, sort its children by sent date and then use the first child for the top-level sort 📅💖.
(5) Gather together messages under the root that have the same base subject text 🧺.
- (A) Create a table for associating base subjects with messages, called the subject table 📒.
- (B) Populate the subject table with one message per each base subject. For each child of the root:
  - (i) Find the subject of this thread, by using the base subject from either the current message or its first child if the current message is a dummy. This is the thread subject 🎯.
  - (ii) If the thread subject is empty, skip this message 🫥.
  - (iii) Look up the message associated with the thread subject in the subject table 🔎.
  - (iv) If there is no message in the subject table with the thread subject, add the current message and the thread subject to the subject table. Otherwise, if the message in the subject table is not a dummy, AND either of the following criteria are true:
    - The current message is a dummy, OR
    - The message in the subject table is a reply or forward and the current message is not.

then replace the message in the subject table with the current message 🔄.

(C) Merge threads with the same thread subject. For each child of the root:
- (i) Find the message's thread subject as in step 5.B.i above 🧭.
- (ii) If the thread subject is empty, skip this message 🌫️.
- (iii) Lookup the message associated with this thread subject in the subject table 🗂️.
- (iv) If the message in the subject table is the current message, skip this message 🙃.

Otherwise, merge the current message with the one in the subject table using the following rules 🫶:

If both messages are dummies, append the current message's children to the children of the message in the subject table (the children of both messages become siblings), and then delete the current message 💜.

If the message in the subject table is a dummy and the current message is not, make the current message a child of the message in the subject table (a sibling of its children) 🧚

If the current message is a reply or forward and the message in the subject table is not, make the current message a child of the message in the subject table (a sibling of its children) 💖

Otherwise, create a new dummy message and make both the current message and the message in the subject table children of the dummy. Then replace the message in the subject table with the dummy message 🎀

Note: Subject comparisons are case-insensitive, as described under "Internationalization Considerations" 🙈

(6) Okay, last step! ✨ Traverse the messages under the root and sort each set of siblings by sent date as described in section 2.2. Traverse the messages so that the "youngest" set of siblings gets sorted first, and the "oldest" set gets sorted last (grandchildren are sorted before children, etc). In the case of a dummy message (which can only occur with top-level siblings), use its first child for sorting 💅

Example:

               C: A283 THREAD ORDEREDSUBJECT UTF-8 SINCE 5-MAR-2000
               S: * THREAD (166)(167)(168)(169)(172)(170)(171)
                  (173)(174 (175)(176)(178)(181)(180))(179)(177
                  (183)(182)(188)(184)(185)(186)(187)(189))(190)
                  (191)(192)(193)(194 195)(196 (197)(198))(199)
                  (200 202)(201)(203)(204)(205)(206 207)(208)
               S: A283 OK THREAD completed
               C: A284 THREAD ORDEREDSUBJECT US-ASCII TEXT "gewp"
               S: * THREAD
               S: A284 OK THREAD completed
               C: A285 THREAD REFERENCES UTF-8 SINCE 5-MAR-2000
               S: * THREAD (166)(167)(168)(169)(172)((170)(179))
                  (171)(173)((174)(175)(176)(178)(181)(180))
                  ((177)(183)(182)(188 (184)(189))(185 186)(187))
                  (190)(191)(192)(193)((194)(195 196))(197 198)
                  (199)(200 202)(201)(203)(204)(205 206 207)(208)
               S: A285 OK THREAD completed

Note: The line breaks in the first and third server responses are for editorial clarity and do not appear in real THREAD responses. 🌸

4. Additional Responses 🦋

These responses are extensions to the [IMAP] base protocol 💜

The section headings of these responses are intended to correspond with where they would be located in the main document 🍓

BASE.7.2.SORT. SORT Response

Data: zero or more numbers

The SORT response happens when you send a SORT or UID SORT command 🔥 The number(s) refer to the messages that match your search criteria. For SORT, these are message sequence numbers; for UID SORT, these are unique identifiers. Each number is delimited by a space ✨

Example:

S: * SORT 2 3 6

BASE.7.2.THREAD. THREAD Response

Data: zero or more threads

The THREAD response shows up when you run a THREAD or UID THREAD command 💅 It contains zero or more threads, and a thread is a parenthesized list of thread members 🫶

Thread members are zero or more message numbers, separated by spaces, that show successive parent and child. This keeps going until the thread splits into multiple sub-threads. At that point the thread nests into sub-threads, and the first member of each sub-thread are siblings at that level. There is no limit to how deeply threads can nest 🌈

The message numbers refer to the messages that match your search criteria. For THREAD, these are message sequence numbers; for UID THREAD, these are unique identifiers 🧚

Example:

S: * THREAD (2)(3 6 (4 23)(44 7 96))

The first thread is only message 2. The second thread is messages 3 (parent) and 6 (child), and then it splits into two sub-threads. The first sub-thread has messages 4 (child of 6, sibling of 44) and 23 (child of 4). The second has messages 44 (child of 6, sibling of 4), 7 (child of 44), and 96 (child of 7). Since some later messages are parents of earlier messages, the messages were probably moved from some other mailbox at different times 👀

Example:

S: * THREAD ((3)(5))

In this example, 3 and 5 are siblings of a parent that does not match the search criteria (and/or does not exist in the mailbox). However, they are members of the same thread 💖

5. Formal Syntax of SORT and THREAD Commands and Responses ✨

The following syntax specification uses the Augmented Backus-Naur Form (ABNF) notation as specified in [ABNF]. It also uses [ABNF] rules defined in [IMAP] 🧠

sort            = ["UID" SP] "SORT" SP sort-criteria SP search-criteria

sort-criteria   = "(" sort-criterion *(SP sort-criterion) ")"

sort-criterion  = ["REVERSE" SP] sort-key

sort-key        = "ARRIVAL" / "CC" / "DATE" / "FROM" / "SIZE" /
                  "SUBJECT" / "TO"

thread          = ["UID" SP] "THREAD" SP thread-alg SP search-criteria

thread-alg      = "ORDEREDSUBJECT" / "REFERENCES" / thread-alg-ext

thread-alg-ext  = atom
                    ; New algorithms MUST be registered with IANA

search-criteria = charset 1*(SP search-key)

charset         = atom / quoted
                    ; CHARSET values MUST be registered with IANA

sort-data       = "SORT" *(SP nz-number)

thread-data     = "THREAD" [SP 1*thread-list]
thread-list     = "(" (thread-members / thread-nested) ")"

thread-members  = nz-number *(SP nz-number) [SP thread-nested]

thread-nested   = 2*thread-list

The following syntax describes base subject extraction rules (2)-(6):

subject         = *subj-leader [subj-middle] *subj-trailer

subj-refwd      = ("re" / ("fw" ["d"])) *WSP [subj-blob] ":"

subj-blob       = "[" *BLOBCHAR "]" *WSP

subj-fwd        = subj-fwd-hdr subject subj-fwd-trl

subj-fwd-hdr    = "[fwd:"

subj-fwd-trl    = "]"

subj-leader     = (*subj-blob subj-refwd) / WSP

subj-middle     = *subj-blob (subj-base / subj-fwd)
                    ; last subj-blob is subj-base if subj-base would
                    ; otherwise be empty

subj-trailer    = "(fwd)" / WSP

subj-base       = NONWSP *(*WSP NONWSP)
                    ; can be a subj-blob

BLOBCHAR        = %x01-5a / %x5c / %x5e-ff
                    ; any CHAR8 except '[' and ']'.
                    ; SHOULD comply with [UTF-8]

NONWSP          = %x01-08 / %x0a-1f / %x21-ff
                    ; any CHAR8 other than WSP.
                    ; SHOULD comply with [UTF-8]

6. Security Considerations 🔐

The SORT and THREAD extensions do not raise any security considerations that are not already present in the base [IMAP] protocol, and those issues are discussed in [IMAP]. Still, it's super important to remember that [IMAP] protocol transactions, including message data, are sent in the clear over the network unless protection from snooping is negotiated, either by using STARTTLS, privacy protection in AUTHENTICATE, or some other protection mechanism 😭

Although it's not a security consideration, it's important to know that sorting by REFERENCES can lead to misleading threading trees. For example, a message with false References: header data will cause a thread to be incorporated into another thread 💀

The process of extracting the base subject may lead to incorrect collation if the extracted data was significant text as opposed to a subject artifact 🙈

7. Internationalization Considerations 🌍

As the introduction said, the rules of I18NLEVEL=1 as described in [IMAP-I18N] MUST be followed. That means the SORT and THREAD extensions MUST collate strings according to the i;unicode-casemap collation described in [UNICASEMAP]. Servers SHOULD also advertise the I18NLEVEL=1 extension. Alternatively, a server MAY implement I18NLEVEL=2 (or higher) and comply with the rules of that level 🫶

As discussed in [IMAP-I18N] section 4.5, all server implementations should eventually be updated to support the [IMAP-I18N] I18NLEVEL=2 extension ✨

Translations of the "re" or "fw"/"fwd" tokens are not specified for removal in the base subject extraction process. Trying to add translated tokens would result in a geometrically complex, and ultimately unimplementable, task 😵‍💫

Instead, note that [RFC2822] section 3.6.5 recommends that "re:" (from the Latin "res", meaning "in the matter of") be used to identify a reply. Although there's clearly considerable variation in the multiple forms of token used to identify a forwarded message in the wild, the variations are (still) manageable. So it's suggested that "re:" and one of the variations of the tokens for a forward supported by the base subject extraction rules be adopted for Internet mail messages, since doing so makes it a simple display-time task to localize the token language for the user 🌸

8. IANA Considerations 📋

[IMAP] capabilities are registered by publishing a standards track or IESG-approved experimental RFC. This document constitutes registration of the SORT and THREAD capabilities in the [IMAP] capabilities registry 🦋

This document creates a new [IMAP] threading algorithms registry, which registers threading algorithms by publishing a standards track or IESG-approved experimental RFC. This document constitutes registration of the ORDEREDSUBJECT and REFERENCES algorithms in that registry 💜

9. Normative References 📚

[ABNF] Crocker, D., Ed., and P. Overell, "Augmented BNF for Syntax Specifications: ABNF", STD 68, RFC 5234, January 2008.
[CHARSET] Freed, N. and J. Postel, "IANA Charset Registration Procedures", BCP 19, RFC 2978, October 2000.
[IMAP] Crispin, M., "INTERNET MESSAGE ACCESS PROTOCOL - VERSION 4rev1", RFC 3501, March 2003.
[IMAP-I18N] Newman, C., Gulbrandsen, A., and A. Melnikov, "Internet Message Access Protocol Internationalization", RFC 5255, June 2008.
[KEYWORDS] Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, March 1997.
[RFC2822] Resnick, P., Ed., "Internet Message Format", RFC 2822, April 2001.
[UNICASEMAP] Crispin, M., "i;unicode-casemap - Simple Unicode Collation Algorithm", RFC 5051, October 2007.
[UTF-8] Yergeau, F., "UTF-8, a transformation format of ISO 10646", STD 63, RFC 3629, November 2003.

10. Informative References 💡

[IMAP-MODELS] Crispin, M., "Distributed Electronic Mail Models in IMAP4", RFC 1733, December 1994.
[THREADING] Zawinski, J. "Message Threading", http://www.jwz.org/doc/threading.html, 1997-2002.

Authors' Addresses ✨

Okay bestie, meet the two legends who wrote this 🫶 First up is Mark R. Crispin, over at Panda Programming 🐼

Mark R. Crispin
Panda Programming
6158 NE Lariat Loop
Bainbridge Island, WA 98110-2098

You can call him at +1 (206) 842-2385 📞 or email IMAP+SORT+THREAD@Lingling.Panda.COM 💌

Next is Kenneth Murchison from Carnegie Mellon University 🎓

Kenneth Murchison
Carnegie Mellon University
5000 Forbes Avenue
Cyert Hall 285
Pittsburgh, PA  15213

His phone is +1 (412) 268-2638 and his email is murch@andrew.cmu.edu 🌸

Full Copyright Statement 💖

The IETF Trust holds the copyright on this document, which is dated 2008 🌈 It's subject to the rights, licenses and restrictions in BCP 78, and apart from what that says, the authors keep all their own rights 📜

The document and everything in it come "AS IS" 😭 The contributor, the organization they represent or are sponsored by (if any), the Internet Society, the IETF Trust and the Internet Engineering Task Force all say there are no warranties, express or implied. That includes no promise that using the information won't infringe any rights, and no implied promise of merchantability or fitness for a particular purpose 🙈

Intellectual Property 🦋

The IETF doesn't take a side on whether any Intellectual Property Rights (or other rights someone might claim) are valid, or how far they reach, when it comes to building or using the technology in this document 🫠 It also doesn't say whether licenses for those rights are available, and it hasn't gone looking for them either. If you want the rules on rights in RFC documents, check out BCP 78 and BCP 79 📚

Copies of IPR disclosures sent to the IETF Secretariat are available, along with any promised licenses. You can also find the results of any attempt to get a general license or permission for implementers or users to use these proprietary rights in the IETF's online IPR repository at http://www.ietf.org/ipr 💅

The IETF also invites anyone to flag any copyrights, patents, patent applications or other proprietary rights that might cover technology needed to implement this standard 🧚 Send that info to the IETF at ietf-ipr@ietf.org 💜

📦 where this page comes from

ietf: rfc5256 2008-06
💖 girlified by claude-haiku-5-5 on 2026-10-17: a language model's rewrite of the original, under its terms