RFC 3269

Author Guidelines for Reliable Multicast Transport (RMT) Building Blocks and Protocol Instantiation documents

📅 published May 2002, from ietf

✨ RFC 3269 PART 1 ✨

Title Block 🎀

This is RFC 3269, titled Author Guidelines for Reliable Multicast Transport (RMT) Building Blocks and Protocol Instantiation documents. It was written by R. Kermode (Motorola) and L. Vicisano (Cisco), and it's dated April 2002. The category is Informational 📚, so it's guidance and not a standard. The header doesn't list anything it obsoletes or updates, so that part is empty 💅.

Status of This Memo 🌸

This memo gives information to the Internet community. It is not an Internet standard of any kind. You can distribute it freely, with no limits.

Copyright Notice 🦋

Abstract 💜

This document is a guide for the people writing Reliable Multicast Transport (RMT) building block definitions and protocol instantiation definitions. The goal is that every building block and protocol instantiation you write has enough detail to fully explain how it works and how to use it. The guidelines also help you design RMT building blocks that are modular, clearly defined, and easy to refine or extend, so people can safely build new protocols for new situations that older protocols never imagined 🧚.

Table of Contents ✨

   1 Introduction ...................................................  2
   1.1 Terminology ..................................................  3
   2 The Guidelines .................................................  3
   2.1 Building Block Document Guidelines ...........................  3
   2.1.1 Rationale ..................................................  3
   2.1.2 Functionality ..............................................  4
   2.1.3 Applicability Statement ....................................  4
   2.1.4 Packet-Header Fields .......................................  4
   2.1.5 Requirements from other Building Blocks ....................  5
   2.1.6 Security Considerations ....................................  5
   2.1.7 Codepoint Considerations ...................................  6
   2.1.8 Summary Checklist ..........................................  6
   2.2 Protocol Instantiation Document Guidelines ...................  7
   2.2.1 Applicability Statement ....................................  7
   2.2.2 Architecture Definition ....................................  7
   2.2.3 Conformance Statement ......................................  8
   2.2.4 Functionality Definition ...................................  8
   2.2.5 Packet Formats .............................................  9
   2.2.6 Summary Checklist ..........................................  9
   3 IANA Considerations ............................................  9
   4 Acknowledgements ............................................... 10
   5 References ..................................................... 10
   6 Authors' Addresses ............................................. 11
   7 Full Copyright Statement ....................................... 12

1. Introduction 🌈

Okay so, RMT protocols can be built in a bunch of different ways, and some of those ways are better for some situations than others. The belief is that the requirements for reliable multicast transport are so varied that no single protocol can cover all of them [RFC2887]. BUT, there's also enough overlap between the approaches that it should be possible to define a set of building blocks [RFC3048] that different RMT protocols can be assembled from. It's giving Lego, but make it networking 🧱✨.

Two big perks here. First, the same building block can be reused across different protocol instantiations. Second, building blocks can get upgraded as people learn more. For that upgrade thing to actually work, a building block has to be clearly described: what it does, how it interacts with other building blocks, and where it fits into the overall architecture of a protocol instantiation. The description also needs enough detail that someone who wants to improve a building block or protocol instantiation can do it while fully understanding the design choices and tradeoffs that were made before 🧠💅.

There are some dangers with the building block approach too, and you need to understand them or you'll end up with specification flaws. 😭

The biggest danger is using building blocks in the wrong way. We should aim to write building blocks that are modular and reusable, but for practical reasons that isn't always fully possible. So some building blocks end up with an applicability that depends on context, and that creates the risk of co-dependence incompatibilities between blocks. A classic example: blocks A and B work together, and blocks B and C work together, but the combination of A, B, and C does not work 💀.

To avoid misusing building blocks and to avoid incompatibilities between them, every external dependency has to be called out in the building block specification. The specification also has to include a precise applicability statement for that block. On the flip side, any protocol instantiation specification has to explain how each building block it uses meets the applicability requirements of that instantiation 🫶. These guidelines aren't meant to replace normal Internet specification writing. They just add to it in a way that fits the RMT framework better 🎀.

