RFC 5023

The Atom Publishing Protocol

📅 published October 2007, from ietf

RFC 5023: The Atom Publishing Protocol 🎀

okay bestie, this one is RFC 5023, titled The Atom Publishing Protocol 💖. It's a Standards Track document from October 2007, so it's an actual official internet standard. The editors are J. Gregorio from Google and B. de hOra from NewBay Software. Neither of them is listed as the sole author, so they're both getting credit 🫶. It doesn't list anything it obsoletes or updates, so it isn't replacing or patching any older RFC. 🌸

Status of This Memo

this is an Internet standards track protocol for the Internet community, and the authors are literally asking for discussion and suggestions for improvements 🧚. if you want to know where it currently stands, check the current edition of the "Internet Official Protocol Standards" (STD 1). and distribution of this memo is unlimited, so share it with everyone 💅.

Abstract

so AtomPub (the Atom Publishing Protocol) is an application-level protocol for publishing and editing Web resources 💜. it works by transferring Atom-formatted representations over HTTP, and the Atom format itself is documented in the Atom Syndication Format. it's giving clean and simple ✨.

1. Introduction ....................................................4
2. Notational Conventions ..........................................4
   2.1. XML-Related Conventions ....................................4
        2.1.1. Referring to Information Items ......................4
        2.1.2. RELAX NG Schema .....................................4
        2.1.3. Use of "xml:base" and "xml:lang" ....................5
3. Terminology .....................................................5
4. Protocol Model ..................................................6
   4.1. Identity and Naming ........................................6
   4.2. Documents and Resource Classification ......................7
   4.3. Control and Publishing .....................................8
   4.4. Client Implementation Considerations .......................9
5. Protocol Operations .............................................9
   5.1. Retrieving a Service Document .............................10
   5.2. Listing Collection Members ................................10
   5.3. Creating a Resource .......................................11
   5.4. Editing a Resource ........................................11
        5.4.1. Retrieving a Resource ..............................11
        5.4.2. Editing a Resource .................................12
        5.4.3. Deleting a Resource ................................12
   5.5. Use of HTTP Response Codes ................................12
6. Protocol Documents .............................................13
   6.1. Document Types ............................................13
   6.2. Document Extensibility ....................................13
7. Category Documents .............................................14
   7.1. Example ...................................................14
   7.2. Element Definitions .......................................14
        7.2.1. The "app:categories" Element .......................14
8. Service Documents ..............................................15
   8.1. Workspaces ................................................16
   8.2. Example ...................................................16
   8.3. Element Definitions .......................................17
        8.3.1. The "app:service" Element ..........................17
        8.3.2. The "app:workspace" Element ........................18
        8.3.3. The "app:collection" Element .......................18
        8.3.4. The "app:accept" Element ...........................19
        8.3.5. Usage in Atom Feed Documents .......................19
        8.3.6. The "app:categories" Element .......................20
9. Creating and Editing Resources .................................20
   9.1. Member URIs ...............................................20
   9.2. Creating Resources with POST ..............................20
        9.2.1. Example ............................................21
   9.3. Editing Resources with PUT ................................22
   9.4. Deleting Resources with DELETE ............................22
   9.5. Caching and Entity Tags ...................................22
        9.5.1. Example ............................................23

   9.6. Media Resources and Media Link Entries ....................25
        9.6.1. Examples ...........................................26
   9.7. The Slug Header ...........................................30
        9.7.1. Slug Header Syntax .................................31
        9.7.2. Example ............................................31
10. Listing Collections ...........................................32
   10.1. Collection Partial Lists .................................32
   10.2. The "app:edited" Element .................................33
11. Atom Format Link Relation Extensions ..........................34
   11.1. The "edit" Link Relation .................................34
   11.2. The "edit-media" Link Relation ...........................34
12. The Atom Format Type Parameter ................................34
   12.1. The "type" parameter .....................................34
        12.1.1. Conformance .......................................35
13. Atom Publishing Controls ......................................35
   13.1. The "app:control" Element ................................35
        13.1.1. The "app:draft" Element ...........................36
14. Securing the Atom Publishing Protocol .........................36
15. Security Considerations .......................................37
   15.1. Denial of Service ........................................37
   15.2. Replay Attacks ...........................................37
   15.3. Spoofing Attacks .........................................37
   15.4. Linked Resources .........................................38
   15.5. Digital Signatures and Encryption ........................38
   15.6. URIs and IRIs ............................................38
   15.7. Code Injection and Cross Site Scripting ..................39
16. IANA Considerations ...........................................39
   16.1. Content-Type Registration for 'application/atomcat+xml' ..39
   16.2. Content-Type Registration for 'application/atomsvc+xml' ..40
   16.3. Header Field Registration for 'SLUG' .....................42
   16.4. The Link Relation Registration "edit" ....................42
   16.5. The Link Relation Registration "edit-media" ..............42
   16.6. The Atom Format Media Type Parameter .....................43
17. References ....................................................43
   17.1. Normative References .....................................43
   17.2. Informative References ...................................44
Appendix A. Contributors ..........................................46
Appendix B. RELAX NG Compact Schema ...............................46

1. Introduction ✨

okay so the Atom Publishing Protocol is an application-level protocol for publishing and editing Web Resources, using HTTP [RFC2616] and XML 1.0 [REC-xml] 🦋. it lets you create Web Resources and gives you tools for three big things:

Collections: sets of Resources that you can grab all at once or just a piece at a time 🍓
Services: discovering and describing Collections 🔍
Editing: creating, editing, and deleting Resources 🛠️

the main vibe that makes AtomPub different from most protocols is that the server gets wide latitude in how it processes client requests 💅. see Section 4.4 for the tea on that ☕.

2. Notational Conventions 💜

the key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document get interpreted exactly the way [RFC2119] describes, so read that one too 📖.

2.1.1. Referring to Information Items

Atom Protocol Document formats are defined in terms of the XML Information Set [REC-xml-infoset], and they get serialized as XML 1.0 [REC-xml] 🧚.

the Infoset terms "Element Information Item" and "Attribute Information Item" get shortened to "element" and "attribute". so whenever this spec says "element", it means an Element Information Item, and whenever it says "attribute", it means an Attribute Information Item 🎀.

2.1.2. RELAX NG Schema

some parts of this spec come with little fragments of a non-normative RELAX NG Compact schema [RNC] to help you picture things 🖼️. but the actual text is what defines conformance, so don't skip it. the complete schemas live in Appendix B 💖.

2.1.3. Use of "xml:base" and "xml:lang"

XML elements defined by this spec "MAY" have an "xml:base" attribute [REC-xmlbase] 🔗. when xml:base shows up, it does the job described in Section 5.1.1 of URI Generic Syntax [RFC3986], which is setting the base URI (or IRI, Internationalized Resource Identifier [RFC3987]) for resolving relative references inside the scope of that "xml:base" attribute 🌸.

any element defined by this spec "MAY" have an "xml:lang" attribute, and its value says what natural language the element and its descendants are in 🌍. the rules for what goes in "xml:lang" and how to read it are in Section 2.12 of XML 1.0 [REC-xml] ✨.

3. Terminology 📚

for convenience, this protocol can also be called the "Atom Protocol" or "AtomPub" 🦋. here's the vocab this spec uses:

URI: a Uniform Resource Identifier, as defined in [RFC3986] 🔗. in this spec, "the URI of a document" is shorthand for "a URI which, when dereferenced, is expected to produce that document as a representation".
IRI: an Internationalized Resource Identifier, as defined in [RFC3987] 🌏. before an IRI found in a document gets used by HTTP, it gets converted to a URI first. see Section 4.1.
Resource: a network-accessible data object or service that's identified by an IRI, as defined in [RFC2616] 🧩. [REC-webarch] has more on Resources if you're curious.
relation (or "relation of"): refers to the "rel" attribute value of an atom:link element 🔗.
Representation: an entity included with a request or response, as defined in [RFC2616] 📦.
Collection: a Resource that contains a set of Member Resources 🍓. Collections are represented as Atom Feeds. see Section 9.
Member (or Member Resource): a Resource whose IRI is listed in a Collection by an atom:link element with a relation of "edit" or "edit-media" 💜. see Section 9.1. the protocol has two kinds of Members:
- Entry Resource: Members of a Collection that are represented as Atom Entry Documents, as defined in [RFC4287] 📝.
- Media Resource: Members of a Collection that have representations other than Atom Entry Documents 🎬.
Media Link Entry: an Entry Resource that holds metadata about a Media Resource 🎞️. see Section 9.6.
Workspace: a named group of Collections 🗂️. see Section 8.1.
Service Document: a document that describes the location and capabilities of one or more Collections, grouped into Workspaces 🗺️. see Section 8.
Category Document: a document that describes the categories allowed in a Collection 🏷️. see Section 7.

4. Protocol Model ✨

okay so bestie, this is where the Atom Publishing Protocol starts getting really fun 🦋 It uses HTTP to publish and edit Resources, and it describes their state and metadata with Atom-formatted representations. 💅 It also lays out how Collections of Resources get organized, and it gives formats for discovering, grouping and categorizing them. literally the whole vibe is "organize all your stuff and make it findable" 🌸

4.1. Identity and Naming 🎀

okay so Atom Protocol documents can use IRIs [RFC3987] as well as URIs [RFC3986] to identify Resources. 🦋 Before an IRI in a document gets used by HTTP, it gets converted to a URI using the procedure in Section 3.1 of [RFC3987]. The conversion SHOULD be applied as late as possible, and that's just how the spec wants it 💖 Converting doesn't mean a new Resource gets created either 🙈 the IRI and the URI it turns into point at the same Resource, no cap.

the protocol cares about the formats of the representations and the actions you can do on the IRIs inside them, but it does NOT care what your URIs look like 🌈 HTTP [RFC2616] says each server controls its own URI space, and this protocol doesn't add any extra rules on top of that 👑

