RFC 9869

Datagram Packetization Layer Path MTU Discovery (DPLPMTUD) for UDP Options

📅 published October 2025, from ietf

Datagram Packetization Layer Path MTU Discovery (DPLPMTUD) for UDP Options 🎀

okay bestie, this is RFC 9869 💖 It's a Standards Track doc from the IETF, published October 2025, with ISSN 2070-1721. The authors are G. Fairhurst and T. Jones, both from the University of Aberdeen 🦋 The header doesn't list any "Obsoletes" or "Updates" RFCs, so it isn't replacing or patching anything else.

Abstract ✨

ok so this doc explains how a UDP Options sender builds Datagram Packetization Layer Path MTU Discovery (DPLPMTUD), which is a super robust way to do Path MTU Discovery (PMTUD) 💅 It runs on the UDP Options packetization layer and lets an app find the biggest datagram that can get across a network path. It also lets the app keep checking the current Maximum Packet Size (MPS) for that path and update it when things change 🌸

Status of This Memo 📜

this is an Internet Standards Track document 🌈

It's a product of the Internet Engineering Task Force (IETF), so it reflects what the IETF community agreed on. It got public review and was approved for publication by the Internet Engineering Steering Group (IESG). If you want more about Internet Standards, check Section 2 of RFC 7841 ✨

For the current status, any errata, and how to send feedback, go to https://www.rfc-editor.org/info/rfc9869 🫶

Copyright Notice ©️

This doc is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents, which you can find at https://trustee.ietf.org/license-info (the version in effect on the publication date). Please read those carefully, because they spell out your rights and restrictions for this document. Any Code Components pulled out of this document have to include Revised BSD License text, as described in Section 4.e of the Trust Legal Provisions, and they come with no warranty, as described in the Revised BSD License 📝

Table of Contents 🗂️

   1.  Introduction
   2.  Terminology
   3.  DPLPMTUD for UDP Options
     3.1.  Packet Formats
     3.2.  Sending Probe Packets with the Request Option
     3.3.  Receiving UDP Options Probe Packets and Sending the RES
           Option
   4.  DPLPMTUD Sender Procedures for UDP Options
     4.1.  Confirmation of Connectivity Across a Path
     4.2.  Sending Probe Packets to Increase the PLPMTU
     4.3.  Validating the Path with UDP Options
     4.4.  Probe Packets That Do Not Include Application Data
     4.5.  Probe Packets That Include Application Data
   5.  Receiving Events from the Network
     5.1.  Changes in the Path
     5.2.  Validation of PTB Messages
   6.  Examples with Different Receiver Behaviors
   7.  IANA Considerations
   8.  Security Considerations
   9.  References
     9.1.  Normative References
     9.2.  Informative References
   Acknowledgements
   Authors' Addresses

1. Introduction ✨

okay so UDP [RFC0768] is a minimal transport service that sits on top of IP, and lots of other protocols are built on it 🦋 Section 3.2 of UDP Guidelines [RFC8085] basically says apps should do some form of PMTUD so they don't end up generating IP fragments 💅 Here's the exact quote:

Consequently, an application SHOULD either use the path MTU information provided by the IP layer or implement Path MTU Discovery (PMTUD) itself [RFC1191] [RFC1981] [RFC4821] to determine whether the path to a destination will support its desired message size without fragmentation.

The UDP API [RFC8304] gives apps calls to receive ICMP Packet Too Big (PTB) messages and to control the max size of the datagrams they send 🌸 But it doesn't have any automatic way for an app to find out the MPS a path supports. So Upper Layer protocols, including apps, can build PMTUD mechanisms on top of the UDP API 🎀

Packetization Layer Path MTU Discovery (PLPMTUD) [RFC4821] describes how a bidirectional Packetization Layer (PL) can search for the largest Packetization Layer PMTU (PLPMTU) that a path supports 🧚 DPLPMTUD [RFC8899] brings that to datagram transports. Both are more robust because they use probing that doesn't rely only on ICMP PTB messages, so they still work on paths that drop those messages 💖

