RFC 3321
Signaling Compression (SigComp) - Extended Operations
Signaling Compression (SigComp) - Extended Operations ✨
RFC 3321 🎀 is an Informational doc from January 2003, written by a whole squad from the Network Working Group: H. Hannu and J. Christoffersson (Ericsson), S. Forsgren and K.-C. Leung (Texas Tech University), Z. Liu (Nokia), and R. Price (Siemens/Roke Manor). The original title block doesn't list any obsoletes or updates, so there's nothing to report there 💅
Status of this Memo ✨
This memo provides information for the Internet community. It does not specify an Internet standard of any kind. Distribution of this memo is unlimited 🌸
Copyright Notice 💖
Copyright (C) The Internet Society (2003). All Rights Reserved.
Abstract 🦋
Okay so this doc is all about how to build certain mechanisms into Signaling Compression (SigComp), which is defined in RFC 3320. The payoff is way better compression efficiency than plain per-message compression, and it's giving main character energy ✨
SigComp decompresses using a Universal Decompressor Virtual Machine (UDVM). The mechanisms in this doc can be implemented with the UDVM instructions that RFC 3320 defines 💜
Table of Contents 📖
1. Introduction..................................................2
2. Terminology...................................................3
3. Architectural View of Feedback................................4
4. State Reference Model.........................................5
5. Extended Mechanisms...........................................6
6. Implications on SigComp......................................13
7. Security Considerations......................................17
8. IANA Considerations..........................................17
9. Acknowledgements.............................................17
10. Intellectual Property Right Considerations...................17
11. References...................................................17
12. Authors' Addresses...........................................18
13. Full Copyright Statement.....................................191. Introduction 🧚
Bestie, this doc shows you how to use [SIGCOMP] to get way better compression efficiency than per-message compression. ✨
Mechanism number one is dynamic compression, which means reusing messages that were already sent. To make that work, a compressor has to know that those earlier messages actually arrived. On a reliable transport like TCP, that's guaranteed 🫶 On an unreliable transport, though, SigComp has to provide that feedback itself. This doc describes that functionality, and it's called explicit acknowledgement 😭
Mechanism number two is shared compression, and it's especially useful when SigComp is applied to request/response-type protocols. It means using messages the local endpoint has received as part of the compression process. The first few messages in particular get a big boost from shared compression, and this doc describes how it works 🔥
Before you dive in, make sure you're familiar with the concept of [SIGCOMP] 💅
2. Terminology 📚
Consult [SIGCOMP] for definitions of terminology, because this doc uses the same terms. There are a few extra terms defined below 🌈
Compressor
Entity that encodes application messages using a certain compression algorithm and keeps track of state that can be used for compression. The compressor is responsible for ensuring that the messages it generates can be decompressed by the remote UDVM 💜
Decompressor
The decompressor converts a SigComp message back into uncompressed data. Decompression functionality is provided by the UDVM 🎀
Dynamic compression
Compression relative to messages sent prior to the current compressed message ✨
Explicit acknowledgement
Acknowledgement for a state. The acknowledgment is explicitly sent from a decompressor to its remote compressor. The acknowledgement should be piggybacked onto a SigComp message in order not to create additional security risks 🙈
Shared compression
Compression relative to messages received by the local endpoint prior to the current compressed message 🍓
Shared state
A state used for shared compression consists only of an uncompressed message. This makes the state independent of the compression algorithm 🦋
State identifier
Reference used to access a previously created item of state.
shared_state_id: the state identifier of a shared state.acked_state_id: the state identifier of a state that is acknowledged as successfully saved by the decompressor.
3. Architectural View of Feedback 🌸
SigComp has a request/response mechanism for sending feedback between endpoints, see Figure 1. This doc uses that exact functionality to support the mechanisms it describes 💖
+--------------------+ +--------------------+
| Endpoint 1 | | Endpoint 2 |
| +--------------+ | | +--------------+ |
| | Compressor 1 | | | |Decompressor 2| |
| | [------------+--+--------------+--+--] * | |
| +-|-------^----+ | | +--|---|-------+ |
| | | | | | | |
| | | | | | | |
| | | | | | | |
| +-|-------|----+ | | +--v---|-------+ |
| | * [----+--+--------------+--+------] | |
| |Decompressor 1| | | | Compressor 2 | |
| +--------------+ | | +--------------+ |
+--------------------+ +--------------------+
Figure 1. Architectural viewThe feedback functionality of SigComp is used here to let a SigComp endpoint confirm which states its remote SigComp endpoint has established during the lifetime of a SigComp compartment. These confirmations are called acknowledgments. Depending on which states have been established, this type of feedback may or may not be used to boost compression efficiency 🔥
Here's the roadmap: Section 4 covers the state reference model of SigComp, Section 5 gives a general tour of the mechanisms, and Section 6 explains what some of these mechanisms mean for basic SigComp 🗺️
4. State Reference Model 🧠
A UDVM may want to save the status of its memory. That status is called a state. As [SIGCOMP] explains, the application may or may not grant a state save request. To reference a saved state later on, for example if the UDVM is going to be loaded with that state, you need a reference that locates the specific state. That reference is called a state identifier 🔑
4.1. Overview of State Reference with Dynamic Compression 💫
When compressor 1 compresses a message m, it uses the information from a SigComp state that its remote decompressor 2 has established and acknowledged. If compressor 1 wants to use the new state to compress later messages, it has to save that new state. The new state contains information from the former state and from m. Once an acknowledgement comes back for the new state, compressor 1 can use it in the compression process. Here's an overview of the model with an example message flow 👀
Saved state(s)
A state that's expected to be used for compression/decompression of later messages ✨
Acked state(s)
An acked state is a saved state that the compressor has received an acknowledgement for, meaning the state has been established at the remote decompressor. The compressor must only use states that are established at the remote decompressor, otherwise a decompression failure will occur. This is why acknowledgements are necessary, at least for unreliable transport 🚨
Compressor 1 Decompressor 2
+---+ +---+
| C | | D |
+---+ +---+
Saved Acked | | Saved
State(s) State(s) | | State(s)
-----------------------+------------+------------------
s0 s0 | | s0
s1=s0+m1 | --m1(s0)-->|
| <--ack(s1) | s0,s1
s0,s1 s0,s1 | |
| |
s0,s1 s0,s1 | --m2(s1)-->| (m2 Lost)
s2=s1+m1 | |
| |
s0-s2 s0,s1 | |
s3=s1+m3 | --m3(s1)-->| s0,s1
| |
| |
| <--ack(s3) | s0,s1,s3=s1+m3
s0-s3 s0,s1,s3 | |
Figure 2. Example of message flow for dynamic compressionLegend time 🎀 Message 1 compressed using state s0 is written m1(s0). The notation s1=s0+m1 means state s1 is created from state s0 and message m1. ack(s1) means the creation of state s1 is acknowledged by piggybacking on a message going the other way (which isn't shown in the figure) 💖
5. Extended Mechanisms ⭐
These subsections give a general description of the extended mechanisms 🌈
5.1. Explicit Acknowledgement Scheme 🫶
For a compressor to use a certain state, it has to know that the remote decompressor has access to that state.
If compressed messages can be lost or arrive out of order on the path between compressor and decompressor, an acknowledgement scheme must be used to tell the remote compressor that a certain state has been established 😭
Explicit acknowledgements can be started in two ways: either by UDVM code that the remote compressor uploaded to the decompressor, or by the endpoint where the states were established. The next two sections explain each case in more detail 👑
5.1.1. Remote Compressor Initiated Acknowledgements ✨
Okay so this is the case where, say, compressor 1 uploads UDVM bytecode to decompressor 2 💌. The UDVM bytecode uses the requested feedback field in the announcement information, and the returned feedback field in the SigComp header, to figure out which states are established at endpoint 2 🔍.
Consider Figure 3 🎀. Here's how a successful remote compressor initiated acknowledgement can go:
- (1): Compressor 1 saves e.g., state(A).
- (2): The UDVM bytecode to initiate a state save for state(A) is either carried in the compressed message, or can be retrieved by decompressor 2 from a state already saved at endpoint 2.
- (3): As compressor 1 is the initiator of this acknowledgement, it can use an arbitrary identifier to be returned to indicate that state(A) has been established. The identifier needs to consist of enough bits to avoid acknowledgement of wrong state. To avoid padding of the feedback items and for simplicity, a minimum of 1 octet SHOULD be used for the identifier. The identifier is placed at the location of the
requested_feedback_item[SIGCOMP]. TheEND-MESSAGEinstruction is used to indicate the location of therequested_feedback_itemto the state handler. - (4): The requested feedback data is now called returned feedback data, as it is placed into the SigComp message at compressor 2.
- (5): The returned feedback item is carried in the SigComp message according to Figure 4: see Section 6.1 and [SIGCOMP].
- (6): The returned feedback item is handled according to: Section 7 of [SIGCOMP]
+--------------+ (2) +--------------+
| Compressor 1 |--------------------------->|Decompressor 2|
+------^-------+ +-------^------+
| (1) (3) |
+---v---+ +---v---+
|State | |State |
|handler| |handler|
+---^---+ +---^---+
| (6) (4) |
+------v-------+ (5) +-------v------+
|Decompressor 1|<---------------------------| Compressor 2 |
+--------------+ +--------------+
Figure 3. Simplified SigComp endpoints5.1.2. Local Endpoint Initiated Acknowledgements 🦋
So when explicit acknowledgements come from an endpoint, the SigComp message carries them too, these are the so-called acked_state_ids: see Section 2. Consider Figure 3 again 🌸, and here's how a successful explicit endpoint initiated acknowledgement goes:
- (1): Compressor 1 saves e.g., state(A).
- (2): The UDVM bytecode to initiate a state save for state(A) is either carried in the compressed message, or can be retrieved by decompressor 2 from a state already saved at endpoint 2.
- (3): A save state request for state(A) is passed to the state handler using the
END-MESSAGEinstruction. The application MAY then grant the state handler permission to save state(A): see [SIGCOMP]. - (4): Endpoint 2 decides to acknowledge state(A) to endpoint 1. The state identifier (
acked_state_id) for state(A) is placed in the SigComp message sent from compressor 2 to decompressor 1. - (5): The UDVM bytecode to initiate (pass) the explicit acknowledgement to endpoint 1 is either carried in the compressed message, or can be retrieved by decompressor 1 from a state already saved at endpoint 1.
- (6): The
acked_state_idfor state(A) is passed to the state handler by placing theacked_state_idat the location of the "returned SigComp parameters" [SIGCOMP], whose location is given to the state handler using theEND-MESSAGEinstruction.
Note: When the requested feedback length is non-zero, endpoint initiated acknowledgements SHOULD NOT be used, due to possible waste of bandwidth. When deciding to implement this mechanism, one SHOULD consider whether this is worth the effort, since all SigComp implementations will support the feedback mechanism and thus have the possibility to implement the mechanism of Section 5.1.1. 🙈
5.2. Shared Compression 💜
To make use of shared compression, a compressing endpoint saves the uncompressed version of the compressed message as a state (shared state). As described in Section 2, the reference to a shared state is called shared_state_id. The shared state's parameters state_address and state_instruction MUST be set to zero. The state_retention_priority MUST be set to 65535, and the other state parameters are set according to [SIGCOMP]. This is because different compression algorithms may be used to compress application messages traveling in different directions. The shared state is also created on a per-compartment basis, i.e., the shared state is stored in the same memory as the states created by the particular remote compressor. The choice of how to divide the state memory between "ordinary" states and shared states is an implementation decision at the compressor. Note that new shared state items MUST NOT be created unless the compressor has made enough state memory available, since decompression failure could occur if the shared state pushed existing state out of the state memory buffer. 💀
A compressing endpoint MUST also indicate to the remote compressor that the shared state is available, but only if the local decompressor can retrieve the shared state. The retrieval of the shared state is done according to the state retrieval instruction of the UDVM.
Consider Figure 3 🧚. Here's how a successful shared compression goes:
- (1): Compressor 1 saves e.g., state(M), which is the uncompressed version of the current application message to be compressed and sent.
- (2): The UDVM bytecode to indicate the presence of state(M) at endpoint 1 is either carried in the compressed message, or can be retrieved by decompressor 2 from a state already saved at endpoint 2.
- (3): The SHA-1 instruction is used at endpoint 2 to calculate the
shared_state_idfor state(M). The indication is passed to the state handler, by placing the shared identifier at the location of the "returned SigComp parameters" [SIGCOMP]. The location of the "returned SigComp parameters" is given to the state handler using theEND-MESSAGEinstruction. - (4): If endpoint 2 uses shared compression, it compares the state identifier values in the "returned SigComp parameters" information with the value it has calculated for the current decompressed message received from endpoint 1. If there is a match, then endpoint 2 uses the shared state together with the state it would normally use if shared compression is not supported to compress the next message.
- (5): The UDVM bytecode that will use the shared state (state(M)) in the decompression process at decompressor 1 is either carried in the compressed message, or can be retrieved by decompressor 1 from a state already saved at endpoint 1.
5.3. Maintaining State Data Across Application Sessions ⭐
Usually, signaling protocols (e.g., SIP) use the concept of sessions. However, from the compression point of view, the messages sent by the same source contain redundancies beyond the session boundary. So it's natural to keep the state data from the same source across sessions, so high performance can be achieved and maintained, with the overhead spread out over a much longer period of time than one application session. 🌈
Maintaining states across application sessions can be achieved simply by making the lifetime of a compartment longer than the time duration of a single application session. Note that the states here are the ones stored on a per-compartment basis, not the locally available states that are stored on a global basis (i.e., not compartment specific).
5.4. Use of User-Specific Dictionary 🎀
The idea behind the user-specific dictionary is based on the observation that, for protocols such as SIP, a given user/device combination will produce some messages containing fields that are always populated with the same data.
Take SIP as an example. Capabilities of the SIP endpoints are communicated during session initiation, and they tend not to change unless the capabilities of the device change. Similarly, user-specific information such as the user's URL, name, and e-mail address will likely not change often, and will show up regularly in SIP signaling exchanges involving a specific user. 🫶
So a SigComp compressor could include the user-specific dictionary as part of the initial messages to the decompressor, even before any time critical signaling messages are generated from a particular application. This increases compression efficiency once the messages start to flow. 👑
Obviously, the user-specific dictionary is a state item that would be good to have as a cross-session state: see Section 5.3. 💅
5.5. Checkpoint State 🔥
The following mechanism can be used to avoid decompression failure due to reference to a non-existent state. This may occur in three cases: a) a state is not established at the remote SigComp endpoint due to the loss of a SigComp message; b) a state is not established due to insufficient memory; c) a state has been established but was deleted later due to insufficient memory. 😭
When a compressor sends a SigComp message that will create a new state on the decompressor side, it can indicate that the newly created state will be a checkpoint state by setting state_retention_priority [SIGCOMP] to the highest value sent by the same compressor. On top of that, a checkpoint state MUST be explicitly acknowledged by the receiving decompressor to the sending compressor. 🍓
Consider Figure 3 🦋. Here's how this kind of state management goes:
- (1): Compressor 1 saves e.g., state(A), which it would like to have as a checkpoint state at decompressor 2.
- (2): The UDVM bytecode to indicate the state priority (
[SIGCOMP]state_retention_priority) of state(A) and initiate a state save for state(A) is either carried in the compressed message, or can be retrieved by decompressor 2 from a state already saved at endpoint 2. - (3): A save state request for state(A) is passed to the state handler using the
END-MESSAGEinstruction, including the indication of the state priority. The application grants the saving of state(A): see [SIGCOMP]. - (4): An acknowledgement for state(A) (the checkpoint state) is returned to endpoint 2 using one of the mechanisms described in Section 5.1.
Note: To avoid using a state that has been deleted due to insufficient memory, a compressor MUST keep track of the memory available for saving states at the remote endpoint. The SigComp parameter state_memory_size, which is announced by the SigComp feedback mechanism, can be used to infer if a previous checkpoint state has been deleted (by a later checkpoint state creation request) due to lack of memory. 🧠
5.6. Implicit Deletion for Dictionary Update 🧚
okay so a state is usually two things: UDVM bytecode and a dictionary 📚. when dynamic compression is running, new stuff has to get added to the dictionary, but if you keep piling it on forever your memory blows up. that's a big deal for low end mobile terminals, so old dictionary content has to be deleted to make room for the new stuff ✨
here's the iconic part 💅 instead of signaling which dictionary parts to delete in every single message, you can use implicit deletion. both sides agree on a well-defined algorithm and run it the exact same way, so they always end up deleting the same bits. for example, the algorithm can live inside the predefined UDVM bytecode both SigComp endpoints agreed on. the algorithm takes one input, which is the total number of bytes to be deleted, and then it decides which parts of the dictionary go 🗑️
because both endpoints run the same algorithm, there's no need for explicit signaling per message 🙌 that can mean better compression efficiency, since you skip the signaling overhead. it's also more robust, because there are no signaling bits on the wire that can get garbled or lost in transmission. no cap, that's a whole vibe 🔥
6. Implications on SigComp 🎀
okay this section is where the new features start affecting the actual SigComp messages going between the compressor and its remote decompressor 📨 it also changes how you read things like the returned SigComp parameters [SIGCOMP]. BUT (and this is important) the only fixed part is the mandatory bytes of the SigComp messages [SIGCOMP]. everything else in the final message format is up to the implementation 🫶
also, an implementation that doesn't use explicit acknowledgements and/or shared compression isn't affected at all, even if it gets this kind of feedback. so you can just chill 😌
6.1. Implications on SigComp Messages 💌
to support the extended features, SigComp messages must carry the indications and information covered in Section 5. for example, to support shared compression and explicit acknowledgements, the SigComp messages need to convey this info:
- The
acked_state_idas described in Sections 2 and 5.1. - The
shared_state_idas described in Sections 2 and 5.2.
here's what a SigComp message looks like according to [SIGCOMP] 👀
0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7
+---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
| 1 1 1 1 1 | T | len | | 1 1 1 1 1 | T | 0 |
+---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
| | | |
: returned feedback item : : returned feedback item :
| | | |
+---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
| | | code_len |
: partial state identifier : +---+---+---+---+---+---+---+---+
| | | code_len | destination |
+---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
| | | |
: remaining SigComp message : : uploaded UDVM bytecode :
| | | |
+---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
| |
: remaining SigComp message :
| |
+---+---+---+---+---+---+---+---+
Figure 4. Format of a SigComp messagethe "remaining SigComp message" field is totally the compressor's call, since it's the one supplying the UDVM bytecode. so there's no need to define a new message format just to carry the extended feature info 🤷♀️
and here's an example of what that "remaining SigComp message" could look like with shared compression and explicit acknowledgements 🦋 it's only an example though, the format is still an implementation decision!
0 1 2 3 4 5 6 7
+---+---+---+---+---+---+---+---+
| Format according to Figure 4 |
: except for the field called :
| "remaining SigComp message" | "remaining SigComp message" field
+---+---+---+---+---+---+---+---+ --------
| s | a | r | Reserved | |
+---+---+---+---+---+---+---+---+ |
| | |
: shared_state_id* : Present if 's' is set
| | |
+---+---+---+---+---+---+---+---+ |
| | |
: acked_state_id* : Present if 'a' is set
| | |
+---+---+---+---+---+---+---+---+ |
| | |
: Rest of the SigComp message : |
| | v
+---+---+---+---+---+---+---+---+ --------------
Figure 5. Example of SigComp message for some of the extended
features.
'r' : If set, then a state corresponding to the decompressed
version of this compressed message (shared state) was saved at
the compressor.
* : The length of the shared_state_id and acked_state_id fields
are of the same length as the partial state identifier.6.2. Extended SigComp Announcement/Feedback Format 📣
this part explains how the "returned_SigComp_parameters" [SIGCOMP] info gets read so you can get feedback as described in Sections 5.1 and 5.2 ✨
the partial_state_identifiers match up with the hash_value for states that got set up at the remote endpoint after it received SigComp messages. so they're basically acknowledgements for established states, and you can use them for compression 💖 they can also announce "global state," which isn't tied to any particular compartment and doesn't get created just from receiving a SigComp message.
it's up to the implementation to figure out what kind of state each partial_state_identifier is pointing at, like whether it's an acknowledged state or a shared state. and if a basic SigComp implementation gets a message with state identifiers for shared or acknowledged states, it just ignores them 🙈
the I-bit of the requested feedback format is there to turn off the list of locally available state items. an endpoint that wants to receive shared_state_id must not set the I-bit to 1 🚫 and an endpoint that stores shared states and sends its list of locally available states needs to be careful about which types go in the list. so it has to decide whether to include or exclude shared states and states of well-known algorithms, for example 🧐
6.3. Acknowledgement Optimization 🌟
okay this one's a fun optimization. if shared compression is used between two endpoints (see Figure 1), then there's a trick that, if implemented, makes an acked_state_id in the SigComp message unnecessary 🤯
here's how it goes. Compressor 1 saves a shared state(M), which is the uncompressed version of the current compressed message (message m) about to be sent. Compressor 1 also sets bit 'r' (see Figure 5) to signal that state(M) can be used by endpoint 2 during compression. the acked_state_id for state(S), which was created at endpoint 2 when it decompressed message m, may not have to be explicitly placed in the compressed messages from compressor 2, as long as shared state(M) gets used in the compression process 🦋
when endpoint 1 notices that decompressor 1 requested shared state(M), it implicitly knows that state(S) was created at endpoint 2. why? because:
- Compressor 1 has instructed decompressor 2 to save state(S).
- The indication of shared state(M) would never have been received by compressor 2 if state(S) hadn't been successfully saved, because if a state save request is denied, the corresponding announcement information gets thrown out by the state handler.
Note: endpoint 1's state handler must keep a mapping between state(M) and state(S) for this optimization to work. no mapping, no magic ✨
Note: the only state this feature acknowledges is the state created by combining the state used to compress the message with the message itself. for anything else, the acked_state_id has to be used 🙏
Note: state(S) might get discarded due to a lack of state memory even though the announcement info was forwarded successfully. this possibility must be taken into account (otherwise a decompression failure may occur). you can handle this with the SigComp parameter state_memory_size, which is announced by the SigComp feedback mechanism. the endpoint can use that parameter to figure out whether a state creation request failed because it ran out of memory 😭
7. Security Considerations 🔒
the features in this document are believed not to add any security risks to the ones already mentioned in [SIGCOMP]. 🛡️
8. IANA Considerations 📋
this document does not require any IANA involvement 💅
9. Acknowledgements 🫶
thanks to Carsten Bormann, Christopher Clanton, Miguel Garcia, Lars-Erik Jonsson, Khiem Le, Mats Nordberg, Jonathan Rosenberg and Krister Svanbro for valuable input 💜
10. Intellectual Property Right Considerations ⚖️
the IETF has been notified of intellectual property rights claimed in regard to some or all of the specification in this document. for more info, check the online list of claimed rights 📜
11. References 📚
[SIP] Rosenberg, J., Schulzrinne, H., Camarillo, G., Johnston,
A., Peterson, J., Sparks, R., Handley, M. and E.
Schooler, "SIP: Session Initiation Protocol", RFC 3261,
June 2002.
[SIGCOMP] Price R., Bormann, C., Christoffersson, J., Hannu, H.,
Liu, Z. and J. Rosenberg, "Signaling Compression
(SigComp)", RFC 3320, January 2003.12. Authors' Addresses 💌
Hans Hannu
Box 920
Ericsson AB
SE-971 28 Lulea, Sweden
Phone: +46 920 20 21 84
EMail: hans.hannu@epl.ericsson.se
Jan Christoffersson
Box 920
Ericsson AB
SE-971 28 Lulea, Sweden
Phone: +46 920 20 28 40
EMail: jan.christoffersson@epl.ericsson.se
Stefan Forsgren
EMail: StefanForsgren@alvishagglunds.se
Ka-Cheong Leung
Department of Computer Science
Texas Tech University
Lubbock, TX 79409-3104
United States of America
Phone: +1 806 742-3527
EMail: kcleung@cs.ttu.edu
Zhigang Liu
Nokia Research Center
6000 Connection Drive
Irving, TX 75039, USA
Phone: +1 972 894-5935
EMail: zhigang.c.liu@nokia.com
Richard Price
Roke Manor Research Ltd
Romsey, Hants, SO51 0ZN, United Kingdom
Phone: +44 1794 833681
EMail: richard.price@roke.co.uk13. Full Copyright Statement ✨
okay bestie, this is the legal part 🧾💅 and i'm keeping the important bits exactly as written, no cap.
Copyright (C) The Internet Society (2003). All Rights Reserved. 🌸
So basically, this document and translations of it may be copied and handed out to others 💌. People can also make derivative works that comment on or explain it, or help with implementing it, and they can prepare, copy, publish and distribute those in whole or in part, without restriction of any kind 🦋. The one condition is that the copyright notice and this paragraph are included on all those copies and derivative works ✨.
The document itself may not be modified in any way, such as by removing the copyright notice or references to the Internet Society or other Internet organizations. The exceptions are: needed for developing Internet standards (then the procedures for copyrights in the Internet Standards process must be followed), or required to translate it into languages other than English 🌈.
The limited permissions above are perpetual, and the Internet Society or its successors or assigns will not revoke them 💜. That's forever, bestie 🫶.
This document and the information contained herein is provided on an "AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. 🙈
Acknowledgement 🎀
okay last but not least, the funding bit 💖. Funding for the RFC Editor function is currently provided by the Internet Society 🫶✨. Thank you to them for keeping the RFC Editor running, because without that, none of this would exist 🧚💕.
📦 where this page comes from
- ietf: rfc3321 2003-01
- 💖 girlified by claude-haiku-5-5 on : a language model's rewrite of the original, under its terms