1.1. 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 RFC 2119 [RFC2119].

2. The Guidelines 💖

This document gives guidelines for the authors of the two main kinds of RMT documents: building block documents and protocol instantiation documents. Here are the guidelines for each one 📝.

2.1. Building Block Document Guidelines 🍓

All RMT Building block documents MUST contain sections that cover the following.

2.1.1. Rationale 🦋

Individual building blocks SHOULD be reusable within multiple protocols, and they MUST provide functionality that no other building block provides. If a building block is currently used in only one protocol instantiation, then it MUST specify some functionality that is likely to be reused in another (future) protocol instantiation.

The rationale section of a building block document needs to clearly explain why the functional decomposition landed on that particular level of granularity and produced that building block. If the granularity is too small, the building blocks will probably be trivial, and you'll need a ton of extra effort to get a working protocol out of them 😩. If the granularity is too large, the building blocks will only be usable inside a single protocol instantiation. The rationale section MUST show that the granularity is appropriate so that neither problem happens 🙌.

2.1.2. Functionality 💜

The functionality section of a building block document MUST describe all algorithms and functions inside the building block. The external interfaces for accessing those algorithms and functions MUST be fully specified too. That way the building block can be combined with other building blocks and with any extra functionality from a protocol instantiation document to make a working protocol ⚡.

2.1.3. Applicability Statement 👑

This is one of the most important sections in a building block document. Its job is to give enough detail about the intended use of the block so that people writing protocol instantiations can use it within its applicability constraints. It also helps future building block authors quickly figure out whether an existing block already meets their need. For that to work, the Applicability Statement MUST describe:

The intended scenarios for using the building block.
The building block's known failure modes, why they happen, and how they can be detected.
A list of environmental considerations. This includes, but isn't limited to, whether the block needs multi-source multicast or can work in single-source-only multicast networks, satellite networks, asymmetric networks, and wireless networks 📡.
A list of potential conflicts or incompatibilities with other building blocks.

2.1.4. Packet-Header Fields 🧚

If a building block provides functionality that needs protocol messages to be exchanged between multiple agents, then the building block specification MUST state what kind of information is needed and how the exchange works. This includes a detailed description of the data format and the various communication requirements, like timing constraints and network requirements (for example, multicast vs. unicast delivery) 🌸.

The data format is usually specified at the level of "generic header fields," without a full bit-level header specification. Generic header fields MAY carry additional requirements, such as how precise the representation needs to be or where in the packet header they should sit. That last one might be driven by efficiency concerns ⏱️.

A building block specification MAY specify "abstract messages" that carry particular information for use only inside that building block. Most of the time, though, it will rely on the protocol messages defined in the protocol instantiation to carry the information it needs 📬.

The building block that provides Generic Router Assist functionality is the exception to the rule above. For efficiency reasons, that block can fully specify its header fields and where those fields go within the packet header 🦄.

2.1.5. Requirements from other Building Blocks 🫧

Each building block specifies a well-defined piece of functionality that's common to multiple protocol instantiations. That doesn't mean block definitions get written in isolation, though. For example, a congestion control building block has specific requirements about loss notification coming from either a NACK or an ACK building block. The "Requirements from other Building Blocks" section exists to capture these requirements, so that authors of related building blocks can tell what functionality they need to provide in order to use a particular block 🤝.

Specifically, the "Requirements from other Building Blocks section" MUST provide a complete and exhaustive list of every requirement placed on other building blocks so that the block being specified can operate the way it's meant to. Requirements that SHOULD be listed include, but aren't limited to:

Event generation for, and responses to, other building blocks.
Message ordering relative to messages from other building blocks.

Part 2 is coming next, bestie! 🎀💅

2.1.6. Security Considerations 🔐

Okay so the protocol instantiation is the one with the ultimate responsibility for handling security requirements, following RFC 2357 💅. Security considerations might not apply to generic building blocks unless the block is a specific "security" building block. Some building blocks, though, can raise special security issues, either because of the kind of communication they need or because of how they're meant to be used in a protocol instantiation. When a building block has special security issues, its specification MUST address them explicitly 🚨.