UDP Options [RFC9868] provides the functionality to run DPLPMTUD either inside the transport service or in an Upper Layer protocol (apps included) that uses UDP Options. This document explains how DPLPMTUD with UDP Options gets implemented (Section 6.1 of [RFC8899]), and it requires support to be turned on at both the sender and the receiver 🫶

Doing DPLPMTUD inside the transport service above UDP Options means each Upper Layer protocol doesn't have to build its own version 🙌 It gives apps a standard way to find the current MPS for a path and notice when it changes ✨ It works with Equal-Cost Multipath (ECMP) routing and/or multihoming 🌈 If multipath or multihoming is supported, each path needs its own state machine 👑

DPLPMTUD isn't specified for multicast 🙈 The method depends on explicit acknowledgement of probe packets, which UDP Options provides, and it's mainly meant for unicast (see Section 23 of [RFC9868]) 💅

2. Terminology 📖

key word check, bestie 💜 The words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document get read as described in BCP 14 [RFC2119] [RFC8174], but only when they show up in ALL CAPITALS, like right here 🎀

This document uses the terms defined for DPLPMTUD (Sections 2 and 5 of [RFC8899]) 🧠

3. DPLPMTUD for UDP Options 🦋

ok this is where it gets juicy 🔥 A UDP Options sender doing DPLPMTUD follows the method in [RFC8899]. In this spec, DPLPMTUD is done with a pair of UDP Options: the Request (REQ) Option and the Response (RES) Option (Section 11.7 of [RFC9868]) 🎀 The method also uses the End of Options List (EOL) Option (Section 11.1 of [RFC9868]) to add padding and set how big a probe packet is 🧚

Use of DPLPMTUD MUST be explicitly enabled by the application, for example once the app has connectivity and is ready to swap data with the remote Upper Layer protocol 🔐 Similarly, a DPLPMTUD receiver MUST NOT respond to a UDP REQ Option until DPLPMTUD has been enabled. This helps protect against people misusing the mechanism for other kinds of probing 🙅‍♀️

Probe packets use up network capacity and cost endpoint processing (Section 4.1 of [RFC8899]) 💀 So implementations ought to send a probe packet with a UDP REQ Option only when their local DPLPMTUD state machine needs it: when confirming the base PMTU for the path, probing to increase the PLPMTU, or confirming the current PLPMTU 🌸

There are two ways DPLPMTUD can run over UDP Options:

Implementation within the UDP transport service.
Implementation in an Upper Layer protocol (or application) that uses UDP Options.

When DPLPMTUD lives inside the UDP transport service, the DPLPMTUD state machine handles sending probe packets to find a PLPMTU, the way this document describes ✨ That gives you an MPS, which is the largest size of application data block that can go across a network path in a single datagram 💖 The Upper Layer protocol decides when a session turns DPLPMTUD on 👑

The discovered PLPMTU can then be used to either:

set the maximum datagram size for the current path, or
set the maximum fragment size when a sender uses the UDP Fragmentation Option to split a datagram into several UDP fragments for sending. Each UDP fragment is then less than or equal to the size of the largest IP packet found to be receivable across the current path 🦋

Here's a figure showing DPLPMTUD running inside the UDP transport service, with the key interactions between the layers 📊 This design needs an API primitive so the app can control whether the DPLPMTUD state machine is on for a specific UDP port. By default, this API MUST disable DPLPMTUD processing 🙅‍♀️

   +--------------------------------+
   |      Upper Layer Protocol      |
   |         or Application         |
   +---------------------------+----+
       ^                       | Messages (with UDP Options)
       | receive         send  v Primitives for MPS, Min_PMTU, etc.
   +---+----------------------------+
   | DPLPMTUD State Machine         |
   |   Maximum Packet Size (MPS)    |
   |   PLPMTU, Probed-Size, Min_PMTU|
   |   Token Values & Probes, etc.  |
   +---------------------------+----+
       ^                       | Messages (with UDP Options)
       |                       |   Send/Receive: Probes with Options
       | receive         send  v   Events: ICMP, Interface MTU, etc.
   +---+----------------------------+
   | UDP Options Transport          |
   +---------------------------+----+
       ^                       | Datagrams (with UDP Options)
       |                       |   Fragmented Datagrams with UDP Options
       | receive         send  v   Events: ICMP, Interface MTU, etc.