4.2. Documents and Resource Classification 🧚

a Resource whose IRI is listed in a Collection is called a Member Resource 💜 There are two kinds: Entry Resources and Media Resources ✨ Entry Resources are represented as Atom Entry Documents [RFC4287], and Media Resources can have representations in any media type at all 🫶 A Media Resource gets described inside a Collection with an Entry called a Media Link Entry. Here's the classification, bestie:

            Member Resources
                   |
            -----------------
           |                 |
     Entry Resources     Media Resources
           |
     Media Link Entry

the Atom Protocol also defines Collection Resources for managing and organizing both kinds of Member Resource 🔥 A Collection is represented by an Atom Feed Document, and a Collection Feed's Entries hold the IRIs of, and metadata about, the Collection's Member Resources 💅 A Collection Feed can have any number of Entries. They might cover every Member, or just an ordered subset of them (see Section 10.1). Here's a Collection with two Entries: the first holds the IRI of an Entry Resource, and the second holds the IRIs of a Media Resource and the Media Link Entry with its metadata 🦋

  Collection
     |
     o- Entry
     |    |
     |    o- Member Entry IRI (Entry Resource)
     |
     o- Entry
          |
          o- Member Entry IRI (Media Link Entry)
          |
          o- Media IRI        (Media Resource)

the Atom Protocol doesn't separate Feeds used for Collections from other Atom Feeds 🙈 The only way this spec tells you a Feed is a Collection Feed is if its IRI shows up in a Service Document. iykyk 🌸

Service Documents represent server-defined groups of Collections, and they kick off the process of creating and editing Resources 🎀 Those groups are called Workspaces. Workspaces have names but no IRIs, and there's no specified processing model for them 🫶 The Service Document can say which media types and which categories a Collection will accept. Two Workspaces, each describing the IRIs, acceptable media types, and categories for a Collection:

  Service
     o- Workspace
     |    |
     |    o- Collection
     |         |
     |         o- IRI, categories, media types
     |
     o- Workspace
          |
          o- Collection
               |
               o- IRI, categories, media types

4.3. Control and Publishing 💖

the Atom Publishing Protocol uses HTTP methods to author Member Resources like this:

GET retrieves a representation of a known Resource 💜
POST creates a new, dynamically named Resource 🌈 When the client submits non-Atom-Entry representations to a Collection for creation, two Resources always get created: a Media Entry for the requested Resource, and a Media Link Entry for metadata about the Resource that appears in the Collection ✨
PUT edits a known Resource 🫶 It is NOT used for Resource creation 🙅
DELETE removes a known Resource 💀

the Atom Protocol only covers creating, editing, and deleting Entry and Media Resources 🦋 Other Resources could get created, edited, or deleted as a result of manipulating a Collection, but how many there are, their media types, and what Atom Protocol operations do to them are all outside this spec 🌸

Since all client-server interaction is defined in terms of HTTP, [RFC2616] should be consulted for any areas this spec doesn't cover 📚

4.4. Client Implementation Considerations 🍓

the Atom Protocol puts very few restrictions on servers 🙈 Unless a constraint is specified here, servers can be expected to vary in behavior, especially when it comes to manipulating the Atom Entries clients send 💅 For example, this spec only defines expected Collection behavior for GET and POST, but that does NOT mean PUT, DELETE, PROPPATCH, and others are forbidden on Collection Resources. It just means this spec doesn't define what the server's response to them would be 😭 Similarly, even though some HTTP status codes get mentioned explicitly, clients ought to be prepared to handle any status code from a server 🔥 Servers can choose to accept, reject, delay, moderate, censor, reformat, translate, relocate, or re-categorize the content submitted to them 💀 Only some of these choices get relayed straight back to the client in responses, and others might only show up later, in the feed or in published entries 🫠 The same series of requests sent to two different publishing sites can produce different HTTP responses, different feeds, or different entry contents, so be ready 🧚

so client software has to be written flexibly to accept what the server decides its submissions turned into ✨ Any server response or content modification that this spec or HTTP [RFC2616] doesn't explicitly forbid is therefore allowed 👑

5. Protocol Operations 🎀

specific HTTP status codes show up in the interaction diagrams below, but an AtomPub client should be prepared to handle any status code 💖 For example, a PUT to a Member URI could return "204 No Content", which still means success 🫶

5.1. Retrieving a Service Document 🦋

  Client                                     Server
    |                                           |
    |  1.) GET to Service Document URI          |
    |------------------------------------------>|
    |                                           |
    |  2.) 200 Ok                               |
    |      Service Document                     |
    |<------------------------------------------|
    |                                           |

the client sends a GET request to the URI of the Service Document 💌
the server responds with a Service Document listing the IRIs of a group of Collections and the capabilities those Collections support. The content can vary based on aspects of the client request, including, but not limited to, authentication credentials 🔐

5.2. Listing Collection Members 🌸

to list a Collection's Members, the client sends a GET request to the Collection's URI. An Atom Feed Document comes back with Entries containing the IRIs of Member Resources 🧚 The returned Feed may describe all of the Members or only a partial list (see Section 10) ✨

  Client                          Server
    |                                |
    |  1.) GET to Collection URI     |
    |------------------------------->|
    |                                |
    |  2.) 200 Ok                    |
    |      Atom Feed Document        |
    |<-------------------------------|
    |                                |

the client sends a GET request to the Collection's URI 🫶
the server responds with an Atom Feed Document containing the IRIs of the Collection Members 💜

5.3. Creating a Resource 💅

  Client                                     Server
    |                                           |
    |  1.) POST to Collection URI               |
    |      Member Representation                |
    |------------------------------------------>|
    |                                           |
    |  2.) 201 Created                          |
    |      Location: Member Entry URI           |
    |<------------------------------------------|
    |                                           |

the client POSTs a representation of the Member to the Collection's URI 🦋
if the Member Resource was created successfully, the server responds with status 201 and a Location header containing the IRI of the newly created Entry Resource 🎉 Media Resources could have been created too, and their IRIs can be found through the Entry Resource. See Section 9.6 for more details 🌈

5.4. Editing a Resource 🍓

once a Resource has been created and its Member URI is known, that URI can be used to retrieve, edit, and delete the Resource 💖 Section 11 describes the extensions to the Atom Syndication Format that the Atom Protocol uses for editing 🧚

5.4.1. Retrieving a Resource 🌸

  Client                                     Server
    |                                           |
    |  1.) GET to Member URI                    |
    |------------------------------------------>|
    |                                           |
    |  2.) 200 Ok                               |
    |      Member Representation                |
    |<------------------------------------------|
    |                                           |

the client sends a GET request to the URI of a Member Resource to retrieve its representation 💌
the server responds with the representation of the Member Resource ✨

5.4.2. Editing a Resource 🦋

  Client                                     Server
    |                                           |
    |  1.) PUT to Member URI                    |
    |      Member Representation                |
    |------------------------------------------>|
    |                                           |
    |  2.) 200 OK                               |
    |<------------------------------------------|

the client sends a PUT request to store a representation of a Member Resource 💖
if the request is successful, the server responds with status 200 👑

5.4.3. Deleting a Resource ✨

Deleting is so simple it's almost iconic 💅 Here's the whole flow:

   Client                                     Server
     |                                           |
     |  1.) DELETE to Member URI                 |
     |------------------------------------------>|
     |                                           |
     |  2.) 200 OK                               |
     |<------------------------------------------|
     |                                           |

The client sends a DELETE request to the URI of a Member Resource. 🗑️
If the deletion works, the server responds with a status code of 200. ✅

Media Resources are a whole different vibe, so they get their own deletion process. Check out Section 9.4 for the deets 🦋

5.5. Use of HTTP Response Codes

The Atom Protocol uses the response status codes from HTTP to tell you whether an operation worked or flopped 💖 For the full scoop on what each status code means, read the HTTP specification [RFC2616].

Quick tip from the spec, bestie: according to HTTP, HTTP 4xx and 5xx response entities SHOULD include a human-readable explanation of the error. Your future self will thank you 🫶

6. Protocol Documents

6.1. Document Types

There are two kinds of documents in this spec: Category Documents and Service Documents 🎀

A Category Document (Section 7) holds lists of categories described with the atom:category element from the Atom Syndication Format (see Section 4.2.2 of [RFC4287]).

A Service Document (Section 8) groups the available Collections into Workspaces 🧚

The namespace name [REC-xml-names] for both kinds of document is:

http://www.w3.org/2007/app

Atom Publishing Protocol XML Documents MUST be "namespace-well-formed" as specified in Section 7 of [REC-xml-names]. Non-negotiable, periodt 💅

This spec uses the prefix app: for the namespace name. The prefix atom: stands for http://www.w3.org/2005/Atom, which is the namespace name of the Atom Syndication Format [RFC4287]. These prefixes don't carry any semantic weight, so they're just vibes 🌸

This spec doesn't define any DTDs for Atom Protocol formats, so it doesn't require them to be "valid" in the sense used by [REC-xml]. No DTD drama here 🙈

6.2. Document Extensibility

Unrecognized markup in an Atom Publishing Protocol document counts as "foreign markup," as defined in Section 6 of the Atom Syndication Format [RFC4287]. Foreign markup is welcome anywhere inside a Category or Service Document, unless it's explicitly banned 🌈 Processors that run into foreign markup MUST NOT stop processing and MUST NOT signal an error. Clients SHOULD preserve foreign markup when they send such documents along, because it's rude to delete someone's stuff 💜

The namespace name http://www.w3.org/2007/app is reserved for forward-compatible revisions of the Category and Service Document types. That doesn't stop anyone from adding elements and attributes that conformant processors might not recognize. Still, any unrecognized markup from the http://www.w3.org/2007/app namespace MUST be treated as foreign markup. Plot twist, but a good one ✨