An example would be a building block that moves data that's especially sensitive to security attacks. Very important, bestie 😭

2.1.7. Codepoint Considerations 🧩

Some building blocks give you a general framework for describing functionality and leave the details open for implementation-specific algorithms ✨. One example is the Forward Error Correction (FEC) building block. It describes the framing aspects for FEC message fragments, but not the algorithms used to generate the redundant data 🦋.

2.1.8. Summary Checklist 📋

Rationale
   _  Provide justification for the building block's existence
   _  Provide rationale for the building block's granularity

Functionality
   _  Functionality contained within the building block
   _  External interfaces

Applicability Statement
   _  Intended usage
   _  Failure modes (including means of detection if known)
   _  Environmental considerations
   _  Incompatibilities / Conflicts with other building blocks

Packet Header Fields
   _  Specification of logical packet-header fields (*)
   _  Abstract messages specifications (*)

Requirements from other building blocks;
   _  Mandatory needs from other building blocks

Security Considerations
   _  Specify as much as possible (with respect to procedures,
      algorithms and data encoding), without affecting the general
      applicability of the building block.

(*) May not be applicable to some building blocks.

2.2. Protocol Instantiation Document Guidelines 🌸

Protocol Instantiation documents have one job: to explain how you can combine multiple building blocks to build a new, fully specified working protocol 🧚. So RMT Protocol Instantiation documents MUST contain the following four sections 💜.

2.2.1. Applicability Statement 🎯

The applicability statement's whole purpose is to frame the design space where the fully realized protocol will live. That way, future RMT protocol designers can figure out whether an existing protocol already meets their needs 👀. For this to work, the applicability statement MUST follow these guidelines:

The target application space the protocol is meant for MUST be clearly identified. For example, is the protocol for real-time delivery, or for non-real-time file transfer? 🎬
The target scale, meaning the maximum number of receivers per session the protocol is meant for, MUST be clearly specified. If the protocol has an architectural limit because it was optimized for some other feature, like per-packet acknowledgment, this SHOULD be included 📏.
The applicability statement MUST identify the intended environments for the protocol's use AND list any environments where the protocol should not be used. Example environments to consider include asymmetric networks, wireless networks, and satellite networks 🛰️.
Finally, all protocols have inherent weaknesses that come from being optimized for one specific feature. These weaknesses can show up as spectacular failure modes when certain conditions happen 💀. When they're known, these conditions and how the resulting failure can be detected MUST be included in the applicability statement 🚩.

2.2.2. Architecture Definition 🏗️

Protocol Instantiations define how to combine one or more building blocks to create a working protocol. The Architecture Definition lays out the framework for how this happens. For that framework to be complete, it MUST contain the following information:

An overview of the major facets of the protocol's operation ✨.
A full enumeration and overview of which Building Blocks are used, with explicit references to the documents that define them 📚.
An overview of how those building blocks are joined together 🔗.
A discussion of the design tradeoffs made when choosing the architecture 🤔.

2.2.3. Conformance Statement 🎀

The conformance statement below MUST be included and adhered to 💖:

   "This Protocol Instantiation document, in conjunction with the
   following Building Block documents identified in [list of relevant
   building block references] completely specifies a working reliable
   multicast transport protocol that conforms to the requirements
   described in RFC 2357."

Protocol instantiation document authors, this is your reminder that RFC 2357 requires any RMT protocol put forward for standardization with the IETF to protect the network as much as is possible 🛡️. This doesn't mean RMT protocols get held to a higher standard than unicast transport protocols. It just means they should be designed to perform at least as well as unicast transport protocols when it comes to the possibility of protocol failure 🫶.

2.2.4. Functionality Definition ⚙️

Building Block documents will be incomplete, since they only specify an abstract framework of a building block's functionality 🫠. So the complete algorithmic specifications for each building block, along with any additional functionality, MUST be provided within the Protocol Instantiation document's functionality definition. This description must also show that each building block is used in accordance with its respective applicability statement. Finally, the functionality description must provide a description of the abstract programming interface that connects the protocol instantiation with the applications that will use it 🔌.