ok quick side note 👀 UDP lets an Upper Layer protocol send datagrams with or without payload data, and with or without UDP Options. These get delivered across the network to the remote Upper Layer. When DPLPMTUD runs inside the UDP transport service, probe packets carrying a REQ or RES UDP Option can be sent with no UDP payload. Those probes weren't made by a sending app, so the matching received datagrams don't get delivered to the remote app 🫶

When an Upper Layer protocol does DPLPMTUD instead, that protocol decides the format and content of the probe packets 🧚 That design is also allowed to use the REQ and RES Options that UDP Options provides 💜

If DPLPMTUD is active at more than one layer, the token values in REQ Options need to be coordinated with any values used by other DPLPMTUD probe packets, so every probe packet can be identified by a unique token 🔍 When it's configurable, a configuration ought to avoid doing this discovery both inside UDP Options and also in an Upper Layer protocol that sends and receives probe packets through UDP Options 🙈 And [RFC8899] Section 6.1 recommends this exact thing:

An application SHOULD avoid using DPLPMTUD when the underlying transport system provides this capability.

Part 1 of 3 is done, bestie 🎀 Next up are the sender procedures, the packet formats, and the big examples, so stay tuned 💅✨

3.1. Packet Formats 📦

Okay so the UDP Options we use in this doc are defined in [RFC9868], and here's how each one shows up ✨

The REQ Option is set by a sending PL to ask a remote receiver for a response 🙋‍♀️ Each request gets its own four-byte (four-octet) token so you can tell them apart.
A sending PL can use the EOL Option together with a minimum datagram length to pad probe packets 🎀
The RES Option is sent by a UDP Options receiver in reply to a REQ Option it got before. Each RES echoes the last four-byte token it received 💌
If a UDP Options endpoint makes and sends a datagram with a RES Option only because it got a REQ Option, the responder MUST limit the rate of these responses (e.g., limiting each pair of ports to send 1 per measured RTT or 1 per second). This rate limit is there to deal with the DoS vector without seriously messing up DPLPMTUD 🛡️ Section 6 has an example of when this might be used.
When the REQ sender gets a RES Option back, that confirms a specific probe packet made it to the remote UDP Options receiver 🥳

Okay so the token is how a UDP Options sender tells apart the acks for its first probe packets from the acks confirming later probes (like ones zooming along a different path with a bigger RTT) 🧠 Each probe packet MUST be uniquely identifiable by the UDP Options sender within the Maximum Segment Lifetime (MSL) [RFC8085]. The UDP Options sender MUST NOT reuse a token value within the MSL. Four bytes for the token field is plenty of room for multiple unique probe packets within the MSL, no cap 💅 And since UDP Options runs over UDP, the token values only have to be unique for the specific 5-tuple it's using. Iconic efficiency.

The four-byte token field SHOULD be initialized to a randomized value to level up protection from off-path attacks, as described in Section 5.1 of [RFC8085]. Protect your tokens, bestie 🔐

3.2. Sending Probe Packets with the Request Option 🚀

DPLPMTUD relies on sending a probe packet of a specific size 📏 Each probe packet includes the UDP Options area, which holds a REQ Option and any other required options, ending with an EOL Option (Section 11.1 of [RFC9868]). Then it gets any padding needed to inflate it to the required probe size 🎈

So a probe packet can be as big as the largest size the local interface supports (aka the Interface MTU) 🌈 Item 2 in Section 3 of [RFC8899] requires the network interface below DPLPMTUD to offer a way to send a probe packet that's bigger than the current PLPMTU. The size of this probe packet MUST NOT be constrained by the maximum PMTU set by network layer mechanisms (like the one discovered by PMTUD [RFC1191][RFC8201] or the PMTU size kept in the IP-layer cache), as noted in item 2 in Section 3 of [RFC8899]). Not letting the network layer boss it around 💁‍♀️

