RFC 5482
TCP User Timeout Option
RFC 5482: TCP User Timeout Option 🎀
Network Working Group · Request for Comments: 5482 Category: Standards Track (an internet standards track protocol) 💖 Date: March 2009 🌸 Authors: L. Eggert (Nokia) and F. Gont (UTN/FRH) 🧚 Obsoletes / Updates: the title block doesn't list anything it obsoletes or updates 👀
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. 💅
Copyright Notice 🫶
Copyright (c) 2009 IETF Trust and the persons identified as the document authors. All rights reserved.
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents in effect on the date of publication of this document (http://trustee.ietf.org/license-info). Please review these documents carefully, because they describe your rights and restrictions with respect to this document. 📜
Abstract 🌈
The TCP user timeout controls how long transmitted data can stay unacknowledged before a connection gets forcefully closed. It's a local, per-connection parameter. This document introduces a new TCP option, the TCP User Timeout Option, which lets one end of a TCP connection announce its current user timeout value. That's basically a hint for the other end to adjust its own user timeout. Raising the user timeouts on both ends lets a connection survive long stretches without end-to-end connectivity. Lowering them lets busy servers tell their clients, "hey, I'll only hold your connection state for a short time if I lose connectivity." 🦋
Table of Contents 🌸
1. Introduction ....................................................2
2. Conventions .....................................................3
3. Operation .......................................................4
3.1. Changing the Local User Timeout ............................5
3.2. UTO Option Reliability .....................................8
3.3. Option Format ..............................................8
3.4. Reserved Option Values .....................................9
4. Interoperability Issues .........................................9
4.1. Middleboxes ................................................9
4.2. TCP Keep-Alives ...........................................10
5. Programming and Manageability Considerations ...................10
6. Security Considerations ........................................10
7. IANA Considerations ............................................12
8. Acknowledgments ................................................12
9. References .....................................................12
9.1. Normative References ......................................12
9.2. Informative References ....................................131. Introduction ✨
Okay so the Transmission Control Protocol (TCP) spec [RFC0793] defines a local, per-connection "user timeout" parameter. It's the maximum amount of time transmitted data can stay unacknowledged before TCP forcefully closes that connection. Apps can set and change it with OPEN and SEND calls. If an end-to-end connectivity disruption lasts longer than the user timeout, the sender gets zero acknowledgments for every transmission attempt, keep-alives included, and then the connection gets closed when the user timeout hits. Rude, but that's TCP. 💀
This document adds a new TCP option, the TCP User Timeout Option (UTO), which lets one end of a connection advertise its current user timeout value. It's advice for the other end to adapt its user timeout to match. TCP is still free to ignore the UTO advice if local policies say that's the move. 🙅♀️✨
Raising the user timeouts on both ends lets a connection survive extended periods without end-to-end connectivity. Lowering them lets busy servers explicitly tell their clients that they'll only maintain the connection state for a short time without connectivity. Main character energy, honestly. 👑
If no application sets a user timeout, the TCP spec [RFC0793] defines a default user timeout of 5 minutes. The Host Requirements RFC [RFC1122] refines this by introducing two thresholds, R1 and R2 (R2 > R1), that control how many retransmission attempts happen for a single segment. It suggests that TCP should notify applications when R1 is reached for a segment, and close the connection when R2 is reached. [RFC1122] also defines the recommended values: R1 is 3 retransmissions and R2 is 100 seconds. It also notes that R2 for SYN segments should be at least 3 minutes. Some TCP implementations go even more granular instead of having one single user timeout. For example, Solaris supports different timeouts depending on whether a connection is in the SYN-SENT, SYN-RECEIVED, or ESTABLISHED state [SOLARIS]. Very detailed, very iconic. 🔥
Here's the tea 🍵: some TCP implementations let apps set their local user timeout, but TCP has no in-protocol way to tell the other end about changes to it. So local changes don't really help a connection survive a long outage, because the other end still closes the connection once its user timeout runs out. Lowkey frustrating. 😭
Being able to tell the other end about your local user timeout could make TCP work better in situations that aren't well supported right now. One example is mobile hosts that change network attachment points. These hosts, maybe using Mobile IP [RFC3344], HIP [RFC4423], or transport-layer mobility mechanisms [TCP_MOB], are only intermittently connected to the Internet. Between connected periods they can go without end-to-end connectivity for a while. Other things that cause temporary disruptions include heavy congestion or link or routing failures inside the network. In these cases a host may not know exactly when or for how long a disruption will happen. It might still be able to predict that such events are more likely based on past mobility patterns, and then it can benefit from longer user timeouts. 🧠
Sometimes the timing and duration of a disruption is even predictable. For example, a node in space might lose connectivity when planetary bodies block its line of sight. The timing of those events may be computable from orbital mechanics. Space bestie energy 🚀🌌
2. Conventions 💅
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 [RFC2119]. Those are the official requirement words, so pay attention to them. 🎀
3. Operation 🦋
Okay, this is the part where it gets real. Using the TCP User Timeout Option can be either enabled on a per-connection basis, e.g., through an API option, or controlled by a system-wide setting. TCP keeps four per-connection state variables to run the UTO option. Three of them (ADV_UTO, ENABLED, and CHANGEABLE) are new. 🍓
USER_TIMEOUT: TCP's USER TIMEOUT parameter, as specified in [RFC0793].ADV_UTO: The UTO option advertised to the remote TCP peer. It's an application-specified value, and it may be specified on a system-wide basis. If it's unspecified, it defaults to the default system-wide USER TIMEOUT.ENABLED(Boolean): A flag that controls whether the UTO option is enabled for a connection. This flag applies to both sending and receiving. It defaults to false.CHANGEABLE(Boolean): A flag that controls whether USER_TIMEOUT (TCP's USER TIMEOUT parameter) may be changed based on a UTO option received from the other end of the connection. It defaults to true and becomes false when an application explicitly sets USER_TIMEOUT. 🔒
Important vibe check: an exchange of UTO options between both ends of a connection is NOT a binding negotiation. Sending a UTO option is just a suggestion for the other end to think about adapting its user timeout. That adaptation only happens if the other end has explicitly allowed it, meaning both ENABLED and CHANGEABLE are true. 🙅♀️
Before opening a connection, an app that wants the UTO option turns it on by setting ENABLED to true. It can pick a good local UTO by explicitly setting ADV_UTO. Otherwise, UTO is set to the default USER TIMEOUT value. Then the app should decide whether it will let the local USER TIMEOUT change based on UTO options received from the other end. The default is to allow that for connections without specific user timeout concerns. If an application explicitly sets USER_TIMEOUT, CHANGEABLE MUST become false, so UTO options from the other end can't override local application requests. Apps can also set or clear CHANGEABLE directly through API calls. Full control, periodt. 💖
Doing these steps before an active or passive open makes UTO options get exchanged in the SYN and SYN-ACK packets. That's a reliable way to exchange UTO values at the start, and to adapt to them if needed. TCP implementations MAY provide system-wide default settings for the ENABLED, ADV_UTO, and CHANGEABLE connection parameters. ⭐
Also, a connection that has enabled UTO options SHOULD include a UTO option in the first packet that doesn't have the SYN flag set, in addition to the SYN exchange. This helps keep the amount of state TCP has to store for connections in non-synchronized states small. It's especially handy when mechanisms like "SYN cookies" [RFC4987] are in use. There, a newly-established TCP connection can still benefit from the info the UTO option advertises, even if the UTO in the initial SYN segment wasn't recorded. Clever, right? 🧚
A host that supports the UTO option SHOULD include one in the next possible outgoing segment whenever it starts using a new user timeout for the connection. That lets the other end adapt its local user timeout to match. A TCP implementation that doesn't support the UTO option MUST silently ignore it [RFC1122], which keeps everything interoperable. No drama, just vibes. 🌈
Hosts MUST impose upper and lower limits on the user timeouts they use for a connection. Section 3.1 talks about user timeout limits and some potentially problematic effects of certain user timeout settings. Don't skip that bit, bestie. ⚠️
Heads up: TCP's option space is limited to 40 bytes. If other TCP options are already in use, they may eat all the available TCP option space, which would block the UTO option from this document. So TCP option space issues should be considered before enabling the UTO option. 🙈
Part 2 is coming up next, so stay tuned 🍓💜
3.1. Changing the Local User Timeout 💅
okay so when a host gets a TCP User Timeout Option, it has to decide whether to change the local user timeout for that connection 🫶 If the CHANGEABLE flag is false, USER_TIMEOUT MUST NOT be changed, no matter what the UTO option says. Without that rule the UTO option would be rewriting TCP's behavior, because an application's USER TIMEOUT could get overridden by whatever a peer asks for 😭 Even so, in that case TCP SHOULD still notify the application about the user timeout value it received from the other end system 🔔
In general, unless the application on the local host has asked for a specific USER TIMEOUT on the connection, CHANGEABLE will be true, and hosts SHOULD adjust the local TCP USER TIMEOUT (USER_TIMEOUT) when they get a UTO option, as the rest of this section explains ✨
The UTO option gives the user timeout in seconds or minutes, not in retransmissions or round-trip times (RTTs) 🦋 So hosts can swap timeout values anywhere from 1 second to over 9 hours at a granularity of seconds, or from 1 minute to over 22 days at a granularity of minutes. literally so many options 🌈
Very short USER TIMEOUT values can mess with TCP over high-delay paths 💀 If the user timeout runs out before the ACK for an outstanding segment shows up, maybe because a packet got lost, the connection closes. Lots of TCP implementations default to USER TIMEOUT values of a few minutes. The UTO option lets you suggest short timeouts, but applications that advertise them should think about these effects first 🙈
Long USER TIMEOUT values let hosts survive long stretches without end-to-end connectivity 🧚 The catch is that hosts then have to keep the TCP state for those connections around for a long time. Section 6 covers the security implications of long timeout values, so go read that too 👑
To protect against all of this, implementations MUST impose limits on the user timeout values they accept and use 🛡️ The rest of this section describes a RECOMMENDED scheme for limiting TCP's USER TIMEOUT using an upper limit and a lower limit 💖
Under the RECOMMENDED scheme, and when CHANGEABLE is true, each end SHOULD compute the local USER TIMEOUT for the connection with this formula 🎀
USER_TIMEOUT = min(U_LIMIT, max(ADV_UTO, REMOTE_UTO, L_LIMIT))Here's what each field means:
USER_TIMEOUT: the USER TIMEOUT value the local TCP adopts for this connection.U_LIMIT: the current upper limit that the local host puts on a connection's user timeout.ADV_UTO: the user timeout advertised to the remote TCP peer in a TCP User Timeout Option.REMOTE_UTO: the last user timeout value received from the other end in a TCP User Timeout Option.L_LIMIT: the current lower limit that the local host puts on a connection's user timeout.
The RECOMMENDED formula takes the larger of the two advertised values, adjusted for the configured upper and lower limits, and both ends use that for the connection's user timeout 🌸 The reason is that picking the bigger value lets the connection survive longer stretches without end-to-end connectivity. If the end that announced the smaller value did it to cut down on the TCP state it has to keep around, it can close or abort the connection whenever it likes 🍓
It must be noted that the two endpoints of the connection will not necessarily adopt the same user timeout 👀
Enforcing a lower limit (L_LIMIT) keeps connections from closing because of short-lived network problems, like temporary congestion, mobility hand-offs, and routing instabilities 🌈
An upper limit (U_LIMIT) can help reduce the effect of resource exhaustion attacks. Section 6 goes into the details of those attacks ⚠️
These limits MAY be system-wide constants, or they can be set at other granularities, such as per host, per user, per outgoing interface, or even per connection. And they don't have to stay fixed either: they MAY be a function of system resource utilization or attack status and could be adapted on the fly 🔥
The Host Requirements RFC [RFC1122] doesn't put any limit on the length of the user timeout. It does recommend an interval of at least 100 seconds, though. So when you follow the RECOMMENDED scheme in this section, the lower limit (L_LIMIT) SHOULD be set to at least 100 seconds 💅 Picking a user timeout smaller than the connection's current retransmission timeout (RTO) would probably get the connection aborted for no good reason 💀 That's why the lower limit (L_LIMIT) MUST be larger than the connection's current retransmission timeout (RTO). Fun fact: an upper limit can be placed on the RTO too, as long as it's at least 60 seconds [RFC2988] ✨
3.2. UTO Option Reliability 🎀
The TCP User Timeout Option is an advisory TCP option, which means it doesn't change how later segments get processed 🦋 Unlike other TCP options, it doesn't need to be exchanged reliably. So this specification doesn't define a reliability handshake for UTO option exchanges. If a segment carrying a UTO option gets lost, the other end just doesn't get the chance to update its local USER TIMEOUT 😭
Implementations MAY use local mechanisms to make delivery more reliable. Examples are retransmitting a UTO option whenever they retransmit the segment it originally rode in on, or "attaching" the option to a byte in the stream and retransmitting the option whenever that byte or its ACK gets retransmitted 🧚
Important to note: even though these mechanisms can make UTO option delivery more reliable, they don't guarantee it (you'd need a three-way handshake for that) 🙈 So implementations MUST NOT assume that UTO options are transmitted reliably 🚫
3.3. Option Format 🍓
Sending a TCP User Timeout Option tells the other end of the connection what the current local user timeout is, and suggests that the other end adjust its own user timeout to match 💖 The user timeout value in a UTO option is the ADV_UTO value that's expected to be adopted for TCP's USER TIMEOUT parameter during the synchronized states of a connection (ESTABLISHED, FIN-WAIT-1, FIN-WAIT-2, CLOSE-WAIT, CLOSING, or LAST-ACK). Connections in other states MUST use the default timeout values defined in [RFC0793] and [RFC1122] 👑
Here's the layout 👇
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Kind = 28 | Length = 4 |G| User Timeout |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+(One tick mark represents one bit.)
Figure 1: Format of the TCP User Timeout Option
Figure 1 is the format of the TCP User Timeout Option, and it has these fields 🌈
Kind(8 bits): This MUST be 28, which is the TCP option number [RFC0793] that IANA assigned (see Section 7) ✨Length(8 bits): The length of the TCP option in octets [RFC0793]. Its value MUST be 4 🎀Granularity(1 bit): The granularity bit, which says what unit the "User Timeout" field uses. When it's set (G = 1), the time interval in the "User Timeout" field MUST be interpreted as minutes. Otherwise (G = 0), the time interval in the "User Timeout" field MUST be interpreted as seconds 💅User Timeout(15 bits): The user timeout suggestion for this connection. It MUST be interpreted as a 15-bit unsigned integer. The unit (minutes or seconds) depends on the "G" field 🔥
3.4. Reserved Option Values 🌸
A TCP User Timeout Option with a "User Timeout" field of zero and a "Granularity" bit of either minutes (1) or seconds (0) is reserved for future use. Current TCP implementations MUST NOT send it, and MUST ignore it when they receive it 🙅♀️
4. Interoperability Issues 🦋
This section talks about the interoperability issues that come with introducing the TCP User Timeout Option 🫶
4.1. Middleboxes 🧚
A TCP implementation that doesn't support the TCP User Timeout Option MUST silently ignore it [RFC1122], which keeps everything interoperable ✨ Medina et al. studied how middleboxes affect transport protocols and showed that the vast majority of modern TCP stacks handle unknown TCP options correctly [MEDINA]. In that study, 3% of connections failed when an unknown TCP option showed up in the middle of a connection. Since the number of failures from unknown options is small, and they come from incorrectly implemented TCP stacks that break existing rules to ignore unknown options, they don't call for special measures. So this document doesn't define a way to negotiate support for the TCP User Timeout Option during the three-way handshake 🙄
Implementations may want to exchange UTO options on the very first data segments after the three-way handshake, to figure out whether a middlebox is sitting on the path. When segments carrying UTO options keep getting lost, an implementation should turn off UTO for the connection. When the connection itself gets reset, an implementation may be able to transparently re-establish another connection instance that doesn't use UTO, as long as no application data has been successfully exchanged yet 💖
Stateful firewalls usually time out connection state after a stretch of inactivity. If one of those firewalls is on the path, it may close or abort connections no matter whether the TCP User Timeout Option is used. In the future, firewalls like that might learn to parse the TCP User Timeout Option in unencrypted TCP segments and adjust their connection state management to match 🔮
4.2. TCP Keep-Alives 🌈
Some TCP implementations, like the ones in BSD systems, use a different abort policy for TCP keep-alives than for user data. So the TCP keep-alive mechanism might abort a connection that would otherwise have made it through a temporary lack of connectivity 😭 That's why, if a connection enables keep-alives and uses the TCP User Timeout Option, the keep-alive timer MUST be set to a value larger than the adopted USER TIMEOUT 👑
5. Programming and Manageability Considerations ✨
The IETF specification for TCP [RFC0793] includes a simple, abstract application programming interface (API). The API for the UTO extension in Section 3 is kept abstract in the same way 💅 TCP implementations usually provide more complex, feature-rich APIs, though. The "socket" API that started with BSD Unix and is now standardized by POSIX is one example [POSIX]. It's expected that TCP implementations that include the UTO extension will extend their API so applications can use and configure its parameters 🎀
The MIB objects defined in [RFC4022] and [RFC4898] let you manage TCP connections. It's expected that revisions to these documents will define objects for managing the UTO extension defined in this document 🌸
6. Security Considerations 🔐✨
Okay, bestie, lengthening user timeouts has some obvious security implications 🙈. Flooding attacks cause denial of service by forcing servers to commit resources to maintain the state of throw-away connections. Good news though: TCP implementations do not become more vulnerable to simple SYN flooding just because they implement the TCP User Timeout Option 💖. That's because user timeouts exchanged during the handshake only affect the synchronized states (ESTABLISHED, FIN-WAIT-1, FIN-WAIT-2, CLOSE-WAIT, CLOSING, LAST-ACK), and simple SYN floods never reach those states.
Now the plot twist 😭. When an attacker completes the three-way handshakes of its throw-away connections, it can amplify resource exhaustion attacks, because the attacked server has to keep the connection state for those throw-away connections for much longer. Since connection state sticks around longer, lower-frequency attack traffic (which may be harder to detect) can already make resource exhaustion worse.
Several approaches can help with this issue 🛡️. First, implementations can require prior peer authentication before accepting long user timeouts for a peer's connections. Options for that include IPsec [RFC4301] or TCP-MD5 [RFC2385]. (Implementors who decide to use TCP-MD5 for this purpose are encouraged to keep an eye on TCP-AO [AUTH_OPT], its designated successor, and to update their implementation once it's published as an RFC 👀.) A similar approach is for a host to start accepting long user timeouts for an established connection only after in-band authentication has happened. For example, that could be after a TLS handshake across the connection has succeeded [RFC5246]. These are arguably the most complete solutions, but they depend on external mechanisms to establish a trust relationship, so they aren't a free pass 💅.
A second option that doesn't depend on external mechanisms would be a per-peer limit on the number of connections that may use increased user timeouts. There are a few variants of this, such as fixed limits, or shortening the accepted user timeouts as the number of connections rises. This option doesn't eliminate resource exhaustion attacks from a single peer, but it can limit their effects 🦋. Reducing the number of high-UTO connections a server supports during an attack turns that attack into a denial-of-service attack against the service of high-UTO connections, so it's a trade-off.
Per-peer limits can't protect against distributed denial-of-service attacks, where multiple clients coordinate a resource exhaustion attack that uses long user timeouts 😵. To guard against those, TCP implementations could reduce the duration of accepted user timeouts as resource utilization goes up.
TCP implementations under attack may be forced to shed load by resetting established connections. Some load-shedding heuristics, like resetting connections with long idle times first, can hurt service for intermittently connected, trusted peers that have suggested long user timeouts 🥺. On the other hand, resetting connections to untrusted peers that use long user timeouts may be effective. In general, using the peers' level of trust as a parameter in the load-shedding decision may be useful 🧚. Also, if TCP needs to close or abort connections with a long TCP User Timeout Option to shed load, those connections are still no worse off than they would have been without the option.
Finally, the upper and lower limits on user timeouts, discussed in Section 3.1, can be an effective tool for limiting the impact of these sorts of attacks 🌸.
7. IANA Considerations 📋
This section is to be interpreted according to [RFC5226].
This document doesn't define any new namespaces. IANA has allocated a new 8-bit TCP option number (28) for the UTO option from the "TCP Option Kind Numbers" registry, which is maintained at http://www.iana.org. 🎀
8. Acknowledgments 💜
The following people have improved this document through thoughtful suggestions, and I'm literally so grateful 🫶: Mark Allman, Caitlin Bestler, David Borman, Bob Braden, Scott Brim, Marcus Brunner, Wesley Eddy, Gorry Fairhurst, Abolade Gbadegesin, Ted Faber, Guillermo Gont, Tom Henderson, Joseph Ishac, Jeremy Harris, Alfred Hoenes, Phil Karn, Michael Kerrisk, Dan Krejsa, Jamshid Mahdavi, Kostas Pentikousis, Juergen Quittek, Anantha Ramaiah, Joe Touch, Stefan Schmid, Simon Schuetz, Tim Shepard, and Martin Stiemerling.
Lars Eggert is partly funded by [TRILOGY], a research project supported by the European Commission under its Seventh Framework Program 🇪🇺.
Fernando Gont wishes to thank Secretaria de Extension Universitaria at Universidad Tecnologica Nacional and Universidad Tecnologica Nacional/Facultad Regional Haedo for supporting him in this work 🌈.
9. References 📚
9.1. Normative References
[RFC0793] Postel, J., "Transmission Control Protocol", STD 7,
RFC 793, September 1981.
[RFC1122] Braden, R., "Requirements for Internet Hosts -
Communication Layers", STD 3, RFC 1122, October 1989.
[RFC2119] Bradner, S., "Key words for use in RFCs to Indicate
Requirement Levels", BCP 14, RFC 2119, March 1997.
[RFC5226] Narten, T. and H. Alvestrand, "Guidelines for Writing an
IANA Considerations Section in RFCs", BCP 26, RFC 5226,
May 2008.9.2. Informative References
[AUTH_OPT] Touch, J., Mankin, A., and R. Bonica, "The TCP
Authentication Option", Work in Progress, November 2008.
[MEDINA] Medina, A., Allman, M., and S. Floyd, "Measuring
Interactions Between Transport Protocols and
Middleboxes", Proc. 4th ACM SIGCOMM/USENIX Conference on
Internet Measurement, October 2004.
[POSIX] IEEE Std. 1003.1-2001, "Standard for Information
Technology - Portable Operating System Interface
(POSIX)", Open Group Technical Standard: Base
Specifications Issue 6, ISO/IEC 9945:2002, December 2001.
[RFC2385] Heffernan, A., "Protection of BGP Sessions via the TCP
MD5 Signature Option", RFC 2385, August 1998.
[RFC2988] Paxson, V. and M. Allman, "Computing TCP's Retransmission
Timer", RFC 2988, November 2000.
[RFC3344] Perkins, C., "IP Mobility Support for IPv4", RFC 3344,
August 2002.
[RFC4022] Raghunarayan, R., "Management Information Base for the
Transmission Control Protocol (TCP)", RFC 4022,
March 2005.
[RFC4301] Kent, S. and K. Seo, "Security Architecture for the
Internet Protocol", RFC 4301, December 2005.
[RFC4423] Moskowitz, R. and P. Nikander, "Host Identity Protocol
(HIP) Architecture", RFC 4423, May 2006.
[RFC4898] Mathis, M., Heffner, J., and R. Raghunarayan, "TCP
Extended Statistics MIB", RFC 4898, May 2007.
[RFC4987] Eddy, W., "TCP SYN Flooding Attacks and Common
Mitigations", RFC 4987, August 2007.
[RFC5246] Dierks, T. and E. Rescorla, "The Transport Layer Security
(TLS) Protocol Version 1.2", RFC 5246, August 2008.
[SOLARIS] Sun Microsystems, "Solaris Tunable Parameters Reference
Manual", Part No. 806-7009-10, 2002.
[TCP_MOB] Eddy, W., "Mobility Support For TCP", Work in Progress,
April 2004.
[TRILOGY] "Trilogy Project", `<http://www.trilogy-project.org/>`.Authors' Addresses 🖊️
Lars Eggert
Nokia Research Center
P.O. Box 407
Nokia Group 00045
Finland
Phone: +358 50 48 24461
EMail: lars.eggert@nokia.com
URI: http://research.nokia.com/people/lars_eggert/
Fernando Gont
Universidad Tecnologica Nacional / Facultad Regional Haedo
Evaristo Carriego 2644
Haedo, Provincia de Buenos Aires 1706
Argentina
Phone: +54 11 4650 8472
EMail: fernando@gont.com.ar
URI: http://www.gont.com.ar/📦 where this page comes from
- ietf: rfc5482 2009-03
- 💖 girlified by claude-haiku-5-5 on : a language model's rewrite of the original, under its terms