2.2.5. Packet Formats 📦

Once all the functionality is fully defined, the Protocol Instantiation document must define the packet formats the protocol will use. Each message part, and the rules for how they're concatenated, MUST be specified for both IPv4 [RFC791] and IPv6 [RFC2460]. Support for IPSEC [RFC2401] MUST be explicitly shown 🔐.

Protocols will evolve, and IP protocol numbers are a scarce resource 💎. So protocol instantiations MUST initially define packet formats for use over UDP [RFC768]. Whether a particular Reliable Multicast Transport protocol instantiation becomes popular enough to warrant its own protocol number is an issue that will be deferred until the protocol has been widely deployed and understood 🌈.

2.2.6. Summary Checklist ✅

Applicability Statement
   _  Target application space
   _  Target scale
   _  Intended environment
   _  Weaknesses and known failure modes

Architecture Definition
   _  Operational overview
   _  Building blocks used
   _  Details on how building blocks are joined

Conformance Statement
   _  Inclusion of mandatory paragraph

Functionality Definition
   _  Building block algorithmic specification
   _  Addition functionality specification
   _  Compliance with building block applicability statements
   _  Abstract program interface

Packet Formats
   _  IPv4 message parts
   _  IPv6 message parts
   _  IPSEC support
   _  Message ordering

3. IANA Considerations 🪪

There are no explicit IANA considerations for this document.

4. Acknowledgements 🫶

This document is an overview of the mandatory elements required for specifying building blocks and protocol instantiations within the RMT working group. The requirements presented are a summary of discussions held between the RMT Working Group chairs and the participants in the IRTF Reliable Multicast Research Group. Although the name of these participants are too numerous to list here, the Working Group chairs would like to thank everyone who participated in these discussions for their contributions 💜.

5. References 📚

[RFC768] Postel, J., "User Datagram Protocol", STD 6, RFC 768, August 1980.

[RFC791] Postel, J., "Darpa Internet Protocol Specification", STD 5, RFC 791, September 1981.

[RFC2401] Kent, S. and R. Atkinson, "Security Architecture for the Internet Protocol", RFC 2401, November 1998.

[RFC2460] Deering, S. and R. Hinden, "Internet Protocol, Version 6 (IPv6) Specification", RFC2460, December 1998.

[RFC2887] Handley, M., Floyd, S., Whetten, B., Kermode, R., Vicisano, L. and M. Luby, "The Reliable Multicast Design Space for Bulk Data Transfer", RFC 2887, August 2000.

[RFC3048] Whetten, B., Vicisano, L., Kermode, R., Handley, M., Floyd, S. and M. Luby, "Reliable Multicast Transport Building Blocks for One-to-Many Bulk-Data Transfer", RFC 3048, January 2001.

6. Authors' Addresses 🦋

Roger Kermode
Motorola Australian Research Centre
Locked Bag 5028
Botany  NSW  1455,
Australia.

EMail: Roger.Kermode@motorola.com


Lorenzo Vicisano
Cisco Systems,
170 West Tasman Dr.
San Jose, CA 95134, USA

EMail: lorenzo@cisco.com

This document and translations of it may be copied and furnished to others, and derivative works that comment on or otherwise explain it or assist in its implementation may be prepared, copied, published and distributed, in whole or in part, without restriction of any kind, provided that the above copyright notice and this paragraph are included on all such copies and derivative works. However, this document itself may not be modified in any way, such as by removing the copyright notice or references to the Internet Society or other Internet organizations, except as needed for the purpose of developing Internet standards in which case the procedures for copyrights defined in the Internet Standards process must be followed, or as required to translate it into languages other than English.

The limited permissions granted above are perpetual and will not be revoked by the Internet Society or its successors or assigns.

This document and the information contained herein is provided on an "AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.

Acknowledgement 💖

Funding for the RFC Editor function is currently provided by the Internet Society 🌸.

📦 where this page comes from

ietf: rfc3269 2002-05
💖 girlified by claude-haiku-5-5 on 2026-10-16: a language model's rewrite of the original, under its terms