UDP datagrams used as DPLPMTUD probe packets, as described here, MUST NOT be fragmented at the UDP or IP layer. So Section 3 of [RFC8899] says: "In IPv4, a probe packet MUST be sent with the Don't Fragment (DF) bit set in the IP header and without network layer endpoint fragmentation." No fragmenting, periodt 🙅‍♀️

3.3. Receiving UDP Options Probe Packets and Sending the RES Option 📬

When DPLPMTUD is turned on, a UDP Options receiver responds by sending a UDP datagram with the RES Option whenever it gets a UDP Options datagram with the REQ Option 💌

How DPLPMTUD behaves can depend on whether the remote UDP Options endpoint supports it, how DPLPMTUD got implemented, and sometimes the application data being exchanged over the UDP transport service 🤷‍♀️ If the remote receiver doesn't support UDP Options, DPLPMTUD can't confirm the path or find the PLPMTU. That leaves you stuck at the minimum configured PLPMTU (MIN_PLPMTU) 😭 More on how to use all this is in Section 6.

Heads up, bestie 💅 A receiver that only responds when there's a datagram queued for transmission by the Upper Layer could end up getting multiple datagrams with a REQ Option before it replies. When it does send a RES Option, that only acknowledges the latest token it received. So the sender would conclude that the earlier REQ Options never got through. BUT, DPLPMTUD doesn't usually send more than one probe packet per timeout interval, and a late reply already counts as a failed probe attempt. So it doesn't really hurt performance. Still, a more prompt response would let DPLPMTUD record that every probe packet arrived 🧚

4. DPLPMTUD Sender Procedures for UDP Options 👑

DPLPMTUD uses three types of probe, and they're covered in the sections below ✨

Probes to confirm the path can support the BASE_PLPMTU (Section 5.1.4 of [RFC8899]).
Probes to detect whether the path can support a larger PLPMTU.
Probes to validate that the path supports the current PLPMTU.

4.1. Confirmation of Connectivity Across a Path 🔗

DPLPMTUD needs a PL to confirm connectivity over the path (Section 5.1.4 of [RFC8899]), but UDP doesn't offer any mechanism for this, sad but true 😔

Good news though: UDP Options can provide this! A UDP Options sender implementing this specification MUST get a positive confirmation of connectivity for the path by sending a probe packet padded to size BASE_PLPMTU. This confirmation probe MUST include the REQ UDP Option so it can elicit a response from the remote DPLPMTUD. Getting a datagram with the matching RES Option confirms that a packet of the probed size made it across the path to the receiver. It also confirms that the remote endpoint supports the RES Option. Main character energy 🎀

4.2. Sending Probe Packets to Increase the PLPMTU 📈

Every so often, DPLPMTUD enters the SEARCHING state, described in Section 5.2 of [RFC8899] (e.g., after the PMTU_RAISE_TIMER expires), to check whether the current path can handle a bigger PLPMTU 🔍 When the remote endpoint advertises a UDP Maximum Datagram Size (MDS) Option (see Section 11.5 of [RFC9868]), that value MAY be used as a hint to start this search for a bigger PLPMTU.

Probe packets trying to increase the PLPMTU SHOULD NOT carry application data (see "Probing using padding data" in Section 4.1 of [RFC8899]), since they'll get lost whenever their size goes over the actual PMTU 💀 [RFC8899] requires a probe packet to elicit a positive acknowledgement that the path delivered a datagram of the specific probed size. So a probe packet MUST include the REQ Option when using transport options for UDP [RFC9868]. Non-negotiable 🫶

At the receiver, a probe packet that doesn't carry application data isn't part of the end-to-end transport data, so it doesn't get delivered to the Upper Layer protocol (i.e., the application or whatever protocol sits above UDP) 🙈 A zero-length payload notification could still be delivered to the application (see Section 5 of [RFC8085]), although Section 18 of [RFC9868] talks about what happens when you use UDP Options.

4.3. Validating the Path with UDP Options ✅

A PL using DPLPMTUD MUST validate that a path still supports the PLPMTU found in an earlier search for a suitable PLPMTU value, as defined in Section 6.1.4 of [RFC8899]. This validation sends probe packets in the DPLPMTUD SEARCH_COMPLETE state (Section 5.2 of [RFC8899]) to detect black-holing of data (Section 4.3 of [RFC8899] defines a DPLPMTUD black hole). Checking for black holes, the responsible way 🕵️‍♀️