7. Category Documents

Category Documents hold lists of categories described with the atom:category element from the Atom Syndication Format [RFC4287]. Categories can also show up in Service Documents, where they show which categories a Collection allows (see Section 8.3.6) 🍓

Category Documents are identified with the application/atomcat+xml media type (see Section 16.1).

7.1. Example

<?xml version="1.0" ?>
<app:categories
    xmlns:app="http://www.w3.org/2007/app"
    xmlns:atom="http://www.w3.org/2005/Atom"
    fixed="yes" scheme="http://example.com/cats/big3">
  <atom:category term="animal" />
  <atom:category term="vegetable" />
  <atom:category term="mineral" />
</app:categories>

This Category Document has three atom:category elements with the terms 'animal', 'vegetable', and 'mineral' 🦖 None of the categories use the label attribute from [RFC4287]. They all inherit the scheme attribute http://example.com/cats/big3 from the app:categories element. So if 'mineral' showed up in an Atom Entry or Feed Document, it would look like this:

<atom:category scheme="http://example.com/cats/big3" term="mineral"/>

7.2. Element Definitions

7.2.1. The "app:categories" Element

The root of a Category Document is the app:categories element 👑 An app:categories element can hold zero or more atom:category elements from the Atom Syndication Format [RFC4287] namespace (http://www.w3.org/2005/Atom).

An atom:category child element with no scheme attribute inherits that attribute from its app:categories parent. An atom:category child element that already has a scheme attribute does not inherit the scheme value from its app:categories parent element. Each category keeps its own identity, bestie 🫶

atomCategory =
    element atom:category {
       atomCommonAttributes,
       attribute term { text },
       attribute scheme { atomURI }?,
       attribute label { text }?,
       undefinedContent
    }

appInlineCategories =
    element app:categories {
        attribute fixed { "yes" | "no" }?,
        attribute scheme { atomURI }?,
        (atomCategory*,
        undefinedContent)
    }

appOutOfLineCategories =
    element app:categories {
        attribute href { atomURI },
        undefinedContent
    }

appCategories = appInlineCategories | appOutOfLineCategories

7.2.1.1. Attributes of "app:categories"

The app:categories element can have a fixed attribute, with a value of either "yes" or "no." This tells you whether the list of categories is a fixed set or an open one. If the fixed attribute is missing, it's the same as having fixed set to "no" 🌸

Or, the app:categories element MAY contain an href attribute, whose value MUST be an IRI reference that identifies a Category Document. If the href attribute is there, the app:categories element MUST be empty and MUST NOT have the fixed or scheme attributes. It's either a pointer or a list, never both, iykyk 🦋

8. Service Documents

Before authoring can start, a client has to discover what Collections are available and where they live 🔍 Service Documents exist to make that discovery work.

How Service Documents get discovered is not defined in this specification.

Service Documents are identified with the application/atomsvc+xml media type (see Section 16.2).

8.1. Workspaces

A Service Document groups Collections into Workspaces. Operations on Workspaces, like creating or deleting them, aren't defined by this spec. This spec gives Workspaces no meaning at all, so a Workspace doesn't imply any particular processing assumptions. Zero drama 🧁

There's no requirement that a server support multiple Workspaces. Also, a Collection MAY appear in more than one Workspace. Double-booked and iconic 💖

8.2. Example

<?xml version="1.0" encoding='utf-8'?>
<service xmlns="http://www.w3.org/2007/app"
         xmlns:atom="http://www.w3.org/2005/Atom">
  <workspace>
    <atom:title>Main Site</atom:title>
    <collection
        href="http://example.org/blog/main" >
      <atom:title>My Blog Entries</atom:title>
      <categories
         href="http://example.com/cats/forMain.cats" />
    </collection>
    <collection
        href="http://example.org/blog/pic" >
      <atom:title>Pictures</atom:title>
      <accept>image/png</accept>
      <accept>image/jpeg</accept>
      <accept>image/gif</accept>
    </collection>
  </workspace>
  <workspace>
    <atom:title>Sidebar Blog</atom:title>
    <collection
        href="http://example.org/sidebar/list" >
      <atom:title>Remaindered Links</atom:title>
      <accept>application/atom+xml;type=entry</accept>
      <categories fixed="yes">
        <atom:category
          scheme="http://example.org/extra-cats/"
          term="joke" />
        <atom:category
          scheme="http://example.org/extra-cats/"
          term="serious" />

      </categories>
    </collection>
  </workspace>
</service>

This Service Document has two Workspaces, and it's giving organized 🗂️ The first one is "Main Site," with two Collections: "My Blog Entries" and "Pictures," at "http://example.org/blog/main" and "http://example.org/blog/pic." The "Pictures" Collection has three accept elements listing the image types the client can send to make new Media Resources (entries tied to Media Resources are covered in Section 9.6) 📸

The second Workspace is "Sidebar Blog," with one Collection called "Remaindered Links" at "http://example.org/sidebar/list." That Collection has an accept element with "application/atom+xml;type=entry," which says it'll take Atom Entries from a client ✨

In both Entry Collections, the categories element lists the categories available for Member Entries. For "My Blog Entries," the list comes in through the href attribute. "Sidebar Blog" puts its category list right inside the Service Document, but marks it as fixed. That's the server basically saying "POST Entries using only these two categories, please" 💅

8.3. Element Definitions

8.3.1. The "app:service" Element

The root of a Service Document is the app:service element 👑

The app:service element is the container for service information tied to one or more Workspaces. An app:service element MUST contain one or more app:workspace elements.

namespace app = "http://www.w3.org/2007/app"
start = appService

appService =
   element app:service {
      appCommonAttributes,
      ( appWorkspace+
        & extensionElement* )
   }

8.3.2. The "app:workspace" Element

Workspaces are server-defined groups of Collections 🏠 The app:workspace element holds zero or more app:collection elements, which describe the Collections of Resources you can edit.

appWorkspace =
   element app:workspace {
      appCommonAttributes,
      ( atomTitle
        & appCollection*
        & extensionSansTitleElement* )
   }

atomTitle = element atom:title { atomTextConstruct }

8.3.2.1. The "atom:title" Element

The app:workspace element MUST contain one atom:title element (as defined in [RFC4287]), which gives a human-readable title for the Workspace 🎀

8.3.3. The "app:collection" Element

The app:collection element describes a Collection. The app:collection element MUST contain one atom:title element.

The app:collection element MAY contain any number of app:accept elements, which show the types of representations the Collection accepts. The order of those elements doesn't matter 🦋

The app:collection element MAY contain any number of app:categories elements.

appCollection =
   element app:collection {
      appCommonAttributes,
      attribute href { atomURI  },
      ( atomTitle
        & appAccept*
        & appCategories*
        & extensionSansTitleElement* )
   }

8.3.3.1. The "href" Attribute

The app:collection element MUST contain an href attribute, whose value gives the IRI of the Collection 🌈

8.3.3.2. The "atom:title" Element

The atom:title element is defined in [RFC4287] and gives a human-readable title for the Collection 💜

8.3.4. The "app:accept" Element

okay so the content of an "app:accept" element is a media range as defined in [RFC2616] 💖 and it tells you what kind of representation can be POSTed to a Collection 📮

app:accept is giving major HTTP Accept request-header [RFC2616] energy 🦋 media type parameters are allowed, but there is zero preference drama here. "accept-params" or "q" arguments, as specified in Section 14.1 of [RFC2616], are not significant 💅

White space (as defined in [REC-xml]) around the app:accept element's media range is insignificant and MUST be ignored ✨

a value of "application/atom+xml;type=entry" MAY appear in any app:accept list of media ranges, and it means Atom Entry Documents can be POSTed to the Collection 🌸 if there's no app:accept element at all, clients SHOULD treat that as the same thing as an app:accept element with the content "application/atom+xml;type=entry" 🫶

if one app:accept element exists and is empty, clients SHOULD assume the Collection does not support creating new Entries 🙈

appAccept =
   element app:accept {
         appCommonAttributes,
         ( text? )
   }

8.3.5. Usage in Atom Feed Documents

the app:collection element MAY appear as a child of an atom:feed or atom:source element in an Atom Feed Document 🧚 its content identifies a Collection that new Entries can be added through so they show up in the feed 🍓 when it sits inside an atom:feed or atom:source element, app:collection is treated as foreign markup as defined in Section 6 of [RFC4287] 💜

8.3.6. The "app:categories" Element

the "app:categories" element gives you a list of the categories that can be applied to the members of a Collection 🎀 see Section 7.2.1 for the full definition of app:categories 📖

the server MAY reject attempts to create or store members whose categories aren't in its categories list 🚫 a Collection that says its category set is open SHOULD NOT reject otherwise-fine members just because their categories aren't on that list 🌈 no app:categories element means category handling for the Collection is unspecified 🤷‍♀️ and a "fixed" category list with zero categories means the Collection doesn't accept category data at all 💀

9. Creating and Editing Resources 🦋

9.1. Member URIs

the Member URI lets clients retrieve, edit, and delete a Member Resource using HTTP's GET, PUT, and DELETE methods 🔥 Entry Resources are represented as Atom Entry documents 📝

Member URIs show up in two places 👀 first, they come back in a Location header after a successful Resource creation using POST, which we'll get into in Section 9.2 below 💌 second, they can appear in a Collection Feed's Entries as atom:link elements with a link relation of "edit" 🔗

a Member Entry SHOULD contain an atom:link element with a link relation of "edit", which points to the Member URI 💖

9.2. Creating Resources with POST

to add members to a Collection, clients send POST requests to the URI of the Collection 🚀

a successful member creation is signalled with a 201 ("Created") response code ✨ when the Collection responds with a 201, it SHOULD also return a response body, and that body MUST be an Atom Entry Document representing the newly created Resource 🎀 the server is free to alter the POSTed Entry (for example, by changing the content of the atom:id element), so getting the Entry back is super useful for the client, since it can line up the client's and server's views of the new Entry 🧩

when a Member Resource is created, its Member Entry URI MUST be returned in a Location header in the Collection's response 📍

if the creation request contained an Atom Entry Document, and the response from the server has a Content-Location header that matches the Location header character-for-character, then the client is authorized to read the response entity as a complete representation of the newly created Entry 🥹 without a matching Content-Location header, the client MUST NOT assume the returned entity is a complete representation of the created Resource 🙅‍♀️

the request body sent with the POST doesn't have to be an Atom Entry 📸 it could be a picture or a movie, for example 🎬 Collections MAY return a 415 ("Unsupported Media Type") response to say the media type of the POSTed entity isn't allowed or supported by the Collection 🚫 for the tea on creating that kind of content, see Section 9.6 ☕

9.2.1. Example

below, the client sends a POST request containing an Atom Entry representation using the URI of the Collection 💅

    POST /edit/ HTTP/1.1
    Host: example.org
    User-Agent: Thingio/1.0
    Authorization: Basic ZGFmZnk6c2VjZXJldA==
    Content-Type: application/atom+xml;type=entry
    Content-Length: nnn
    Slug: First Post

    <?xml version="1.0"?>
    <entry xmlns="http://www.w3.org/2005/Atom">
      <title>Atom-Powered Robots Run Amok</title>
      <id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a</id>
      <updated>2003-12-13T18:30:02Z</updated>
      <author><name>John Doe</name></author>
      <content>Some text.</content>
    </entry>

the server signals a successful creation with a 201 ✨ the response includes a Location header pointing to the Member Entry URI of the Atom Entry, plus a representation of that Entry in the body of the response 🎉

    HTTP/1.1 201 Created
    Date: Fri, 7 Oct 2005 17:17:11 GMT
    Content-Length: nnn
    Content-Type: application/atom+xml;type=entry;charset="utf-8"
    Location: http://example.org/edit/first-post.atom
    ETag: "c180de84f991g8"
    <?xml version="1.0"?>
    <entry xmlns="http://www.w3.org/2005/Atom">
      <title>Atom-Powered Robots Run Amok</title>
      <id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a</id>
      <updated>2003-12-13T18:30:02Z</updated>
      <author><name>John Doe</name></author>
      <content>Some text.</content>
      <link rel="edit"
          href="http://example.org/edit/first-post.atom"/>
    </entry>

the Entry the Collection creates and sends back might not match the Entry the client POSTed 🙃 a server MAY change the values of various elements in the Entry, like the atom:id, atom:updated, and atom:author values, and MAY choose to remove or add other elements and attributes, or change element content and attribute values 🌀

9.3. Editing Resources with PUT

to edit a Member Resource, a client sends a PUT request to its Member URI, as specified in [RFC2616] 🖊️

to avoid accidentally losing data when editing Member Entries or Media Link Entries, an Atom Protocol client SHOULD preserve all metadata that hasn't been intentionally modified, including unknown foreign markup as defined in Section 6 of [RFC4287] 🛡️ protect that metadata, bestie 🫶

9.4. Deleting Resources with DELETE

to delete a Member Resource, a client sends a DELETE request to its Member URI, as specified in [RFC2616] 🗑️ deleting a Media Link Entry SHOULD result in the deletion of the corresponding Media Resource 💀

9.5. Caching and Entity Tags

implementers are advised to pay attention to cache controls and to use the mechanisms HTTP offers when editing Resources, especially entity-tags as outlined in [NOTE-detect-lost-update] 🧠 clients aren't assured to get the most recent representations of Collection Members using GET if the server is letting intermediaries cache them 👻

9.5.1. Example

below, the client creates a Member Entry using POST 📝

    POST /myblog/entries HTTP/1.1
    Host: example.org
    Authorization: Basic ZGFmZnk6c2VjZXJldA==
    Content-Type: application/atom+xml;type=entry
    Content-Length: nnn
    Slug: First Post

    <?xml version="1.0" ?>
    <entry xmlns="http://www.w3.org/2005/Atom">
      <title>Atom-Powered Robots Run Amok</title>
      <id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a</id>
      <updated>2007-02-123T17:09:02Z</updated>
      <author><name>Captain Lansing</name></author>
      <content>It's something moving... solid metal</content>
    </entry>

the server signals a successful creation with a 201 and returns an ETag header in the response 🏷️ because, in this case, the server returned a Content-Location header and a Location header with the same value, the returned Entry representation can be understood as a complete representation of the newly created Entry (see Section 9.2) 💖

    HTTP/1.1 201 Created
    Date: Fri, 23 Feb 2007 21:17:11 GMT
    Content-Length: nnn
    Content-Type: application/atom+xml;type=entry
    Location: http://example.org/edit/first-post.atom
    Content-Location: http://example.org/edit/first-post.atom
    ETag: "e180ee84f0671b1"

    <?xml version="1.0" ?>
    <entry xmlns="http://www.w3.org/2005/Atom">
      <title>Atom-Powered Robots Run Amok</title>
      <id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a</id>
      <updated>2007-02-123T17:09:02Z</updated>
      <author><name>Captain Lansing</name></author>
      <content>It's something moving... solid metal</content>
    </entry>

if it wants, the client can use the returned ETag value to later build a "Conditional GET" as defined in [RFC2616] 🧁 in this case, before editing, the client sends the ETag value for the Member using the If-None-Match header 🕵️‍♀️

    GET /edit/first-post.atom HTTP/1.1
    Host: example.org
    Authorization: Basic ZGFmZnk6c2VjZXJldA==
    If-None-Match: "e180ee84f0671b1"

if the Entry hasn't been modified, the response is a 304 ("Not Modified") 🙌 this lets the client check whether it still has the most recent representation of the Entry at editing time 🔍

    HTTP/1.1 304 Not Modified
    Date: Sat, 24 Feb 2007 13:17:11 GMT

after editing, the client can PUT the Entry and send the ETag entity value in an If-Match header, which tells the server to accept the entry only if the entity value sent still matches the server's 🤞

    PUT /edit/first-post.atom HTTP/1.1
    Host: example.org
    Authorization: Basic ZGFmZnk6c2VjZXJldA==
    Content-Type: application/atom+xml;type=entry
    Content-Length: nnn
    If-Match: "e180ee84f0671b1"

    <?xml version="1.0" ?>
    <entry xmlns="http://www.w3.org/2005/Atom">
      <title>Atom-Powered Robots Run Amok</title>
      <id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a</id>
      <updated>2007-02-24T16:34:06Z</updated>
      <author><name>Captain Lansing</name></author>
      <content>Update: it's a hoax!</content>
    </entry>

but the server has since received a more recent copy than the client's, so it responds with a 412 ("Precondition Failed") 😬

    HTTP/1.1 412 Precondition Failed
    Date: Sat, 24 Feb 2007 16:34:11 GMT

this tells the client that the server has a more recent version of the Entry and won't allow the sent entity to be stored 🥀

9.6. Media Resources and Media Link Entries 📸✨

okay so a client can POST Media Resources as well as Entry Resources to a Collection 💖 If a server accepts such a request, then it MUST create two new Resources -- one that corresponds to the entity sent in the request, called the Media Resource, and an associated Member Entry, called the Media Link Entry. Media Link Entries are represented as Atom Entries, and they appear in the Collection 🎀

The Media Link Entry holds the metadata and IRI of the (perhaps non-textual) Media Resource 🦋 So the Media Link Entry makes the metadata about the Media Resource separately available for retrieval and alteration. It's giving organized 💅

The server can signal the media types it will accept using the app:accept element in the Service Document, as specified in Section 8.3.4. 🧚

Successful responses to creation requests MUST include the URI of the Media Link Entry in the Location header. The Media Link Entry SHOULD contain an atom:link element with a link relation of "edit-media" that contains the Media Resource IRI. The Media Link Entry MUST have an atom:content element with a "src" attribute. The value of the "src" attribute is an IRI for the newly created Media Resource. It is OPTIONAL that the IRI of the "src" attribute on the atom:content element be the same as the Media Resource IRI. For example, the "src" attribute value might instead be a link into a static cache or content distribution network and not the Media Resource IRI 🌸

Implementers are asked to note that [RFC4287] specifies that Atom Entries MUST contain an atom:summary element 👀 So, upon successful creation of a Media Link Entry, a server MAY choose to populate the atom:summary element (as well as any other mandatory elements such as atom:id, atom:author, and atom:title) with content derived from the POSTed entity or from any other source. A server might not allow a client to modify the server-selected values for these elements. no cap, that's a lot of required stuff 😭

For Resource creation, this specification only defines cases where the POST body has an Atom Entry entity declared as an Atom media type ("application/atom+xml"), or a non-Atom entity declared as a non-Atom media type. When a client is POSTing an Atom Entry to a Collection, it may use a media type of either "application/atom+xml" or "application/atom +xml;type=entry". This specification does not specify any request semantics or server behavior in the case where the POSTed media type is "application/atom+xml" but the body is something other than an Atom Entry. In particular, what happens on POSTing an Atom Feed Document to a Collection using the "application/atom+xml" media type is undefined. not me reading "undefined" like it's a plot twist 🙈

The Atom Protocol does not specify a means to create multiple representations of the same Resource (for example, a PNG and a JPG of the same image) either on creation or editing. 🖼️

9.6.1. Examples 🌈

Below, the client sends a POST request containing a PNG image to the URI of a Collection that accepts PNG images 📮

POST /edit/ HTTP/1.1
Host: media.example.org
Content-Type: image/png
Slug: The Beach
Authorization: Basic ZGFmZnk6c2VjZXJldA==
Content-Length: nnn

...binary data...

The server signals a successful creation with a status code of 201. The response includes a Location header indicating the Member URI of the Media Link Entry, plus a representation of that entry in the body of the response. The Media Link Entry includes a content element with a "src" attribute. It also contains a link with a link relation of "edit-media", specifying the IRI to be used for modifying the Media Resource. ✨

HTTP/1.1 201 Created
Date: Fri, 7 Oct 2005 17:17:11 GMT
Content-Length: nnn
Content-Type: application/atom+xml;type=entry;charset="utf-8"
Location: http://example.org/media/edit/the_beach.atom

<?xml version="1.0"?>
<entry xmlns="http://www.w3.org/2005/Atom">
  <title>The Beach</title>
  <id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a</id>
  <updated>2005-10-07T17:17:08Z</updated>
  <author><name>Daffy</name></author>
  <summary type="text" />
  <content type="image/png"
     src="http://media.example.org/the_beach.png"/>
  <link rel="edit-media"
     href="http://media.example.org/edit/the_beach.png" />
  <link rel="edit"
     href="http://example.org/media/edit/the_beach.atom" />
</entry>

Later, the client sends a PUT request containing the new PNG using the URI indicated in the Media Link Entry's "edit-media" link 🦋

PUT /edit/the_beach.png HTTP/1.1
Host: media.example.org
Content-Type: image/png
Authorization: Basic ZGFmZnk6c2VjZXJldA==
Content-Length: nnn

...binary data...

The server signals a successful edit with a status code of 200. 🥳

HTTP/1.1 200 Ok
Date: Fri, 8 Oct 2006 17:17:11 GMT

The client can edit the metadata for the picture 🎀 First, GET the Media Link Entry:

GET /media/edit/the_beach.atom HTTP/1.1
Host: example.org
Authorization: Basic ZGFmZnk6c2VjZXJldA==

The Media Link Entry is returned 💌

HTTP/1.1 200 Ok
Date: Fri, 7 Oct 2005 17:18:11 GMT
Content-Length: nnn
Content-Type: application/atom+xml;type=entry;charset="utf-8"
ETag: "c181bb840673b5"

<?xml version="1.0"?>
<entry xmlns="http://www.w3.org/2005/Atom">
  <title>The Beach</title>
  <id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a</id>
  <updated>2005-10-07T17:17:08Z</updated>
  <author><name>Daffy</name></author>
  <summary type="text" />
  <content type="image/png"
     src="http://media.example.org/the_beach.png"/>
  <link rel="edit-media"
     href="http://media.example.org/edit/the_beach.png" />
  <link rel="edit"
     href="http://example.org/media/edit/the_beach.atom" />
</entry>

The metadata can be updated, in this case to add a summary, and then PUT back to the server 🌸

PUT /media/edit/the_beach.atom HTTP/1.1
Host: example.org
Authorization: Basic ZGFmZnk6c2VjZXJldA==
Content-Type: application/atom+xml;type=entry
Content-Length: nnn
If-Match: "c181bb840673b5"

<?xml version="1.0"?>
<entry xmlns="http://www.w3.org/2005/Atom">
  <title>The Beach</title>
  <id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a</id>
  <updated>2005-10-07T17:17:08Z</updated>
  <author><name>Daffy</name></author>
  <summary type="text">
      A nice sunset picture over the water.
  </summary>
  <content type="image/png"
     src="http://media.example.org/the_beach.png"/>
  <link rel="edit-media"
     href="http://media.example.org/edit/the_beach.png" />
  <link rel="edit"
     href="http://example.org/media/edit/the_beach.atom" />
</entry>

The update was successful 🎉

HTTP/1.1 200 Ok
Date: Fri, 7 Oct 2005 17:19:11 GMT
Content-Length: 0

Multiple Media Resources can be added to the Collection 🌷

POST /edit/ HTTP/1.1
Host: media.example.org
Content-Type: image/png
Slug: The Pier
Authorization: Basic ZGFmZnk6c2VjZXJldA==
Content-Length: nnn

...binary data...

The Resource is created successfully 🥹

HTTP/1.1 201 Created
Date: Fri, 7 Oct 2005 17:17:11 GMT
Content-Length: nnn
Content-Type: application/atom+xml;type=entry;charset="utf-8"
Location: http://example.org/media/edit/the_pier.atom
<?xml version="1.0"?>
<entry xmlns="http://www.w3.org/2005/Atom">
  <title>The Pier</title>
  <id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efe6b</id>
  <updated>2005-10-07T17:26:43Z</updated>
  <author><name>Daffy</name></author>
  <summary type="text" />
  <content type="image/png"
     src="http://media.example.org/the_pier.png"/>
  <link rel="edit-media"
     href="http://media.example.org/edit/the_pier.png" />
  <link rel="edit"
     href="http://example.org/media/edit/the_pier.atom" />
</entry>

The client can now create a new Atom Entry in the blog Entry Collection that references the two newly created Media Resources 🍓

POST /blog/ HTTP/1.1
Host: example.org
Content-Type: application/atom+xml;type=entry
Slug: A day at the beach
Authorization: Basic ZGFmZnk6c2VjZXJldA==
Content-Length: nnn

<?xml version="1.0"?>
<entry xmlns="http://www.w3.org/2005/Atom">
  <title>A fun day at the beach</title>
  <id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6b</id>
  <updated>2005-10-07T17:40:02Z</updated>
  <author><name>Daffy</name></author>
  <content type="xhtml">
      <xhtml:div xmlns:xhtml="http://www.w3.org/1999/xhtml">
          <xhtml:p>We had a good day at the beach.
              <xhtml:img alt="the beach"
                  src="http://media.example.org/the_beach.png"/>
          </xhtml:p>
          <xhtml:p>Later we walked down to the pier.
              <xhtml:img  alt="the pier"
                  src="http://media.example.org/the_pier.png"/>
          </xhtml:p>
      </xhtml:div>
  </content>
</entry>

The Resource is created successfully 🎀

HTTP/1.1 200 Ok
Date: Fri, 7 Oct 2005 17:20:11 GMT
Content-Length: nnn
Content-Type: application/atom+xml;type=entry;charset="utf-8"
Location: http://example.org/blog/atom/a-day-at-the-beach.atom

<?xml version="1.0"?>
<entry xmlns="http://www.w3.org/2005/Atom">
  <title>A fun day at the beach</title>
  <id>http://example.org/blog/a-day-at-the-beach.xhtml</id>
  <updated>2005-10-07T17:43:07Z</updated>
  <author><name>Daffy</name></author>
  <content type="xhtml">
      <xhtml:div xmlns:xhtml="http://www.w3.org/1999/xhtml">
          <xhtml:p>We had a good day at the beach.
              <xhtml:img alt="the beach"
                 src="http://media.example.org/the_beach.png"/>
          </xhtml:p>
          <xhtml:p>Later we walked down to the pier.
              <xhtml:img alt="the pier"
                 src="http://media.example.org/the_pier.png"/>
          </xhtml:p>
      </xhtml:div>
  </content>
  <link rel="edit"
    href="http://example.org/blog/edit/a-day-at-the-beach.atom"/>
  <link rel="alternate" type="text/html"
    href="http://example.org/blog/a-day-at-the-beach.html"/>
</entry>

Note that the returned Entry contains a link with a relation of "alternate" that points to the associated HTML page that was created -- this is not required by this specification, but it's included to show the kinds of changes a server can make to an Entry. the server really said "here's your post, plus a little bonus link" and honestly iconic 👑🦋

9.7. The Slug Header ✨

okay so Slug is an HTTP entity-header, and if a client sends it in a POST to a Collection, that's basically the client going "hey, please use this value as part of the URIs for the Entry or Media Resource being created" 💅

Servers MAY use the value of the Slug header when they create the Member URI for the new Resource. For example, they could use some or all of the words in the value for the last URI segment 🌸 Servers MAY also use the value for the atom:id, or as the title of a Media Link Entry (see Section 9.6). 🦋

Servers MAY totally ignore the Slug entity-header 🙈 Servers MAY also change the header value before using it. A server might filter out some characters, swap accented letters for non-accented ones, replace spaces with underscores, change the case, and so on. Main character server energy 👑

9.7.1. Slug Header Syntax

The syntax of the Slug header is defined using the augmented BNF syntax from Section 2.1 of [RFC2616]:

LWS      = <defined in Section 2.2 of [RFC2616]>
slugtext = %x20-7E | LWS
Slug     = "Slug" ":" *slugtext

The field value is the percent-encoded value of the UTF-8 encoding of the character sequence you want to include. (Section 2.1 of [RFC3986] explains percent encoding, and [RFC3629] explains UTF-8 encoding 🧚)

Implementation note: to make the field value from a character sequence, first encode it with UTF-8, then percent-encode every octet outside the ranges %20-24 and %26-7E. (%25 is the ASCII encoding of "%", so it needs to be escaped too 🎀) To read the field value, first undo the percent encoding, then run the resulting octets through a UTF-8 decoding process. Literally so detailed, I'm obsessed 😭

9.7.2. Example

Here's an example of the Slug header using percent-encoding to represent the Unicode character U+00E8 (LATIN SMALL LETTER E WITH GRAVE) 🍓

POST /myblog/entries HTTP/1.1
Host: example.org
Content-Type: image/png
Slug: The Beach at S%C3%A8te
Authorization: Basic ZGFmZnk6c2VjZXJldA==
Content-Length: nnn

...binary data...

For an example of the Slug header applied to creating an Entry Resource, see Section 9.2.1 ✨

10. Listing Collections 💖

Collection Resources MUST provide representations as Atom Feed Documents whose Entries contain the IRIs of the Members in the Collection. Also, no distinction is made between Collection Feeds and other kinds of Feeds. A Feed can act as a 'public' feed for subscriptions and as a Collection Feed at the same time, which is so iconic 🫶

Each Entry in the Feed Document SHOULD have an atom:link element with a relation of "edit" (see Section 11.1).

The Entries in the returned Atom Feed SHOULD be ordered by their "app:edited" property, with the most recently edited Entries first in document order. The app:edited value is NOT the same thing as the HTTP Last-Modified header, and you can't use it to figure out whether cached responses are still fresh. Don't mix those up, bestie 🙅‍♀️

Clients MUST NOT assume that an Atom Entry returned in the Feed is a full representation of an Entry Resource. They SHOULD do a GET on the URI of the Member Entry before editing it. For how cache control directives affect getting entries, see Section 9.5 🧐

10.1. Collection Partial Lists

Collections can hold huge numbers of Resources 📚 A client like a web spider or a web browser could get overwhelmed if a GET returned every Entry in a Collection, and the server could waste bandwidth and processing time generating a response nobody can handle. So servers MAY respond to Collection GET requests with a Feed Document that has a partial list of the Collection's members, plus a link to the next partial list feed if one exists. The first partial list returned MUST contain the most recently edited member Resources and MUST have an atom:link with a "next" relation whose "href" value is the URI of the next partial list of the Collection. That next partial list holds the next most recently edited set of Member Resources (and an atom:link to the following partial list, if there is one) 🎀

On top of "next", partial list feeds MAY contain link elements with "rel" attribute values of "previous", "first", and "last". These help you navigate the full set of entries in the Collection 🗺️

For example, say a client gets the URI "http://example.org/entries/go" for a Collection of Member Entries, and the server has a policy of not generating Feed Documents with more than 10 Entries. The Atom Feed Document for the Collection then acts as the first partial list in a set of 10 linked Feed Documents. The "first" relation points to the initial Feed Document in the set, and the "last" relation points to the final one. Inside each document, the "previous" and "next" link relations point to the preceding and following documents 💜

<feed xmlns="http://www.w3.org/2005/Atom">
  <link rel="first"
        href="http://example.org/entries/go" />
  <link rel="next"
        href="http://example.org/entries/2" />
  <link rel="last"
        href="http://example.org/entries/10" />
  ...
</feed>

The "previous" and "next" link elements for the partial list feed at "http://example.org/entries/2" look like this:

<feed xmlns="http://www.w3.org/2005/Atom">
  <link rel="first"
        href="http://example.org/entries/go" />
  <link rel="previous"
        href="http://example.org/entries/go" />
  <link rel="next"
        href="http://example.org/entries/3" />
  <link rel="last"
        href="http://example.org/entries/10" />
  ...
</feed>

10.2. The "app:edited" Element

The "app:edited" element is a Date construct (as defined by [RFC4287]). Its content tells you the last time an Entry was edited. If the entry hasn't been edited yet, the content shows when it was created ⏰ Atom Entry elements in Collection Documents SHOULD contain one app:edited element, and they MUST NOT contain more than one.

appEdited = element app:edited ( atomDateConstruct )

The server SHOULD change this element's value every time an Entry Resource or an associated Media Resource gets edited ✨

11. Atom Format Link Relation Extensions 🌈

11.1. The "edit" Link Relation

This specification adds the value "edit" to the Atom Registry of Link Relations (see Section 7.1 of [RFC4287]). The "edit" value says the href attribute is the IRI of an editable Member Entry. Inside an atom:entry, that href IRI can be used to retrieve, update, and delete the Resource that Entry represents. An atom:entry MUST NOT contain more than one "edit" link relation 🔒

11.2. The "edit-media" Link Relation

This specification adds the value "edit-media" to the Atom Registry of Link Relations (see Section 7.1 of [RFC4287]). Inside an atom:entry, the href attribute value is an IRI that can be used to modify a Media Resource associated with that Entry 🎞️

An atom:entry element MAY contain zero or more "edit-media" link relations. An atom:entry MUST NOT contain more than one atom:link element with a "rel" attribute value of "edit-media" that has the same "type" and "hreflang" attribute values. All "edit-media" link relations in the same Entry reference the same Resource. If a client finds multiple "edit-media" link relations in an Entry, it SHOULD pick a link based on its preferences for "type" and "hreflang". And if a client finds multiple "edit-media" link relations in an Entry but has no preference based on the "type" and "hreflang" attributes, it SHOULD pick the first "edit-media" link relation in document order 🧁

12. The Atom Format Type Parameter 🎀

The Atom Syndication Format [RFC4287] defines the "application/atom+xml" media type to identify both Atom Feed and Atom Entry Documents. Implementations have shown that Atom Feed and Entry Documents can have different processing models, and sometimes they need to be told apart. So this specification defines a "type" parameter to tell the two types of Atom documents apart 💅

12.1. The "type" parameter

This specification defines a new "type" parameter for use with the "application/atom+xml" media type. Its value is either "entry" or "feed".

Neither the parameter name nor its value are case sensitive 🔤

The value "entry" says the media type identifies an Atom Entry Document. The root element of the document MUST be atom:entry.

The value "feed" says the media type identifies an Atom Feed Document. The root element of the document MUST be atom:feed.

If the parameter isn't specified, the type is treated as unspecified, which means Atom processors have to look at the root element to work out what kind of Atom document it is 🔍

12.1.1. Conformance

New specifications MAY require that the "type" parameter be used to identify the Atom Document type. Producers of Atom Entry Documents SHOULD use the "type" parameter whether or not it's mandatory. Producers of Atom Feed Documents MAY use the parameter.

Atom processors that don't recognize the "type" parameter MUST ignore its value and look at the root element to determine the document type 🙃

Atom processors that DO recognize the "type" parameter SHOULD detect and report any inconsistencies between the parameter's value and the actual type of the document's root element 🚩

13. Atom Publishing Controls 🦋

This specification defines an Atom Format Structured Extension, as defined in Section 6 of [RFC4287], for publishing control inside the "http://www.w3.org/2007/app" namespace.

13.1. The "app:control" Element

namespace app = "http://www.w3.org/2007/app"

 pubControl =
    element app:control {
    atomCommonAttributes,
    pubDraft?
    & extensionElement
 }

 pubDraft =
   element app:draft { "yes" | "no" }

The "app:control" element MAY appear as a child of an atom:entry that is being created or updated through the Atom Publishing Protocol. The app:control element MUST appear only once in an Entry. It counts as foreign markup, as defined in Section 6 of [RFC4287] 🧩

The app:control element and its child elements MAY be included in Atom Feed or Entry Documents ✨

The app:control element can contain an "app:draft" element (defined below), and it can also contain extension elements as defined in Section 6 of [RFC4287] 🌸

13.1.1. The "app:draft" Element

Including an "app:draft" element is the client asking to control the visibility of a Member Resource. The server MAY ignore the app:draft element 🙈

The number of app:draft elements in app:control MUST be zero or one. The content of an app:draft element MUST be one of "yes" or "no". If the element contains "no", the client is asking for the Member Resource to be made publicly visible 👀 If the app:draft element isn't there at all, servers that support the extension MUST behave as though an app:draft element containing "no" had been sent. Hello, public by default 🌈

14. Securing the Atom Publishing Protocol ✨

okay bestie, the Atom Publishing Protocol is built on HTTP 🌸, so its authentication rules come from HTTP. Those are covered in Section 11 of [RFC2616], and you should read them if you want the full tea.

Using authentication to stop POSTing or editing by unknown or unauthorized clients is RECOMMENDED but not required 🔐. Without it, clients and servers are open to trivial spoofing, denial-of-service, and defacement attacks 😭. Honestly though, in some contexts that's an acceptable risk 🤷‍♀️.

The type of authentication is a local decision made by the server operator 💅. Clients will probably run into different auth schemes on different server deployments, so expect some variety 🎀.

At a minimum, client and server implementations MUST be capable of being configured to use HTTP Basic Authentication [RFC2617] in conjunction with a connection made with TLS 1.0 [RFC2246] or a subsequent standards-track version of TLS (such as [RFC4346]), supporting the conventions for using HTTP over TLS described in [RFC2818]. This is the bare minimum, so don't skip it 🙈.

The choice of authentication mechanism will impact interoperability 🦋. The minimum level above (Basic Authentication with TLS) is considered good practice for Internet applications at the time this specification was published, and it's sufficient for setting a baseline for interoperability. Implementers are encouraged to look into and use alternative mechanisms that are regarded as equivalently good or better at the time of deployment ✨. It is RECOMMENDED that clients be implemented in such a way that new authentication schemes can be deployed 🚀.

Because this protocol uses HTTP response status codes as the primary means of reporting the result of a request, servers are advised to respond to unauthorized or unauthenticated requests with an appropriate 4xx HTTP response code (e.g., 401 "Unauthorized" or 403 "Forbidden") in accordance with [RFC2617] 🙅‍♀️.

15. Security Considerations 🔥

The Atom Publishing Protocol is based on HTTP, so it's subject to the security considerations found in Section 15 of [RFC2616]. Real talk, the threats listed in this section apply to a lot of protocols that run under HTTP 😬.

The Atompub Working Group decided that the protection you get from running authenticated HTTP under TLS (as described in Section 14) is enough to handle many of the problems raised by the attacks listed in this section 🔒. Slay.

15.1. Denial of Service

Atom Publishing Protocol server implementations need to take adequate precautions so malicious clients can't eat up excessive server resources (CPU, memory, disk, etc.) 💀.

15.2. Replay Attacks

Atom Publishing Protocol server implementations are susceptible to replay attacks 😱. Specifically, this specification doesn't define a way to detect duplicate requests. Accidentally sent duplicates are indistinguishable from intentional and malicious replay attacks, so the server can't tell the difference 🙃.

15.3. Spoofing Attacks

Atom Publishing Protocol implementations are susceptible to a variety of spoofing attacks 🎭. Malicious clients might send Atom Entries with inaccurate information anywhere in the document 🚩.

15.4. Linked Resources

Atom Feed and Entry Documents can contain XML External Entities as defined in Section 4.2.2 of [REC-xml] 🧚. Atom implementations are not required to load external entities. External entities are subject to the same security concerns as any network operation, and they can change the semantics of an Atom document 😬. The same issues exist for Resources linked to by Atom elements such as atom:link and atom:content 🔗.

15.5. Digital Signatures and Encryption

Atom Entry and Feed Documents can contain XML Digital Signatures [REC-xmldsig-core], and they can be encrypted using XML Encryption [REC-xmlenc-core] as specified in Section 5 of [RFC4287] 🔏. Handling of signatures and encrypted elements in Atom documents is discussed in Sections 5 and 6.3 of [RFC4287] 📖.

Neither servers nor clients are under any obligation to support encryption and digital signatures for Entries or Feeds 🤷‍♀️. It's totally possible that some installations will have clients or servers that require signing or encrypting of the documents exchanged in the Atom Protocol 🛡️.

Servers are allowed (and in some cases expected) to modify the contents of an Entry Document before publishing it, so signatures within an entry are only likely to be useful to the server the entry is sent to 🙈. Clients can't assume the signature will be valid when a third party views it, or even that the server will publish the client's signature 💔.

A server is allowed to strip client-applied signatures, to strip client-applied signatures and then re-sign with its own public key, and to oversign an entry with its own public key 🖋️. To a third party, a signature applied by a server means the same thing as a signature from anyone, as described in [RFC4287] 👀. It is RECOMMENDED that a server that knows it has changed any part of an Entry Document signed by the client should strip that signature before publishing the entry. This keeps third parties from trying to interpret a signature that can't be validated 🧹.

15.6. URIs and IRIs

Atom Publishing Protocol implementations handle URIs and IRIs 🌐. See Section 7 of [RFC3986] and Section 8 of [RFC3987] for security considerations related to their handling and use 📚.

The Atom Publishing Protocol leaves the server in control of minting URIs 👑. Using any client-supplied data to create new URIs is subject to the same concerns as described in the next section ⚠️.

15.7. Code Injection and Cross Site Scripting

Atom Feed and Entry Documents can contain a broad range of content types, including code that might be executable in some contexts 💻. Malicious clients could try to attack servers or other clients by injecting code into a Collection Document's Entry or Media Resources 😈.

Server implementations are strongly encouraged to verify that client-supplied content is safe before accepting, processing, or publishing it 🧼. For HTML, experience shows that verification based on a white list of acceptable content works better than a black list of forbidden content 🍓.

Extra info about XHTML and HTML content safety can be found in Section 8.1 of [RFC4287] 🧠.

16. IANA Considerations 🧚

This specification uses two new media types that conform to the registry mechanism described in [RFC4288]. It also adds a new message header that conforms to the registry mechanism described in [RFC3864], and two new link relations that conform to the registry mechanism described in [RFC4287] 📋.

16.1. Content-Type Registration for 'application/atomcat+xml'

An Atom Publishing Protocol Category Document, when serialized as XML 1.0, can be identified with the following media type 🏷️:

MIME media type name:  application

MIME subtype name:  atomcat+xml

Required parameters:  None.

Optional parameters:

   "charset":  This parameter has identical semantics to the charset
      parameter of the "application/xml" media type as specified in
      [RFC3023].

Encoding considerations:  Identical to those of "application/xml" as
   described in [RFC3023], Section 3.2.

Security considerations:  As defined in RFC 5023.

   In addition, as this media type uses the "+xml" convention, it
   shares the same security considerations as described in [RFC3023],
   Section 10.

Interoperability considerations:  There are no known interoperability
   issues.

Published specification:  RFC 5023.

Applications that use this media type:  No known applications
   currently use this media type.

Additional information:

Magic number(s):  As specified for "application/xml" in [RFC3023],
   Section 3.2.

File extension:  .atomcat

Fragment identifiers:  As specified for "application/xml" in
   [RFC3023], Section 5.

Base URI:  As specified in [RFC3023], Section 6.

Macintosh file type code:  TEXT

Person & email address to contact for further information:
   Joe Gregorio <joe@bitworking.org>

Intended usage:  COMMON

Author/Change controller:  IETF (iesg@ietf.org) Internet Engineering
   Task Force

16.2. Content-Type Registration for 'application/atomsvc+xml'

An Atom Publishing Protocol Service Document, when serialized as XML 1.0, can be identified with the following media type 🏷️:

MIME media type name:  application

MIME subtype name:  atomsvc+xml

Required parameters:  None.

Optional parameters:

   "charset":  This parameter has identical semantics to the charset
      parameter of the "application/xml" media type as specified in
      [RFC3023].

Encoding considerations:  Identical to those of "application/xml" as
   described in [RFC3023], Section 3.2.

Security considerations:  As defined in RFC 5023.

   In addition, as this media type uses the "+xml" convention, it
   shares the same security considerations as described in [RFC3023],
   Section 10.

Interoperability considerations:  There are no known interoperability
   issues.

Published specification:  RFC 5023.

Applications that use this media type:  No known applications
   currently use this media type.

Additional information:

Magic number(s):  As specified for "application/xml" in [RFC3023],
   Section 3.2.

File extension:  .atomsvc

Fragment identifiers:  As specified for "application/xml" in
   [RFC3023], Section 5.

Base URI:  As specified in [RFC3023], Section 6.

Macintosh file type code:  TEXT

Person and email address to contact for further information:  Joe
   Gregorio <joe@bitworking.org>

Intended usage:  COMMON

Author/Change controller:  IETF (iesg@ietf.org) Internet Engineering
   Task Force

16.3. Header Field Registration for 'SLUG'

Here's the header field registration for SLUG 🎀:

Header field name:  SLUG

Applicable protocol:  http [RFC2616]

Status:  standard.

Author/Change controller:  IETF (iesg@ietf.org) Internet Engineering
   Task Force

Specification document(s):  RFC 5023.

Related information:  None.

16.4. The Link Relation Registration "edit"

Next up is the "edit" link relation 🔗:

Attribute Value:  edit

Description:  An IRI of an editable Member Entry.  When appearing
   within an atom:entry, the href IRI can be used to retrieve,
   update, and delete the Resource represented by that Entry.

Expected display characteristics:  Undefined; this relation can be
   used for background processing or to provide extended
   functionality without displaying its value.

Security considerations:  Automated agents should take care when this
   relation crosses administrative domains (e.g., the URI has a
   different authority than the current document).

16.5. The Link Relation Registration "edit-media"

And here's "edit-media" 🎬:

Attribute Value:  edit-media

Description:  An IRI of an editable Media Resource.  When appearing
   within an atom:entry, the href IRI can be used to retrieve,
   update, and delete the Media Resource associated with that Entry.

Expected display characteristics:  Undefined; this relation can be
   used for background processing or to provide extended
   functionality without displaying its value.

Security considerations:  Automated agents should take care when this
   relation crosses administrative domains (e.g., the URI has a
   different authority than the current document).

16.6. The Atom Format Media Type Parameter

IANA has added a reference to this specification in the 'application/atom+xml' media type registration 📝.

17. References 📚

17.1. Normative References ✨

okay so these are the big-deal docs the spec leans on, and you NEED them to actually implement this stuff 📚💅

[REC-xml] Yergeau, F., Paoli, J., Bray, T., Sperberg-McQueen, C., and E. Maler, "Extensible Markup Language (XML) 1.0 (Fourth Edition)", World Wide Web Consortium Recommendation REC-xml-20060816, August 2006, <http://www.w3.org/TR/2006/REC-xml-20060816>.
[REC-xml-infoset] Cowan, J. and R. Tobin, "XML Information Set (Second Edition)", World Wide Web Consortium Recommendation REC-xml-infoset-20040204, February 2004, <http://www.w3.org/TR/2004/REC-xml-infoset-20040204>.
[REC-xml-names] Hollander, D., Bray, T., Tobin, R., and A. Layman, "Namespaces in XML 1.0 (Second Edition)", World Wide Web Consortium Recommendation REC-xml-names-20060816, August 2006, <http://www.w3.org/TR/2006/REC-xml-names-20060816>.
[REC-xmlbase] Marsh, J., "XML Base", W3C REC W3C.REC-xmlbase-20010627, June 2001, <http://www.w3.org/TR/2001/REC-xmlbase-20010627>.
[REC-xmldsig-core] Solo, D., Reagle, J., and D. Eastlake, "XML-Signature Syntax and Processing", World Wide Web Consortium Recommendation REC-xmldsig-core-20020212, February 2002, <http://www.w3.org/TR/2002/REC-xmldsig-core-20020212>.
[REC-xmlenc-core] Eastlake, D. and J. Reagle, "XML Encryption Syntax and Processing", World Wide Web Consortium Recommendation REC-xmlenc-core-20021210, December 2002, <http://www.w3.org/TR/2002/REC-xmlenc-core-20021210>.
[RFC2119] Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, March 1997.
[RFC2246] Dierks, T. and C. Allen, "The TLS Protocol Version 1.0", RFC 2246, January 1999.
[RFC2616] Fielding, R., Gettys, J., Mogul, J., Frystyk, H., Masinter, L., Leach, P., and T. Berners-Lee, "Hypertext Transfer Protocol -- HTTP/1.1", RFC 2616, June 1999.
[RFC2617] Franks, J., Hallam-Baker, P., Hostetler, J., Lawrence, S., Leach, P., Luotonen, A., and L. Stewart, "HTTP Authentication: Basic and Digest Access Authentication", RFC 2617, June 1999.
[RFC2818] Rescorla, E., "HTTP Over TLS", RFC 2818, May 2000.
[RFC3023] Murata, M., St. Laurent, S., and D. Kohn, "XML Media Types", RFC 3023, January 2001.
[RFC3629] Yergeau, F., "UTF-8, a transformation format of ISO 10646", STD 63, RFC 3629, November 2003.
[RFC3864] Klyne, G., Nottingham, M., and J. Mogul, "Registration Procedures for Message Header Fields", BCP 90, RFC 3864, September 2004.
[RFC3986] Berners-Lee, T., Fielding, R., and L. Masinter, "Uniform Resource Identifier (URI): Generic Syntax", STD 66, RFC 3986, January 2005.
[RFC3987] Duerst, M. and M. Suignard, "Internationalized Resource Identifiers (IRIs)", RFC 3987, January 2005.
[RFC4287] Nottingham, M. and R. Sayre, "The Atom Syndication Format", RFC 4287, December 2005.
[RFC4288] Freed, N. and J. Klensin, "Media Type Specifications and Registration Procedures", BCP 13, RFC 4288, December 2005.
[RFC4346] Dierks, T. and E. Rescorla, "The Transport Layer Security (TLS) Protocol Version 1.1", RFC 4346, April 2006.

17.2. Informative References 🦋

these ones are just extra reading, the vibes are "good to know" not "must know" 🌸

[NOTE-detect-lost-update] Nielsen, H. and D. LaLiberte, "Editing the Web: Detecting the Lost Update Problem Using Unreserved Checkout", World Wide Web Consortium NOTE NOTE-detect-lost-update, May 1999, <http://www.w3.org/1999/04/Editing/>.
[REC-webarch] Walsh, N. and I. Jacobs, "Architecture of the World Wide Web, Volume One", W3C REC REC-webarch-20041215, December 2004, <http://www.w3.org/TR/2004/REC-webarch-20041215>.
[RNC] Clark, J., "RELAX NG Compact Syntax", December 2001, <http://www.oasis-open.org/committees/relax-ng/compact-20021121.html>.

Appendix A. Contributors 🌈

all the good stuff in here came from the Atom community and the Atompub Working Group, so big thank yous to everyone who helped build it 🫶✨

Appendix B. RELAX NG Compact Schema 💜

This appendix is informative.

okay so the RELAX NG schema is strict about elements in the Atom Protocol namespace that aren't defined in this revision. if you run into that kind of markup, the rules for handling it are in Sections 6.2 and 6.3 of [RFC4287] 🙈

here's the schema for Service Documents 🎀

# -*- rnc -*- # RELAX NG Compact Syntax Grammar for the Atom Protocol

namespace app = "http://www.w3.org/2007/app"
namespace atom = "http://www.w3.org/2005/Atom"
namespace xsd = "http://www.w3.org/2001/XMLSchema"
namespace xhtml = "http://www.w3.org/1999/xhtml"
namespace local = ""

start = appService

# common:attrs

atomURI = text

appCommonAttributes =
   attribute xml:base { atomURI }?,
   attribute xml:lang { atomLanguageTag  }?,
   attribute xml:space {"default"|"preserved"}?,
   undefinedAttribute*

atomCommonAttributes = appCommonAttributes

undefinedAttribute = attribute * - (xml:base | xml:space  | xml:lang
  | local:*) { text }

atomLanguageTag = xsd:string {
   pattern = "([A-Za-z]{1,8}(-[A-Za-z0-9]{1,8})*)?"
}
atomDateConstruct =
    appCommonAttributes,
    xsd:dateTime

# app:service
appService =
   element app:service {
      appCommonAttributes,
      ( appWorkspace+
        & extensionElement* )
   }

# app:workspace

appWorkspace =
   element app:workspace {
      appCommonAttributes,
      ( atomTitle
        & appCollection*
        & extensionSansTitleElement* )
   }

atomTitle = element atom:title { atomTextConstruct }

# app:collection

appCollection =
   element app:collection {
      appCommonAttributes,
      attribute href { atomURI  },
      ( atomTitle
        & appAccept*
        & appCategories*
        & extensionSansTitleElement* )
   }

# app:categories

atomCategory =
    element atom:category {
       atomCommonAttributes,
       attribute term { text },
       attribute scheme { atomURI }?,
       attribute label { text }?,
       undefinedContent
    }

appInlineCategories =
    element app:categories {
        attribute fixed { "yes" | "no" }?,
        attribute scheme { atomURI }?,
        (atomCategory*,
        undefinedContent)
    }

appOutOfLineCategories =
    element app:categories {
        attribute href { atomURI },
        undefinedContent
    }

appCategories = appInlineCategories | appOutOfLineCategories

# app:accept

appAccept =
   element app:accept {
         appCommonAttributes,
         ( text? )
   }

# Simple Extension

simpleSansTitleExtensionElement =
   element * - (app:*|atom:title) {
      text
   }

simpleExtensionElement =
   element * - (app:*) {
      text
   }

# Structured Extension

structuredSansTitleExtensionElement =
   element * - (app:*|atom:title) {
      (attribute * { text }+,
         (text|anyElement)*)
    | (attribute * { text }*,
       (text?, anyElement+, (text|anyElement)*))
   }

structuredExtensionElement =
   element * - (app:*) {
      (attribute * { text }+,
         (text|anyElement)*)
    | (attribute * { text }*,
       (text?, anyElement+, (text|anyElement)*))
   }

# Other Extensibility

extensionSansTitleElement =
 simpleSansTitleExtensionElement|structuredSansTitleExtensionElement

extensionElement = simpleExtensionElement |
   structuredExtensionElement

undefinedContent = (text|anyForeignElement)*

# Extensions

anyElement =
   element * {
      (attribute * { text }
       | text
       | anyElement)*
   }

anyForeignElement =
    element * - app:* {
       (attribute * { text }
        | text
        | anyElement)*
    }

atomPlainTextConstruct =
    atomCommonAttributes,
    attribute type { "text" | "html" }?,
    text

atomXHTMLTextConstruct =
    atomCommonAttributes,
    attribute type { "xhtml" },
    xhtmlDiv

atomTextConstruct = atomPlainTextConstruct | atomXHTMLTextConstruct
anyXHTML = element xhtml:* {
    (attribute * { text }
     | text
     | anyXHTML)*
}

xhtmlDiv = element xhtml:div {
  (attribute * { text }
   | text
   | anyXHTML)*
}

# EOF

and now the schema for Category Documents 🧚

# -*- rnc -*- # RELAX NG Compact Syntax Grammar for the Atom Protocol

namespace app = "http://www.w3.org/2007/app"
namespace atom = "http://www.w3.org/2005/Atom"
namespace xsd = "http://www.w3.org/2001/XMLSchema"
namespace local = ""

start = appCategories

atomCommonAttributes =
   attribute xml:base { atomURI }?,
   attribute xml:lang { atomLanguageTag }?,
   undefinedAttribute*

undefinedAttribute = attribute * - (xml:base | xml:lang | local:*) {
  text }

atomURI = text

atomLanguageTag = xsd:string {
   pattern = "([A-Za-z]{1,8}(-[A-Za-z0-9]{1,8})*)?"
}

atomCategory =
    element atom:category {
       atomCommonAttributes,
       attribute term { text },
       attribute scheme { atomURI }?,
       attribute label { text }?,
       undefinedContent
    }

appInlineCategories =
    element app:categories {
        attribute fixed { "yes" | "no" }?,
        attribute scheme { atomURI }?,
        (atomCategory*,
        undefinedContent)
    }

appOutOfLineCategories =
    element app:categories {
        attribute href { atomURI },
        (empty)
    }

appCategories = appInlineCategories | appOutOfLineCategories

# Extensibility

undefinedContent = (text|anyForeignElement)*

anyElement =
   element * {
      (attribute * { text }
       | text
       | anyElement)*
   }

anyForeignElement =
    element * - atom:* {
       (attribute * { text }
        | text
        | anyElement)*
    }

# EOF

Authors' Addresses 💖

Joe Gregorio (editor) Google

EMail: joe@bitworking.org URI: http://bitworking.org/

Bill de hOra (editor) NewBay Software

EMail: bill@dehora.net URI: http://dehora.net/

Full Copyright Statement ⭐

This document is subject to the rights, licenses and restrictions contained in BCP 78, and except as set forth therein, the authors retain all their rights.

This document and the information contained herein are provided on an "AS IS" basis and THE CONTRIBUTOR, THE ORGANIZATION HE/SHE REPRESENTS OR IS SPONSORED BY (IF ANY), THE INTERNET SOCIETY, THE IETF TRUST AND THE INTERNET ENGINEERING TASK FORCE DISCLAIM 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.

Intellectual Property 💅

okay bestie, let's talk about the legal stuff because it actually matters 🫶 The IETF does not take a position on whether any Intellectual Property Rights (or other rights someone might claim over the tech in this doc) are valid, how far they reach, or whether any license for them is even available 🤷‍♀️. It's not saying anything about that. And it hasn't done its own independent digging to find those rights either, so no promises there 🙈. If you want the rules on rights for RFC documents, check out BCP 78 and BCP 79 📚.

Copies of IPR disclosures sent to the IETF Secretariat are available, along with any assurances of licenses that are supposed to be made available. The same goes for the result of any attempt to get a general license or permission for implementers or users to use those proprietary rights. All of it lives in the IETF's online IPR repository at http://www.ietf.org/ipr ✨.

The IETF also invites any interested party to flag any copyrights, patents, patent applications, or other proprietary rights that might cover technology needed to implement this standard 🌈. Send that info to the IETF at ietf-ipr@ietf.org 💌. Thanks for being a good one, bestie 🦋💜

📦 where this page comes from

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