Skip to content

Latest commit

 

History

History
156 lines (117 loc) · 47.6 KB

rfc-publication-process.md

File metadata and controls

156 lines (117 loc) · 47.6 KB
Raw
title description published date tags editor dateCreated
RFC Publication process
true
2024-08-28 12:24:05 UTC
markdown
2024-07-23 22:38:08 UTC

Stream approval

The process for publishing an RFC begins when an Internet-Draft is approved by one of the publication streams:

  • IETF Stream. I-Ds from the IETF stream are submitted by the IESG following their processes documented in RFC 2026 and multiple subsequent RFCs.
  • IAB Stream. The process for publication of IAB RFCs is documented in RFC 4845.
  • IRTF Stream. The process for publication of IRTF RFCs is documented in Section 3 of RFC 5743.
  • Independent Stream. The process for publication of Independent Submission RFCs is documented in Section 3 of RFC 4846.
  • Editorial Stream. The process for publication of Editorial Stream RFCs is documented in Section 3.2 of RFC 9280.

Publication queue and states

Once a document is approved, it enters the publication queue and is managed by the RFC Production Center (RPC). From this point on, the RPC has change control of the document. This means that the RPC now manages the document in their own repository, and that all changes the authors wish to make must go through the RPC. Any non-technical changes, such as updating the contact information, will normally be accepted directly, but any technical updates will require stream approval.

When a document enters the publication queue, it is assigned an initial state, and this state is updated as the document progresses through the queue. Any time the document's state changes, an automatic email message summarizing the state change is sent to the authors.

The following diagram shows the states, their codes, and the flow through the queue:

<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" width="611px" height="651px" viewBox="-0.5 -0.5 611 651" content="&lt;mxfile host=&quot;embed.diagrams.net&quot; agent=&quot;Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Safari/605.1.15&quot; version=&quot;24.7.7&quot;&gt;&lt;diagram id=&quot;iom1gZ4s_vyvB37NhebK&quot; name=&quot;Page-1&quot;&gt;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&lt;/diagram&gt;&lt;/mxfile&gt;"><defs/><g><g data-cell-id="0"><g data-cell-id="1"><g data-cell-id="30"><g><rect x="20" y="420" width="200" height="230" fill="none" stroke="rgb(0, 0, 0)" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 198px; height: 1px; padding-top: 535px; margin-left: 21px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;"><div><div><br /></div></div></div></div></div></foreignObject><text x="120" y="539" fill="rgb(0, 0, 0)" font-family="&quot;Helvetica&quot;" font-size="12px" text-anchor="middle">&#xa;</text></switch></g></g></g><g data-cell-id="2"><g><rect x="300" y="0" width="120" height="60" fill="#dae8fc" stroke="#6c8ebf" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 30px; margin-left: 301px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">START<div>Document approved for publication</div></div></div></div></foreignObject><text x="360" y="34" fill="rgb(0, 0, 0)" font-family="&quot;Helvetica&quot;" font-size="12px" text-anchor="middle">START...</text></switch></g></g></g><g data-cell-id="3"><g><path d="M 360 90 L 422 130 L 360 170 L 298 130 Z" fill="#dae8fc" stroke="#6c8ebf" stroke-miterlimit="10" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 122px; height: 1px; padding-top: 130px; margin-left: 299px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">All references available?</div></div></div></foreignObject><text x="360" y="134" fill="rgb(0, 0, 0)" font-family="&quot;Helvetica&quot;" font-size="12px" text-anchor="middle">All references avail...</text></switch></g></g></g><g data-cell-id="4"><g><path d="M 360 60 L 360 83.63" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 360 88.88 L 356.5 81.88 L 360 83.63 L 363.5 81.88 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="5"><g><rect x="300" y="220" width="120" height="60" rx="9" ry="9" fill="#d5e8d4" stroke="#82b366" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 250px; margin-left: 301px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">EDIT<div>Professional editing</div></div></div></div></foreignObject><text x="360" y="254" fill="rgb(0, 0, 0)" font-family="&quot;Helvetica&quot;" font-size="12px" text-anchor="middle">EDIT...</text></switch></g></g></g><g data-cell-id="6"><g><path d="M 360 170 L 360 213.63" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 360 218.88 L 356.5 211.88 L 360 213.63 L 363.5 211.88 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 195px; margin-left: 360px;"><div data-drawio-colors="color: rgb(0, 0, 0); background-color: rgb(255, 255, 255); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; background-color: rgb(255, 255, 255); white-space: nowrap;">Yes</div></div></div></foreignObject><text x="360" y="198" fill="rgb(0, 0, 0)" font-family="&quot;Helvetica&quot;" font-size="11px" text-anchor="middle">Yes</text></switch></g></g></g><g data-cell-id="7"><g><rect x="140" y="150" width="120" height="60" rx="9" ry="9" fill="#fff2cc" stroke="#d6b656" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 180px; margin-left: 141px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">MISSREF<div>Awaiting a normative reference</div></div></div></div></foreignObject><text x="200" y="184" fill="rgb(0, 0, 0)" font-family="&quot;Helvetica&quot;" font-size="12px" text-anchor="middle">MISSREF...</text></switch></g></g></g><g data-cell-id="8"><g><path d="M 298 130 L 200 130 L 200 143.63" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 200 148.88 L 196.5 141.88 L 200 143.63 L 203.5 141.88 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 130px; margin-left: 239px;"><div data-drawio-colors="color: rgb(0, 0, 0); background-color: rgb(255, 255, 255); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; background-color: rgb(255, 255, 255); white-space: nowrap;">No</div></div></div></foreignObject><text x="239" y="133" fill="rgb(0, 0, 0)" font-family="&quot;Helvetica&quot;" font-size="11px" text-anchor="middle">No</text></switch></g></g></g><g data-cell-id="9"><g><path d="M 200 210 L 200 235 L 293.63 235" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 298.88 235 L 291.88 238.5 L 293.63 235 L 291.88 231.5 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="10"><g><rect x="300" y="330" width="120" height="60" rx="9" ry="9" fill="#d5e8d4" stroke="#82b366" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 360px; margin-left: 301px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">RFC-EDITOR<div>Final internal review</div></div></div></div></foreignObject><text x="360" y="364" fill="rgb(0, 0, 0)" font-family="&quot;Helvetica&quot;" font-size="12px" text-anchor="middle">RFC-EDITOR...</text></switch></g></g></g><g data-cell-id="11"><g><path d="M 360 280 L 360 323.63" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 360 328.88 L 356.5 321.88 L 360 323.63 L 363.5 321.88 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="12"><g><rect x="0" y="280" width="120" height="60" rx="9" ry="9" fill="#fff2cc" stroke="#d6b656" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 310px; margin-left: 1px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">IANA<div>Awaiting IANA action</div></div></div></div></foreignObject><text x="60" y="314" fill="rgb(0, 0, 0)" font-family="&quot;Helvetica&quot;" font-size="12px" text-anchor="middle">IANA...</text></switch></g></g></g><g data-cell-id="13"><g><rect x="140" y="280" width="120" height="60" rx="9" ry="9" fill="#fff2cc" stroke="#d6b656" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 310px; margin-left: 141px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">REF<div>Awaiting other documents in the same cluster</div></div></div></div></foreignObject><text x="200" y="314" fill="rgb(0, 0, 0)" font-family="&quot;Helvetica&quot;" font-size="12px" text-anchor="middle">REF...</text></switch></g></g></g><g data-cell-id="14"><g><rect x="490" y="220" width="120" height="60" rx="9" ry="9" fill="#fff2cc" stroke="#d6b656" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 250px; margin-left: 491px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">AUTH<div>Awaiting author action</div></div></div></div></foreignObject><text x="550" y="254" fill="rgb(0, 0, 0)" font-family="&quot;Helvetica&quot;" font-size="12px" text-anchor="middle">AUTH...</text></switch></g></g></g><g data-cell-id="15"><g><path d="M 300 250 L 200 250 L 200 273.63" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 200 278.88 L 196.5 271.88 L 200 273.63 L 203.5 271.88 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="16"><g><path d="M 300 250 L 60 250 L 60 273.63" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 60 278.88 L 56.5 271.88 L 60 273.63 L 63.5 271.88 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="17"><g><path d="M 426.37 250 L 483.63 250" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 421.12 250 L 428.12 246.5 L 426.37 250 L 428.12 253.5 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/><path d="M 488.88 250 L 481.88 253.5 L 483.63 250 L 481.88 246.5 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="18"><g><path d="M 200 340 L 200 360 L 293.63 360" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 298.88 360 L 291.88 363.5 L 293.63 360 L 291.88 356.5 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="19"><g><path d="M 60 340 L 60 360 L 293.63 360" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 298.88 360 L 291.88 363.5 L 293.63 360 L 291.88 356.5 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="21"><g><rect x="300" y="420" width="120" height="60" rx="9" ry="9" fill="#d5e8d4" stroke="#82b366" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 450px; margin-left: 301px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">AUTH48<div>Author(s) final approval</div></div></div></div></foreignObject><text x="360" y="454" fill="rgb(0, 0, 0)" font-family="&quot;Helvetica&quot;" font-size="12px" text-anchor="middle">AUTH48...</text></switch></g></g></g><g data-cell-id="22"><g><rect x="300" y="505" width="120" height="60" rx="9" ry="9" fill="#d5e8d4" stroke="#82b366" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 535px; margin-left: 301px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">AUTH48-DONE<div>Publication</div></div></div></div></foreignObject><text x="360" y="539" fill="rgb(0, 0, 0)" font-family="&quot;Helvetica&quot;" font-size="12px" text-anchor="middle">AUTH48-DONE...</text></switch></g></g></g><g data-cell-id="23"><g><rect x="300" y="590" width="120" height="60" fill="#dae8fc" stroke="#6c8ebf" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 620px; margin-left: 301px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">PUBLISHED</div></div></div></foreignObject><text x="360" y="624" fill="rgb(0, 0, 0)" font-family="&quot;Helvetica&quot;" font-size="12px" text-anchor="middle">PUBLISHED</text></switch></g></g></g><g data-cell-id="24"><g><path d="M 360 390 L 360 413.63" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 360 418.88 L 356.5 411.88 L 360 413.63 L 363.5 411.88 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="25"><g><path d="M 360 480 L 360 498.63" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 360 503.88 L 356.5 496.88 L 360 498.63 L 363.5 496.88 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="26"><g><path d="M 360 565 L 360 583.63" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 360 588.88 L 356.5 581.88 L 360 583.63 L 363.5 581.88 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="27"><g><rect x="490" y="420" width="120" height="60" rx="9" ry="9" fill="#fff2cc" stroke="#d6b656" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 450px; margin-left: 491px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">TI<div>Awaiting tooling change</div></div></div></div></foreignObject><text x="550" y="454" fill="rgb(0, 0, 0)" font-family="&quot;Helvetica&quot;" font-size="12px" text-anchor="middle">TI...</text></switch></g></g></g><g data-cell-id="28"><g><path d="M 426.37 450 L 483.63 450" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 421.12 450 L 428.12 446.5 L 426.37 450 L 428.12 453.5 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/><path d="M 488.88 450 L 481.88 453.5 L 483.63 450 L 481.88 446.5 Z" fill="rgb(0, 0, 0)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="29"><g><rect x="60" y="480" width="120" height="60" rx="9" ry="9" fill="#fff2cc" stroke="#d6b656" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 510px; margin-left: 61px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">IESG<br /><div>Awaiting IESG action</div></div></div></div></foreignObject><text x="120" y="514" fill="rgb(0, 0, 0)" font-family="&quot;Helvetica&quot;" font-size="12px" text-anchor="middle">IESG...</text></switch></g></g></g><g data-cell-id="31"><g><rect x="60" y="560" width="120" height="60" rx="9" ry="9" fill="#f8cecc" stroke="#b85450" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 590px; margin-left: 61px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">WITHDRAWN</div></div></div></foreignObject><text x="120" y="594" fill="rgb(0, 0, 0)" font-family="&quot;Helvetica&quot;" font-size="12px" text-anchor="middle">WITHDRAWN</text></switch></g></g></g><g data-cell-id="32"><g><rect x="45" y="430" width="150" height="40" fill="none" stroke="none" pointer-events="all"/></g><g><g transform="translate(-0.5 -0.5)"><switch><foreignObject pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow: visible; text-align: left;"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 450px; margin-left: 120px;"><div data-drawio-colors="color: rgb(0, 0, 0); " style="box-sizing: border-box; font-size: 0px; text-align: center;"><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: nowrap;">States that can <div><span style="white-space: normal;">be reached at any point</span></div></div></div></div></foreignObject><text x="120" y="454" fill="rgb(0, 0, 0)" font-family="&quot;Helvetica&quot;" font-size="12px" text-anchor="middle">States that can...</text></switch></g></g></g></g></g></g><switch><g requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"/><a transform="translate(0,-5)" xlink:href="https://www.drawio.com/doc/faq/svg-export-text-problems" target="_blank"><text text-anchor="middle" font-size="10px" x="50%" y="100%">Text is not SVG - cannot display</text></a></switch></svg>