Path validation can be done within UDP Options by generating a probe packet of size PLPMTU, which MUST include a REQ Option so it can elicit a positive confirmation that the path delivered this probe packet 🎯 A probe packet used to validate the path MAY use either "Probing using padding data" to build a probe packet with no application data, or "Probing using application data and padding data"; see Section 4.1 of [RFC8899]. When you use "Probing using padding data", the UDP Options API doesn't indicate receipt of the zero-length probe packet (see Section 6 of [RFC9868]). Fair warning, that one's a little sneaky 👀

4.4. Probe Packets That Do Not Include Application Data 🫧

A simple implementation of the method might only use probe packets in a UDP datagram that has no application data in it 🍓 The size of each probe packet gets padded to the required probe size, including the REQ Option. This is "Probing using padding data" (Section 4.1 of [RFC8899]), and it avoids having to retransmit application data when a probe fails, which is honestly such a relief 😌 You could do this by setting a minimum datagram length so the options list ends in EOL (Section 11.1 of [RFC9868]), with any extra space zero-filled as needed (see Section 15 of [RFC9868]). In this setup, the probe packets aren't part of the end-to-end transport data, and the receiver doesn't deliver them to the Upper Layer protocol 🦋

4.5. Probe Packets That Include Application Data 💜

An implementation always uses the format in Section 4.4 when DPLPMTUD searches to increase the PLPMTU 🧱

An alternative format is permitted for a probe packet that's used to confirm connectivity or validate the path. These probe packets MAY carry application data. (UDP payload data is allowed because these probe packets do black-hole detection and will therefore usually have a higher chance of getting through, similar to other packets the Upper Layer protocol sends.) Section 4.1 of [RFC8899] talks through the merits and demerits of including application data. For example, it cuts down on how many extra datagrams need to be sent ✨

This type of probe packet MAY use a control message format defined by the Upper Layer protocol, as long as the message doesn't need to be delivered reliably. The REQ Option MUST be included when the sending Upper Layer protocol performs DPLPMTUD. The DPLPMTUD method tracks the transmission of probe packets using the REQ Option token 🎟️

A receiver that responds to DPLPMTUD MUST process the REQ Option and include the corresponding RES Option with an Upper Layer protocol message that it sends back to the requester (examples of receiver processing are in Section 6) 🎁

Probe packets in this format form a part of the end-to-end transport data and can be used to manage the PLPMTU in just one direction, or in both directions 🔁

5. Receiving Events from the Network 🌸

This specification doesn't rely on receiving events from the network, but an implementation can use these events when they're provided 💖

5.1. Changes in the Path 🦋

okay so a change in the path, or losing a probe packet, can make DPLPMTUD update the PLPMTU ✨ DPLPMTUD [RFC8899] recommends that methods are robust to path changes that could have happened since the path characteristics were last confirmed, and to the possibility of inconsistent path info showing up. For example, a notification that the path has changed could trigger path validation to give you black-hole protection (Section 4.3 of [RFC8899]) 🫶

An Upper Layer protocol could trigger DPLPMTUD to validate the path when it notices a high packet loss rate (or a repeated protocol timeout) [RFC8899] 👀

Section 3 of [RFC8899] requires any methods designed to share the PLPMTU between PLs (like updating the IP cache PMTU for an interface/destination) to be robust to the wide variety of underlying network forwarding behaviors 🌈 For example, an implementation could avoid sharing PMTU info that could potentially relate to packets sent with the same address over a different interface. Not sharing is the move here, bestie 💅

5.2. Validation of PTB Messages 🔍

Support for receiving ICMP PTB messages is OPTIONAL for DPLPMTUD 🎀 So a UDP Options sender can totally ignore received ICMP PTB messages if it wants to 🙈

Before processing an ICMP PTB message, the DPLPMTUD method needs to do two checks to make sure the message was received in response to a probe packet it actually sent 🕵️‍♀️

