Skip to content

Latest commit

 

History

History
133 lines (105 loc) · 46.6 KB

rfc-publication-process.md

File metadata and controls

133 lines (105 loc) · 46.6 KB
Raw
title description published date tags editor dateCreated
RFC Publication process
true
2024-07-24 22:57:15 UTC
markdown
2024-07-23 22:38:08 UTC

THIS PAGE IS STILL UNDER CONSTRUCTION {.is-warning}

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.4&quot;&gt;&lt;diagram id=&quot;iom1gZ4s_vyvB37NhebK&quot; name=&quot;Page-1&quot;&gt;5Vvdc6o4FP9rnNl96I58hNJHW23rzN7eTu2dbh8jRGEWiZcPtfev34QEhCT2UgRL3Qed5JAEcs7vfOQkGRg3q91dBNfeN+yiYKAP3d3AGA90/cq8Iv+U8MYIlm0zwjLyXUbS9oSZ/wtx4pBTU99FcaVhgnGQ+Osq0cFhiJykQoNRhLfVZgscVN+6hkskEWYODGTqi+8mHqPa+uWefo/8pZe/WbP4hFcwb8xnEnvQxdsSyZgMjJsI44SVVrsbFFDe5Xxh/W4PPC0+LEJhUqeDwb9jA4OUT26gWwHpe+36G1Jc0uI7pHkkUsjLFO1Eajb55C3naITT0EX0o4bk8dbzEzRbQ4c+3RIIEZqXrAJS00hx4QfBDQ5wROohDlExYHnenBUbFCVoVyJxPtwhvEJJ9Eaa8KcWZwXHpGny+nYvYX3IaV5JugUPIUfVshh6z3hS4LxXy0GXxDB7Hj09Kxg/xk66orMkL1yvI7whXKMQjuj803ngOzDxcdg13we64UJkLxxCj5MI/4tKTyzHRvNFO2IxzKpcdFksmq4Qi9WCVAxJKqPseYQWiEzJITaIvGAD/QDOKUdvZf56eDVP477y1rArvNU0FXNNmbl2C8w1FZZH4B4K3RE116TmBDCOfafKtCp60c5P/qHlvwCvvfJ2tDzelZqN3/JKSL661IlWX8vP9t2yWt7vIPNjnEYOqih1AqMlSiqIQm7FwcgCKgkAKMCd0yIUEG3fVN2SSij8DY/YzyxHLv+rqm4V9XwINhveq+xGhIFMQUkLpc0HYjyQBsowUky7FmyABJvJeKoylI8RXiCCGRzCIGO5n/jh8sN2Ufu47gJku6ZKd219blhWR3ZR4a86M4yWJIRXagvPS30NWX1Br9S38IU5BESzXFd99UthIDGkaU99LyXkfJvOZk+TW4UGj7aQ6+wQkl+IoxVjV8kDn0CfF4uF7ih9sWvNLdCSPgOjKgPtlIGOLUnlAbekzlpJmfeq/Tt1rijzXrdbVufLXqmzKXjjQis/qs5AdA16Z+p8JQHnM72AVoWN3gpuLvvuBiRxN8aNCEBQDzdEvPCt1GxNG8TvfLD0HiDAkI3YFJT5KqaEyqfbmwsaJ35/UviZW5+FiOQjUcSKEdr4aHu2waIBTuhcNE0Sx2caiS5CRSDbiByEPTESxffk6a2mS72DebL2nYumS8CZjh5G70eKrMUQOo2yYH2NDkX9HZ5Sf+U02DHxOjGzVFU8WvyZovR8QnjN/kwpyfm00Y/n+9+IKU28LHN8ZuoiLqZOKwk5RdWWv2u0ljqRv+tXalPMaIhLoLruThNyLJoYXLcUE4sWPp9AazGxnLL7P4BS7xUoi/3DY1dq2vCAfWsZleJ7WkelnA5sCZXN0k4nQqXZK1RagrPUmy4NLCH+0WsuDY7OH7SNSjkd2patbLRg7SAZqimyoT1bsYrRNBBtXO0Vq4Bvs6O0lrRIs1uGZb+SrZ3AUu8/LEXX29SHi8GAtPnekQ9vG5Z5gNwTWGpdwNLsPSzFFa/ZeBNAMLtmzc2jY51467CUs840H2LaqoxIlgb5I/6TtF/wzQB2uI4Wz3QPQHXAsbOcSG4TJGlcjL8/TFSnd444yvhVJADyxcFJJCBncR9/XP89nd1Pxu/w8qscC7WURxe74uX5n13M2Vl2eXm7nri8YpxcncTlZl2XZwgRkrQ31t6WluL44rHIaYiCJoirhZziRkYZOXqvkAOE7LApnnerfe5V3FWtubRsgpzuErh9sTn5jCrI6de2giUIHIjupHauTNhGB1p3yJGTrM/T9/cF6W0qVnI8GC7PZ4tWWiadNAhumleMCRiSr3z2UukT+nX6EggbfaBpFlx0LlJY0qJmyxnB6WR2d/hu3oEjM1mfczsDIOa9wCnPABhy9uFl+nw/fhq9PLTLS9tBal7ObUDDkW54aZ+Sl3LuYJbAJLt8l3iQqp4DKW7hivIqnMdrNeRzUrymzUsSsH6m9MItY/1FzHhPT5FlR5gC1pW3yQebs2NN0PGyC5jZZ8CQ8mzNNLtQI/a6D12HJWJJqmKHgb8MqfVH9JAqIVDh+Q4MRvzByndd2v06QrH/i91HzAw0T8SRccH1AIzpWGmCY3apWpOQwy/UHrxjK4FGAa2DOLJB1fuqjqGqbLxoQmvAiFT316iZbd3fRTcm/wE=&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="490" y="100" 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: 130px; 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;">MISSREF<div>Awaiting a normative reference</div></div></div></div></foreignObject><text x="550" y="134" 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 422 130 L 483.63 130" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 488.88 130 L 481.88 133.5 L 483.63 130 L 481.88 126.5 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: 456px;"><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="456" 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 550 160 L 550 235 L 426.37 235" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 421.12 235 L 428.12 231.5 L 426.37 235 L 428.12 238.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 a normative reference in the queue</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="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: 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="314" 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 420 250 L 550 250 L 550 273.63" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 550 278.88 L 546.5 271.88 L 550 273.63 L 553.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="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="20"><g><path d="M 550 340 L 550 360 L 426.37 360" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 421.12 360 L 428.12 356.5 L 426.37 360 L 428.12 363.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 either published in a specific order or in some cases published 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).