The state of a document can include one or more flags and a generation number (more details below).

Clusters

Sometimes groups of documents are managed together as a cluster. This can be for two reasons:

  1. Where the documents contain normative references to each other, either directly or indirectly through intermediate documents, and therefore need to be published in a certain order and/or simultaneously.
  2. Where the originating stream specifically submits a set of documents that should be published together even though they are not explicitly coupled by normative references.

Clusters can include both documents that are in the queue and those that are either already published or not yet in the queue (shown as NOT-RECEIVED).

Clusters are assigned IDs and linked to each document in the cluster. The Active Clusters page shows the current clusters and the state of each document in the cluster.

Initial reference check

A document waiting for a normative reference, such as in a cluster, or stream-specified dependency to enter the queue is placed in MISSREF state. The MISSREF state is further sub-divided by generation numbers:

  • 1G has a reference to a NOT-RECEIVED document
  • 2G has a reference to a document that references a NOT-RECEIVED document
  • 3G has a reference to a document that references a doc that references a NOT-RECEIVED document

Documents in a cluster can sometimes wait for a long time for the dependencies on the other documents to be resolved. Once the dependencies are resolved, the document moves out of the MISSREF state and into the EDIT state.

Professional editing (EDIT)

Once a document is approved and submitted for publication, control is handed over to the professional editors of the RFC Publication Center (RPC) and the document moved into EDITstate. They start by putting the document through an extensive editing process with multiple stages.