DPLPMTUD first uses the quoted info in each PTB message. The receiver MUST validate the protocol information in the quoted packet carried in an ICMP PTB message payload, so it knows the message originated from the sending node (see Section 4.6.1 of [RFC8899]) 🔐
The receiver SHOULD use info that is not simple for an off-path attacker to figure out (see Section 4.6.1 of [RFC8899]). Specifically, a UDP Options receiver SHOULD confirm that the token contained in the UDP REQ Option of the quoted packet has a value that matches a probe packet recently sent by the current endpoint 💜

An implementation that can't support this validation MUST ignore received ICMP PTB messages. No validation, no processing, period 🚫

6. Examples with Different Receiver Behaviors 🎀

When it's enabled, a DPLPMTUD endpoint that implements UDP Options normally responds with a UDP datagram carrying a RES Option when a sender asks for one ✨

The following examples walk through the different receiver behaviors you might run into 🧚

No DPLPMTUD receiver support: One case is when a sender supports this specification, but no RES Option comes back from the remote endpoint. In this example the method can't discover the PLPMTU, so it ends up using MIN_PLPMTU. The remote endpoint might not be set up to process UDP Options, or it might not return a datagram with a RES Option for some other reason (e.g., packet loss, insufficient space to include the option, filtering on the path, etc.). Rough, but it happens 😭
DPLPMTUD receiver uses application datagrams: In a second case, both the sender and receiver support DPLPMTUD using this specification, but the receiver only returns a RES Option with the next UDP datagram that goes back to the requester. So getting a REQ Option doesn't automatically trigger a response 🍓 This lets DPLPMTUD work when datagrams are flowing both ways, as long as there's periodic feedback (e.g., one acknowledgement packet per RTT). It also needs the PLPMTU at the receiver to be big enough that the RES Option can fit in the feedback packets sent in the return direction. This approach avoids chances to misuse the method as a DoS attack 🛡️ The catch: when there's a low rate of transmission (or nothing is sent) in the return direction, prompt delivery of the RES Option gets blocked. At the DPLPMTUD sender, probe packets then fail to be acknowledged in time, which could leave you with a smaller PLPMTU than the path actually supports, or with MIN_PLPMTU 😬
Unidirectional transfer: Another case is where an application only transfers data in one direction (or mostly one direction) 📣 Here, the receiver waiting for a datagram to be queued before returning a RES Option could easily cause a probe timeout at the DPLPMTUD sender. In this case, DPLPMTUD could allow exchanging datagrams without a payload (as discussed in earlier sections) to return the RES Option 🦋
DPLPMTUD receiver permitted to send responses in UDP datagrams with no payload: A DPLPMTUD receiver can generate a datagram (e.g., with zero payload data) solely to return a RES Option (e.g., sent when no other datagrams are queued for transmission). This would let an endpoint probe the set of UDP ports that have been configured with support for this specification, using a DPLPMTUD probe packet. Sure, it adds some extra traffic overhead, but it means DPLPMTUD keeps making timely progress ⏩ Section 3.1 specifies: "If a UDP Options endpoint creates and sends a datagram with a RES Option solely as response to a received REQ Option, the responder MUST limit the rate of these responses (e.g., limiting each pair of ports to send 1 per measured RTT or 1 per second)". That rate limit exists to shut down the DoS vector without really hurting how DPLPMTUD works 🔥

7. IANA Considerations 📋

This document has no IANA actions 🌸 Nothing to register, nothing to update in the registries, we're chilling 😌

8. Security Considerations 🚨

The security considerations for using UDP Options are described in [RFC9868]. The method does not change the integrity protection offered by the UDP Options method 🔒

The security considerations for using DPLPMTUD are described in [RFC8899]. On-path attackers could maliciously drop or modify probe packets to try to decrease the PMTU, or maliciously modify probe packets in an attempt to black-hole traffic. Okay, this part is genuinely scary 💀

The specification recommends that the token value in the REQ Option is initialized to a randomized value. This is to boost protection from off-path attacks 🎲 If a later probe packet uses a token value that's easy to derive from the initial value (e.g., incrementing the value), then a misbehaving on-path observer could work out the token values used for later probe packets from that sender, even if those probe packets never transit via the observer. That would let probe packets be forged, with an impact similar to other on-path attacks against probe packets 😱 This attack could be mitigated by using an unpredictable token value for each probe packet 🧠