Documents in a cluster can sometimes wait for a long time for the dependencies on the other documents to be resolved.

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.

Editing

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 and, where needed, edited for correctness. If there is a problem with references, then the document may enter MISSREF or REF states. In addition, a document may be assigned the *R (Reference) flag to indicate that the document has one or more normative references that are IN-QUEUE or NOT-RECEIVED.

MISSREF is fully defined as: Awaiting a missing normative reference (i.e., the reference is NOT-RECEIVED) or there was a specific request from the stream manager or authors for simultaneous publication with another document. MISSREF 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

REF is fully defined as: Document has been edited but is holding for a normative reference that is in the queue. (Note: In addition, “REF” is used to mark a list of normative references shown on cluster pages. Each reference is listed as IN-QUEUE or NOT-RECEIVED.)

A document 'A' that has a normative reference to a document 'B' that is not yet in the queue will be held at MISSREF state (perhaps a very long time) until 'B' enters the queue. Once 'A' and 'B' are both in the queue, they will both be edited. For various reasons, this editing may require different times. 'A' will be held in REF state, if necessary, until the editing of 'B’ is complete, so that 'A' and 'B' will enter the final quality-control state RFC-EDITOR, together. Collections of 5 or more documents linked by such normative references are not unusual.

IANA processing

If the document contains IANA actions then they are sent by the RPC to IANA for processing. This generally takes place in parallel with editing and so the document remains in EDIT state and has the *A (IANA) flag assigned to indicate that IANA processing is underway.

Occasionally IANA processing can take longer than editing, for example, if IANA are waiting for a designated expert to respond, in which case the document will be moved to IANA state until the IANA processing is complete.

IESG processing

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.

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 now takes weeks if not months to complete. 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.

Tooling issue

Occasionally, 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.

Withdrawn documents

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.