RFCXML editing

If the document is not already in RFCXML, it is converted into RFCXML. The RFCXML is examined and may be restructured to ensure consistency and readability. The editors perform the following updates:

  • Look for UTF-8 characters and mark them appropriately.
  • Update the DOCTYPE to the following:
    <!ENTITY nbsp    "&#160;">
    <!ENTITY zwsp   "&#8203;">
    <!ENTITY nbhy   "&#8209;">
    <!ENTITY wj     "&#8288;">
   ]>
  • Check the following elements for accuracy and update them if needed:
  • Add the <seriesInfo> element to capture the RFC number.
  • If the document has key words from BCP 14 (e.g., “MUST”, “RECOMMENDED”), tag those key words with the <bcp14> element, which provides text formatting.
  • Check the contents of anything tagged with <artwork> to assess whether it should be converted to a table, a list, or tagged with <sourcecode> instead.
  • Clean up any blank spaces or lines around <artwork> or [<sourcecode>]((/rfcxml-vocabulary#sourcecode) and may make edits to get the the contents to fit within the width limit.
  • Check lists for correct semantics and update if necessary (e.g., changing a bulleted list to a definition list).
  • If <ul empty=”true”> is used for indentation, this will be replaced with a more appropriate tag such as <blockquote>, <aside>, or <t indent=”6″>.
  • Adjust <table> formatting if needed.
  • Subscripts and superscripts are tagged with <sub> and <sup> respectively.
  • Add <contact> elements around each person’s name.
  • Remove any markdown source and any empty paragraphs.
  • Any long-format references to RFCs and Internet-Drafts are updated to use the <xi:xinclude> mechanism so that information from the citation library can be pulled into the document.
  • Any citation tags are updated to use <displayreference>. For example, this RFCXML:
    <reference anchor="URI" target="https://www.rfc-editor.org/info/rfc3986"> 
      ... 
    </reference>

is changed to the following:

    <displayreference target="RFC3986" to="URI"/>
    <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.3986.xml"/>

Copy editing

The document is copy edited to find and correct errors and to ensure that the document conforms to the style guide. See Language and Style for specific details.

Reference checking and editing

The references in the document are checked for accuracy and stability and, where needed, edited for correctness.

A document that belongs to a cluster is placed in REF state once its EDIT state has finished until the editing of the other documents in the cluster is complete so that all cluster documents will enter the final quality-control state RFC-EDITOR together.

IANA processing

If the document contains IANA actions, such as creating or updating an IANA registry, then IANA will start their processing when the document is approved for publication. IANA processing usually takes place in parallel with editing, and until the processing is completed, the document's queue state will have the *A (IANA) flag appended to it (e.g., EDIT*A).

Occasionally IANA processing can take longer than editing, for example, if IANA is waiting for a designated expert to respond. In which case, the document will be moved to IANA state, where it will stay until the IANA processing is complete. Once IANA has completed their actions, the document will enter RFC-EDITOR state.

Final internal review (RFC-EDITOR)

During the final internal review, a senior editor reviews the formatting, copy edits, and the team's proposed questions to authors.

If there is an IANA Considerations section, the senior editor reviews the messages regarding IANA actions, compares the information within the document to the information within the registry, and updates the section. If there are any issues with the IANA registry itself, these are noted for discussion with IANA during the Authors' Final Approval stage.

If there are code components such as YANG modules, XML, ABNF, or MIBs, the senior editor validates them with automated tools and notes any issues to discuss with authors during final approval.

Once the final review is complete, the senior editor lauches the Author's Final Approval stage (AUTH48).

Authors' final approval (AUTH48)

After editing, the document then enters the Authors' Final Approval stage, referred to as AUTH48 as historically this was expected to take 48 hours to complete, though it can take a week or more depending on the authors' schedules. In AUTH48 the changes made by the RPC are shared with the authors for their approval.

AUTH48 begins with an email sent to the authors asking them to complete the following actions:

  1. Review and resolve any questions raised by the RPC editors. These are included in an attached RFCXML file as XML comments and they are also sent in a subsequent email.
  2. Review any changes submitted by coauthors. The RPC assume that if authors do not speak up that they agree to changes submitted by coauthors.
  3. Review the full content of the document, as this cannot change once the RFC is published.
  4. Review the copyright notice and legends as defined in RFC 5378 and the Trust Legal Provisions (TLP – https://trustee.ietf.org/license-info/).
  5. Review the markup in the RFCXML file to ensure that elements of content are correctly tagged.
  6. Review the PDF, HTML, and TXT files to ensure that the formatted output, as generated from the RFCXML file, is reasonable.

Instructions are provided on how an author can submit changes and how to give final approval for the document to be published. This process can involve multiple discussions about the edits, alternative edits proposed by the authors and much negotiation.

If the authors make any changes that seem beyond editorial in nature, e.g., addition of new text, deletion of text, and technical changes, then the RPC will seek approval for those changes from the originating stream.

AUTH48 finishes when all authors of the document give their final approval.

If it was determined that an IANA registry needed updates, the RPC editor will request IANA make those updates after all author approvals are received.

Unavailable authors

There may be an occasion when one of the authors is no longer available, in which case the remaining authors can opt for one of the following paths:

  1. The unavailable author can be removed as an author and moved to the Acknowledgements section.
  2. The unavailable author can be removed as an author and moved to the Contributors section.
  3. A stream manager can approve the document in place of the unavailable author. (See the IESG Statement on AUTH48 State.)

Option 3 is typically used in instances where the unavailable author made significant contributions to the document, so the other authors are not comfortable removing the individual from the author list.

Exceptional states

There are a number of states that occur in exceptional circumstances.

Tooling issue (TI)

Occasionally, at the end of AUTH48 publication of the document is on hold pending the resolution of an issue with the software tools used to create the pubished versions. For example, if there is an error in the PDF generation. In these circumstances, the document is moved into TI state until the issue is resolved.

IESG action (IESG)

Editing sometimes raises issues that lead to technical discussions involving the working group and an Area Director. If the delay is significant, the document is put into IESG state until the issue is resolved.

Withdrawn documents (WITHDRAWN)

A document may occasionally “fall out” of the queue at any time, e.g., because a working group, an author, or an Area Director requests that it be withdrawn, in which case the state is set to WITHDRAWN.

Publication

When an RFC is published it is moved to PUBLISHED state and an announcement is sent to ietf-announce and rfc-dist mailing lists. The URL for the info page of an RFC is of the form: https://www.rfc-editor.org/info/rfcXXXX. The RFC Editor maintains a list of most recently published RFCs (RSS Feed).