The method does not change the ICMP PTB message validation method described by DPLPMTUD: A UDP Options sender that uses ICMP PTB messages received in response to a probe packet MUST use the quoted packet to validate the UDP port information in combination with the token contained in the UDP Option before processing the packet using the DPLPMTUD method 🔍

Upper Layer protocols or applications that employ encryption ought to perform DPLPMTUD at a layer above UDP Options, and not enable UDP Options support for DPLPMTUD. This lets the application control when DPLPMTUD is used, which keeps the extra traffic it generates in check. It also makes sure DPLPMTUD probe packets are encrypted 🔐✨

9. References 📚

9.1. Normative References 💜

[RFC0768]  Postel, J., "User Datagram Protocol", STD 6, RFC 768,
           DOI 10.17487/RFC0768, August 1980,
           <https://www.rfc-editor.org/info/rfc768>.

[RFC2119]  Bradner, S., "Key words for use in RFCs to Indicate
           Requirement Levels", BCP 14, RFC 2119,
           DOI 10.17487/RFC2119, March 1997,
           <https://www.rfc-editor.org/info/rfc2119>.

[RFC8174]  Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC
           2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174,
           May 2017, <https://www.rfc-editor.org/info/rfc8174>.

[RFC8899]  Fairhurst, G., Jones, T., Tüxen, M., Rüngeler, I., and T.
           Völker, "Packetization Layer Path MTU Discovery for
           Datagram Transports", RFC 8899, DOI 10.17487/RFC8899,
           September 2020, <https://www.rfc-editor.org/info/rfc8899>.

[RFC9868]  Touch, J. and C. Heard, Ed., "Transport Options for UDP",
           RFC 9868, DOI 10.17487/RFC9868, October 2025,
           <https://www.rfc-editor.org/info/rfc9868>.

9.2. Informative References 🌷

[RFC1191]  Mogul, J. and S. Deering, "Path MTU discovery", RFC 1191,
           DOI 10.17487/RFC1191, November 1990,
           <https://www.rfc-editor.org/info/rfc1191>.

[RFC4821]  Mathis, M. and J. Heffner, "Packetization Layer Path MTU
           Discovery", RFC 4821, DOI 10.17487/RFC4821, March 2007,
           <https://www.rfc-editor.org/info/rfc4821>.

[RFC8085]  Eggert, L., Fairhurst, G., and G. Shepherd, "UDP Usage
           Guidelines", BCP 145, RFC 8085, DOI 10.17487/RFC8085,
           March 2017, <https://www.rfc-editor.org/info/rfc8085>.

[RFC8201]  McCann, J., Deering, S., Mogul, J., and R. Hinden, Ed.,
           "Path MTU Discovery for IP version 6", STD 87, RFC 8201,
           DOI 10.17487/RFC8201, July 2017,
           <https://www.rfc-editor.org/info/rfc8201>.

[RFC8304]  Fairhurst, G. and T. Jones, "Transport Features of the
           User Datagram Protocol (UDP) and Lightweight UDP (UDP-
           Lite)", RFC 8304, DOI 10.17487/RFC8304, February 2018,
           <https://www.rfc-editor.org/info/rfc8304>.

Acknowledgements 🫶

Gorry Fairhurst and Tom Jones are supported by funding provided by the University of Aberdeen 🎓 The authors would like to thank Magnus Westerlund and Mohamed Boucadair for their detailed comments, and also other people who helped complete this document 💖

Authors' Addresses 🦋

Godred Fairhurst
University of Aberdeen
School of Engineering
Fraser Noble Building
Aberdeen
AB24 3UE
United Kingdom
Email: gorry@erg.abdn.ac.uk


Tom Jones
University of Aberdeen
School of Engineering
Fraser Noble Building
Aberdeen
AB24 3UE
United Kingdom
Email: tom@erg.abdn.ac.uk

📦 where this page comes from

ietf: rfc9869 2025-10
💖 girlified by claude-haiku-5-5 on 2026-10-19: a language model's rewrite of the original, under its terms