One document matched: draft-ietf-core-block-01.xml
<?xml version="1.0" encoding="us-ascii"?>
<?xml-stylesheet type="text/xsl" href="rfc2629.xslt" ?>
<!DOCTYPE rfc SYSTEM "rfc2629.dtd" [
]>
<!-- Fix: This -nn, date below -->
<rfc ipr="trust200902" docName="draft-ietf-core-block-01"
category="std" >
<?rfc toc="yes"?>
<?rfc sortrefs="yes"?>
<?rfc symrefs="yes" ?>
<front>
<title>
Blockwise transfers in CoAP
</title>
<author initials="Z" surname="Shelby" fullname="Zach Shelby" role="editor">
<organization>
Sensinode
</organization>
<address>
<postal>
<street>Kidekuja 2</street>
<city>Vuokatti</city>
<code>88600</code>
<country>Finland</country>
</postal>
<phone>+358407796297</phone>
<email>zach@sensinode.com</email>
</address>
</author>
<author initials="C" surname="Bormann" fullname="Carsten Bormann">
<organization>Universitaet Bremen TZI</organization>
<address>
<postal>
<street>Postfach 330440</street>
<city>Bremen</city>
<code>D-28359</code>
<country>Germany</country>
</postal>
<phone>+49-421-218-63921</phone>
<facsimile>+49-421-218-7000</facsimile>
<email>cabo@tzi.org</email>
</address>
</author>
<date year="2011" />
<area>Applications</area>
<workgroup>CoRE Working Group</workgroup>
<keyword>Internet-Draft</keyword>
<abstract>
<t>
CoAP is a RESTful transfer protocol for constrained nodes and networks.
CoAP is based on datagram transport, which limits the maximum size of
resource representations that can be transferred without too
much fragmentation. The Block option provides a minimal way to transfer larger representations in a block-wise fashion.
</t>
</abstract>
</front>
<middle>
<section anchor="problems" title="Introduction">
<t>The CoRE WG is tasked with standardizing an
Application Protocol for Constrained Networks/Nodes, CoAP.
This protocol is intended to provide RESTful <xref target="REST"/> services not
unlike HTTP <xref target="RFC2616"/>,
while reducing the complexity of implementation as well as the size of
packets exchanged in order to make these services useful in a highly
constrained network of themselves highly constrained nodes.</t>
<t>This objective requires restraint in a number of sometimes conflicting ways:</t>
<t><list style='symbols'>
<t>reducing implementation complexity in order to minimize code size,</t>
<t>reducing message sizes in order to minimize the number of fragments
needed for each message (in turn to maximize the probability of
delivery of the message), the amount of transmission power needed
and the loading of the limited-bandwidth channel,</t>
<t>reducing requirements on the environment such as stable storage,
good sources of randomness or user interaction capabilities.</t>
</list></t>
<t>CoAP is based on datagram transports such as UDP, which limit the
maximum size of resource representations that can be transferred
without creating unreasonable levels of IP fragmentation.
In addition, not all resource representations will fit into a single
link layer packet of a constrained network, which may cause adaptation
layer fragmentation even if IP layer fragmentation is not required.
Using fragmentation (either at the
adaptation layer or at the IP layer) to enable the transport of larger
representations is possible up to the maximum size of the underlying
datagram protocol (such as UDP),
but the fragmentation/reassembly process loads the lower layers
with conversation state that is better managed in the application
layer.</t>
<t>This specification defines a CoAP option to enable <spanx
style='emph'>block-wise</spanx> access to
resource representations.
The Block option provides a minimal way to transfer larger
resource representations in a block-wise fashion.
The overriding objective is to avoid
creating conversation state at the server for block-wise GET requests.
(It is impossible to fully avoid creating conversation state for
POST/PUT, if the creation/replacement of resources is to be atomic;
where that property is not needed, there is no need to create server
conversation state in this case, either.)</t>
<t> In summary, this specification adds a Block option to CoAP that
can be used for block-wise transfers. Benefits of using this option include:</t>
<t><list style='symbols'>
<t>
Transfers larger than can be accommodated in constrained-network
link-layer packets can be performed in smaller blocks.</t>
<t>No hard-to-manage conversation state is created at the adaptation
layer or IP layer for fragmentation.</t>
<t>The transfer of each block is acknowledged, enabling retransmission
if required.</t>
<t>Both sides have a say in the block size that actually will be used.</t>
<t>The resulting exchanges are easy to understand using packet
analyzer tools and thus quite accessible to debugging.</t>
<t>If needed, the Block option can also be used as is to provide random
access to power-of-two sized blocks within a resource representation.</t>
</list></t>
<t>The key words "MUST", "MUST NOT", "REQUIRED",
"SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY",
and "OPTIONAL" in this document are to be interpreted as described in
RFC 2119, BCP 14 <xref target="RFC2119"/> and indicate requirement
levels for compliant CoAP implementations.</t>
<t>In this document, the term "byte" is used in its now customary
sense as a synonym for "octet".</t>
<t>Where bit arithmetic is explained, this document uses the notation
familiar from the programming language C, except that the operator "^"
stands for exponentiation.</t>
</section>
<section anchor="block-wise-transfers" title="Block-wise transfers">
<section anchor="block-option" title="The Block Option">
<texttable>
<ttcol align='right'>Type</ttcol>
<ttcol align='left'>C/E</ttcol>
<ttcol align='left'>Name</ttcol>
<ttcol align='left'>Data type</ttcol>
<ttcol align='left'>Length</ttcol>
<ttcol align='left'>Default</ttcol>
<c>13</c>
<c>C</c>
<c>Block</c>
<c>uint</c>
<c>1-3 B</c>
<c>0 (see below)</c>
</texttable>
<t>Implementation of the Block option is intended to be optional.
However, when it is present in a CoAP message, it MUST be processed
(or the message rejected);
therefore it is identified as a critical option.</t>
<t>The size of the blocks should not be fixed by the protocol. On the
other hand, implementation should be as simple as possible. The Block
option therefore supports a small range of power-of-two block sizes, from 2^4
(16) to 2^11 (2048) bytes. One of these eight values can be encoded
in three bits (0 for 2^4 to 7 for 2^11 bytes), which we call the <spanx style='verb'>SZX</spanx> (size
exponent); the actual block size is then <spanx style='verb'>1 << (SZX + 4)</spanx>.</t>
<t>When a representation is larger than can be comfortably transferred in
a single UDP datagram, the Block option can be used to indicate a
block-wise transfer. Block is a 1-, 2- or 3-byte integer, the four least
significant bits of which indicate the size and whether the current
block-wise transfer is the last block being transferred (M or "more"
bit). The option value divided by sixteen is the number of the block
currently being transferred, starting from zero, i.e., the current
transfer is about the <spanx style='verb'>size</spanx> bytes starting
at byte <spanx style='verb'>block number << (SZX +
4)</spanx>. The default value of
the Block Option is zero, indicating that the current block is the first
(block number 0) and only (M bit not set) block of the transfer;
however, there is no explicit size implied by this default value.</t>
<figure title="Block option" anchor="block"><artwork><![CDATA[
0
0 1 2 3 4 5 6 7
+-+-+-+-+-+-+-+-+
| NUM |M| SZX |
+-+-+-+-+-+-+-+-+
0 1
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| NUM |M| SZX |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
0 1 2
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| NUM |M| SZX |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
]]></artwork></figure>
<t>(Note that, as an implementation convenience, the option value with
the last 4 bits masked out, shifted to the
left by the value of SZX, gives the byte position of the block.)</t>
<t hangText="Option Fields:">
<list style="hanging">
<t hangText="NUM:">
Block Number. The block number is a variable-size (4, 12, or 20 bit) unsigned integer indicating the block number being requested or provided. Block number 0 indicates the first block of a representation.
</t>
<t hangText="M:">
More Flag. This flag indicates if this block is the last in a representation when set. When not set it indicates that there are one or more blocks available. When the block option is used to retrieve a specific block number the M bit MUST be sent as zero and ignored on reception.
</t>
<t hangText="SZX:">
Block Size. The block size is a three-bit unsigned integer indicating the size of a block to
the power of two. Thus block size = 2^(SZX + 4). As there are
three bits available for SZX, the minimum block size is 2^(0+4) = 16
and the maximum is 2^(7+4) = 2048.
</t>
</list>
</t>
<t>The Block option is used in one of three roles:</t>
<t><list style='symbols'>
<t>In the request for a GET, the Block option gives the block number requested and suggests a block size (block number 0) or echoes the block size of
previous blocks received (block numbers other than 0).</t>
<t>In the response for a GET or in the request for a PUT or POST, the
Block option
describes what block number is contained in the payload, and whether
further blocks are required to complete the transfer of that body (M bit). If the M bit is set,
the size of the payload body in bytes MUST indeed be the power of
two given by the block size. All blocks for a REST transfer MUST use
the same block size, except for the last block (M bit not set).</t>
<t>In the response for a PUT or POST, the Block option indicates what
block number is
being acknowledged. In this case, the M bit is set to indicate that
this response does not carry the final response to the request; this
can occur when the M bit was set in the request and the server
implements PUT/POST atomically (i.e., acts only upon reception of the last
block).</t>
</list></t>
</section>
<section anchor="block-usage" title="Using the Block Option">
<t>Using the Block option, a single REST operation can be split into
multiple CoAP message exchanges. Each of these message
exchanges uses their own CoAP Message ID.</t>
<t>When a GET is answered with a response carrying a Block option with
the M bit set, the requester may retrieve additional blocks of the
resource representation by sending
requests with a Block option giving the block number desired. In such
a Block option, the M bit MUST be sent as zero and ignored on
reception.</t>
<t>To influence the block size used in response to a GET request, the
requester uses the Block option, giving the desired size, a block
number of zero and an M bit of zero. A server SHOULD use the block
size indicated or a smaller size. Any further block-wise requests for
blocks beyond the first one MUST indicate the same block size that was
used by the server in the
response for the first one.</t>
<t>If the Block option is used by the requester, all GET requests in a
single transfer
MUST ultimately use the same size, except that there may not be enough
content to fill the last block (the one returned with the M bit not set).
The server SHOULD use the block
size indicated in the request option or a smaller size, but the
requester MUST take note of the actual block size used in the response
it receives
to its initial GET and proceed to use it in subsequent GETs; the
server behavior MUST ensure that this client behavior results in the
same block size for all responses in a sequence (except for the last
one with the M bit not set).</t>
<t>Block-wise transfers can be used to GET resources the representations of
which are entirely static (not changing over time at all, such as in a
schema describing a device), or for dynamically changing resources.
In the latter case, the Block option SHOULD be used in conjunction
with the Etag option, to ensure that the blocks being reassembled are
from the same version of the representation.
When reassembling the representation from the blocks being exchanged,
the reassembler MUST compare Etag options. If the Etag options do not
match in a GET transfer, the requester has the option of attempting to
retrieve fresh values for the blocks it retrieved first. To minimize
the resulting inefficiency, the server MAY cache the current value of
a representation for an ongoing sequence of requests, but there is no
requirement for the server to establish any state. The client MAY
facilitate identifying the sequence by using the Token option with a
non-default value.</t>
<t>In a PUT or POST transfer, the Block option refers to the body in
the request, i.e., there is no way to perform a block-wise retrieval
of the body of the response. Servers that do need to supply large
bodies in response to PUT/POST SHOULD therefore be employing
mechanisms such as providing a location for a resource that can be
used in a GET to obtain that information.</t>
<t>In a PUT or POST transfer that is intended to be implemented in an
atomic fashion at the server, the actual creation/replacement takes
place at the time the final block, i.e. a block with the M bit unset, is received. If not
all previous blocks are available at the server at this time, the
transfer fails and error code 4.08 (Request Entity Incomplete) MUST be returned. The error
code 4.13 (Request Entity Too Large) can be returned at any time by a server that does not
currently have the resources to store blocks for a block-wise PUT or
POST transfer that it would intend to implement in an atomic fashion.</t>
<t>If multiple concurrently proceeding block-wise PUT or POST operations
are possible, the requester SHOULD use the Token option to clearly separate the different sequences.
In this case, when reassembling the representation from the blocks
being exchanged to enable atomic processing, the reassembler MUST
compare any Token options present (and, as usual, taking an absent Token option
to default to the empty Token).
If atomic processing is not desired, there is no need to process the
Token option (but it is still returned in the response as usual).</t>
</section>
</section>
<section anchor="examples" title="Examples">
<t>This section gives a number of short examples with message flows for a
block-wise GET, and for a PUT or POST.
These examples demonstrate the basic operation, the operation in the
presence of retransmissions, and examples for the operation of the
block size negotiation.</t>
<t>In all these examples, a block option is shown in a decomposed way
separating the block number (NUM), more bit (M), and block size exponent
(2^(SZX+4)) by slashes. E.g., a block option value of 33 would be shown as
2/0/32, or a block option value of 59 would be shown as 3/1/128.</t>
<t>The first example (<xref target="simple-get"/>) shows a GET request that is split
into three blocks.
The server proposes a block size of 128, and the client agrees.
The first two ACKs contain 128 bytes of payload each, and third ACK
contains between 1 and 128 bytes.</t>
<figure title="Simple blockwise GET" anchor="simple-get"><artwork><![CDATA[
CLIENT SERVER
| |
| CON [MID=1234], GET, /status ------> |
| |
| <------ ACK [MID=1234], 2.00 OK, 0/1/128 |
| |
| CON [MID=1235], GET, /status, 1/0/128 ------> |
| |
| <------ ACK [MID=1235], 2.00 OK, 1/1/128 |
| |
| CON [MID=1236], GET, /status, 2/0/128 ------> |
| |
| <------ ACK [MID=1236], 2.00 OK, 2/0/128 |
]]></artwork></figure>
<t>In the second example (<xref target="early-get"/>), the client anticipates the blockwise transfer
(e.g., because of a size indication in the link-format description)
and sends a size proposal. All ACK messages except for the last carry
64 bytes of payload; the last one carries between 1 and 64 bytes.</t>
<figure title="Blockwise GET with early negotiation" anchor="early-get"><artwork><![CDATA[
CLIENT SERVER
| |
| CON [MID=1234], GET, /status, 0/0/64 ------> |
| |
| <------ ACK [MID=1234], 2.00 OK, 0/1/64 |
| |
| CON [MID=1235], GET, /status, 1/0/64 ------> |
| |
| <------ ACK [MID=1235], 2.00 OK, 1/1/64 |
: :
: ... :
: :
| CON [MID=1238], GET, /status, 4/0/64 ------> |
| |
| <------ ACK [MID=1238], 2.00 OK, 4/1/64 |
| |
| CON [MID=1239], GET, /status, 5/0/64 ------> |
| |
| <------ ACK [MID=1239], 2.00 OK, 5/0/64 |
]]></artwork></figure>
<t>In the third example (<xref target="late-get"/>), the client is surprised by the
need for a blockwise transfer, and unhappy with the size chosen
unilaterally by the server. As it did not send a size proposal
initially, the negotiation only influences the size from the second
message exchange. Since the client already obtained both the first and
second 64-byte block in the first 128-byte exchange, it goes on
requesting the third 64-byte block. None of this is understood by the
server, which simply responds to the requests as it best can.</t>
<figure title="Blockwise GET with late negotiation" anchor="late-get"><artwork><![CDATA[
CLIENT SERVER
| |
| CON [MID=1234], GET, /status ------> |
| |
| <------ ACK [MID=1234], 2.00 OK, 0/1/128 |
| |
| CON [MID=1235], GET, /status, 2/0/64 ------> |
| |
| <------ ACK [MID=1235], 2.00 OK, 2/1/64 |
| |
| CON [MID=1236], GET, /status, 3/0/64 ------> |
| |
| <------ ACK [MID=1236], 2.00 OK, 3/1/64 |
| |
| CON [MID=1237], GET, /status, 4/0/64 ------> |
| |
| <------ ACK [MID=1237], 2.00 OK, 4/1/64 |
| |
| CON [MID=1238], GET, /status, 5/0/64 ------> |
| |
| <------ ACK [MID=1238], 2.00 OK, 5/0/64 |
]]></artwork></figure>
<t>In all these (and the following) cases, retransmissions are handled by
the CoAP message exchange layer, so they don't influence the block
operations (<xref target="late-get-lost-con"/>, <xref target="late-get-lost-ack"/>).</t>
<figure title="Blockwise GET with late negotiation and lost CON" anchor="late-get-lost-con"><artwork><![CDATA[
CLIENT SERVER
| |
| CON [MID=1234], GET, /status ------> |
| |
| <------ ACK [MID=1234], 2.00 OK, 0/1/128 |
| |
| CON [MID=1235], GE///////////////////////// |
| |
| (timeout) |
| |
| CON [MID=1235], GET, /status, 2/0/64 ------> |
| |
| <------ ACK [MID=1235], 2.00 OK, 2/1/64 |
: :
: ... :
: :
| CON [MID=1238], GET, /status, 5/0/64 ------> |
| |
| <------ ACK [MID=1238], 2.00 OK, 5/0/64 |
]]></artwork></figure>
<figure title="Blockwise GET with late negotiation and lost ACK" anchor="late-get-lost-ack"><artwork><![CDATA[
CLIENT SERVER
| |
| CON [MID=1234], GET, /status ------> |
| |
| <------ ACK [MID=1234], 2.00 OK, 0/1/128 |
| |
| CON [MID=1235], GET, /status, 2/0/64 ------> |
| |
| /////////////////////////////////OK, 2/1/64 |
| |
| (timeout) |
| |
| CON [MID=1235], GET, /status, 2/0/64 ------> |
| |
| <------ ACK [MID=1235], 2.00 OK, 2/1/64 |
: :
: ... :
: :
| CON [MID=1238], GET, /status, 5/0/64 ------> |
| |
| <------ ACK [MID=1238], 2.00 OK, 5/0/64 |
]]></artwork></figure>
<t>The following examples demonstrate a PUT exchange; a POST exchange
looks the same, with different requirements on atomicity/idempotence.
To ensure that the blocks relate to the same version of the resource
representation carried in the request, the client in
<xref target="simple-put-atomic"/> sets the Token to
"v17" in all requests. Note that, as with the GET, the responses to
the requests that have a more bit in the request block option are
provisional; only the final response tells the client that the PUT
succeeded.</t>
<figure title="Simple atomic blockwise PUT" anchor="simple-put-atomic"><artwork><![CDATA[
CLIENT SERVER
| |
| CON [MID=1234], PUT, /options, v17, 0/1/128 ------> |
| |
| <------ ACK [MID=1234], 2.04 Changed, 0/1/128 |
| |
| CON [MID=1235], PUT, /options, v17, 1/1/12 ------> |
| |
| <------ ACK [MID=1235], 2.04 Changed, 1/1/128 |
| |
| CON [MID=1236], PUT, /options, v17, 2/0/128 ------> |
| |
| <------ ACK [MID=1236], 2.04 Changed, 2/0/128 |
]]></artwork></figure>
<t>A stateless server that simply builds/updates the resource in place
(statelessly) may indicate this by not setting the more bit in the
response (<xref target="simple-put-stateless"/>); in this case, the response codes are valid separately for
each block being updated. This is of course only an acceptable
behavior of the server if the potential inconsistency present during
the run of the message exchange sequence does not lead to problems,
e.g. because the resource being created or changed is not yet or not currently in
use.</t>
<figure title="Simple stateless blockwise PUT" anchor="simple-put-stateless"><artwork><![CDATA[
CLIENT SERVER
| |
| CON [MID=1234], PUT, /options, v17, 0/1/128 ------> |
| |
| <------ ACK [MID=1234], 2.04 Changed, 0/0/128 |
| |
| CON [MID=1235], PUT, /options, v17, 1/1/12 ------> |
| |
| <------ ACK [MID=1235], 2.04 Changed, 1/0/128 |
| |
| CON [MID=1236], PUT, /options, v17, 2/0/128 ------> |
| |
| <------ ACK [MID=1236], 2.04 Changed, 2/0/128 |
]]></artwork></figure>
</section>
<section anchor="iana-considerations" title="IANA Considerations">
<t>This draft adds the following option number to the CoAP Option
Numbers registry of
<xref target="I-D.ietf-core-coap"/>:</t>
<texttable anchor="tab-option-registry" title="CoAP Option Numbers">
<ttcol align="right">Number</ttcol>
<ttcol align="left">Name</ttcol>
<ttcol align="left">Reference</ttcol>
<c>13</c><c>Block </c><c><xref target="block-option"/> </c>
</texttable>
<t>This draft adds the following response code to the CoAP Response Codes registry of
<xref target="I-D.ietf-core-coap"/>:</t>
<texttable anchor="tab-response-code-registry" title="CoAP Response Codes">
<ttcol align="right">Code</ttcol>
<ttcol align="left">Description</ttcol>
<ttcol align="left">Reference</ttcol>
<!-- Client Error 128-159 -->
<c> 136</c><c>4.08 Request Entity Incomplete </c><c><xref target="block-option"/> </c>
</texttable>
</section>
<section anchor="security-considerations" title="Security Considerations">
<t>
Providing access to blocks within a resource may lead to
surprising vulnerabilities.
Where requests are not implemented atomically, an attacker may be able
to exploit a race condition or confuse a server by inducing it to use
a partially updated resource representation.
Partial transfers may also make certain problematic data invisible to
intrusion detection systems; it is RECOMMENDED that an intrusion
detection system (IDS) that analyzes resource representations transferred by
CoAP implement the Block option to gain access to entire resource representations.
Still, approaches such as transferring even-numbered blocks on one path and odd-numbered
blocks on another path, or even transferring blocks multiple times
with different content and
obtaining a different interpretation of temporal order at the IDS than
at the server, may prevent an IDS from seeing the whole picture.
These kinds of attacks are well understood from IP fragmentation and
TCP segmentation; CoAP does not add fundamentally new considerations.
</t>
<t>
Where access to a resource is only granted to clients making use of a specific security
association, all blocks of that resource MUST be subject to the same
security checks; it MUST NOT be possible for unprotected exchanges to
influence blocks of an otherwise protected resource.
As a related consideration, where object security is employed,
PUT/POST should be implemented in the atomic fashion, unless the
object security operation is performed on each access and the
creation of unusable resources can be tolerated.
</t>
<section anchor="mitigating-exhaustion-attacks"
title="Mitigating Resource Exhaustion Attacks">
<t>
Certain blockwise requests may induce the server to create state, e.g. to
create a snapshot for the blockwise GET of a fast-changing resource
to enable consistent access to the same
version of a resource for all blocks, or to create temporary
resource representations that are collected until pressed into
service by a final PUT or POST with the more bit unset.
All mechanisms that induce a server to create state that cannot simply
be cleaned up create opportunities for denial-of-service attacks.
Servers SHOULD avoid being subject to resource exhaustion based on state
created by untrusted sources.
But even if this is done, the mitigation may cause a denial-of-service
to a legitimate request when it is drowned out by other state-creating
requests.
Wherever possible, servers should therefore minimize the opportunities
to create state for untrusted sources, e.g. by using stateless approaches.
</t>
<t>
Performing segmentation at the application layer is almost always
better in this respect than at the transport layer or lower (IP fragmentation,
adaptation layer fragmentation), e.g. because there is application
layer semantics that can be used for mitigation or because lower
layers provide security associations that can prevent attacks.
However, it is less common to apply timeouts and keepalive mechanisms
at the application layer than at lower layers. Servers MAY want to
clean up accreted state by timing it out (cf. response code 4.08), and
clients SHOULD be prepared to run blockwise transfers in an expedient
way to minimize the likelihood of running into such a timeout.
</t>
</section>
<section anchor="mitigating-amplification-attacks" title="Mitigating Amplification Attacks">
<t><xref target="I-D.ietf-core-coap"/> discusses the susceptibility of
CoAP end-points for use in amplification attacks.
</t>
<t>A CoAP server can reduce the amount of amplification it provides to an
attacker by offering large resource representations only in relatively
small blocks. With this, e.g., for a 1000 byte resource, a 10-byte request might
result in an 80-byte response (with a 64-byte block) instead of a
1016-byte response, considerably reducing the amplification provided.</t>
</section>
</section>
<section anchor="acknowledgements" title="Acknowledgements">
<t>Much of the content of this draft is the result of
discussions with the <xref target="I-D.ietf-core-coap"/> authors, and via many CoRE WG discussions. Tokens were suggested by Gilman Tolle and refined by Klaus Hartke.</t>
</section>
</middle>
<back>
<references title='Normative References'>
<reference anchor='RFC2119'>
<front>
<title abbrev='RFC Key Words'>Key words for use in RFCs to Indicate Requirement Levels</title>
<author initials='S.' surname='Bradner' fullname='Scott Bradner'>
<organization>Harvard University</organization>
<address>
<postal>
<street>1350 Mass. Ave.</street>
<street>Cambridge</street>
<street>MA 02138</street></postal>
<phone>- +1 617 495 3864</phone>
<email>sob@harvard.edu</email></address></author>
<date year='1997' month='March' />
<area>General</area>
<keyword>keyword</keyword>
<abstract>
<t>
In many standards track documents several words are used to signify
the requirements in the specification. These words are often
capitalized. This document defines these words as they should be
interpreted in IETF documents. Authors who follow these guidelines
should incorporate this phrase near the beginning of their document:
<list>
<t>
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL
NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and
"OPTIONAL" in this document are to be interpreted as described in
RFC 2119.
</t></list></t>
<t>
Note that the force of these words is modified by the requirement
level of the document in which they are used.
</t></abstract></front>
<seriesInfo name='BCP' value='14' />
<seriesInfo name='RFC' value='2119' />
<format type='TXT' octets='4723' target='http://www.rfc-editor.org/rfc/rfc2119.txt' />
<format type='HTML' octets='17491' target='http://xml.resource.org/public/rfc/html/rfc2119.html' />
<format type='XML' octets='5777' target='http://xml.resource.org/public/rfc/xml/rfc2119.xml' />
</reference>
<reference anchor='RFC2616'>
<front>
<title abbrev='HTTP/1.1'>Hypertext Transfer Protocol -- HTTP/1.1</title>
<author initials='R.' surname='Fielding' fullname='Roy T. Fielding'>
<organization abbrev='UC Irvine'>Department of Information and Computer Science</organization>
<address>
<postal>
<street>University of California, Irvine</street>
<city>Irvine</city>
<region>CA</region>
<code>92697-3425</code></postal>
<facsimile>+1(949)824-1715</facsimile>
<email>fielding@ics.uci.edu</email></address></author>
<author initials='J.' surname='Gettys' fullname='James Gettys'>
<organization abbrev='Compaq/W3C'>World Wide Web Consortium</organization>
<address>
<postal>
<street>MIT Laboratory for Computer Science, NE43-356</street>
<street>545 Technology Square</street>
<city>Cambridge</city>
<region>MA</region>
<code>02139</code></postal>
<facsimile>+1(617)258-8682</facsimile>
<email>jg@w3.org</email></address></author>
<author initials='J.' surname='Mogul' fullname='Jeffrey C. Mogul'>
<organization abbrev='Compaq'>Compaq Computer Corporation</organization>
<address>
<postal>
<street>Western Research Laboratory</street>
<street>250 University Avenue</street>
<city>Palo Alto</city>
<region>CA</region>
<code>94305</code></postal>
<email>mogul@wrl.dec.com</email></address></author>
<author initials='H.' surname='Frystyk' fullname='Henrik Frystyk Nielsen'>
<organization abbrev='W3C/MIT'>World Wide Web Consortium</organization>
<address>
<postal>
<street>MIT Laboratory for Computer Science, NE43-356</street>
<street>545 Technology Square</street>
<city>Cambridge</city>
<region>MA</region>
<code>02139</code></postal>
<facsimile>+1(617)258-8682</facsimile>
<email>frystyk@w3.org</email></address></author>
<author initials='L.' surname='Masinter' fullname='Larry Masinter'>
<organization abbrev='Xerox'>Xerox Corporation</organization>
<address>
<postal>
<street>MIT Laboratory for Computer Science, NE43-356</street>
<street>3333 Coyote Hill Road</street>
<city>Palo Alto</city>
<region>CA</region>
<code>94034</code></postal>
<email>masinter@parc.xerox.com</email></address></author>
<author initials='P.' surname='Leach' fullname='Paul J. Leach'>
<organization abbrev='Microsoft'>Microsoft Corporation</organization>
<address>
<postal>
<street>1 Microsoft Way</street>
<city>Redmond</city>
<region>WA</region>
<code>98052</code></postal>
<email>paulle@microsoft.com</email></address></author>
<author initials='T.' surname='Berners-Lee' fullname='Tim Berners-Lee'>
<organization abbrev='W3C/MIT'>World Wide Web Consortium</organization>
<address>
<postal>
<street>MIT Laboratory for Computer Science, NE43-356</street>
<street>545 Technology Square</street>
<city>Cambridge</city>
<region>MA</region>
<code>02139</code></postal>
<facsimile>+1(617)258-8682</facsimile>
<email>timbl@w3.org</email></address></author>
<date year='1999' month='June' />
<abstract>
<t>
The Hypertext Transfer Protocol (HTTP) is an application-level
protocol for distributed, collaborative, hypermedia information
systems. It is a generic, stateless, protocol which can be used for
many tasks beyond its use for hypertext, such as name servers and
distributed object management systems, through extension of its
request methods, error codes and headers . A feature of HTTP is
the typing and negotiation of data representation, allowing systems
to be built independently of the data being transferred.
</t>
<t>
HTTP has been in use by the World-Wide Web global information
initiative since 1990. This specification defines the protocol
referred to as "HTTP/1.1", and is an update to RFC 2068 .
</t></abstract></front>
<seriesInfo name='RFC' value='2616' />
<format type='TXT' octets='422317' target='http://www.rfc-editor.org/rfc/rfc2616.txt' />
<format type='PS' octets='5529857' target='http://www.rfc-editor.org/rfc/rfc2616.ps' />
<format type='PDF' octets='550558' target='http://www.rfc-editor.org/rfc/rfc2616.pdf' />
<format type='HTML' octets='636125' target='http://xml.resource.org/public/rfc/html/rfc2616.html' />
<format type='XML' octets='493420' target='http://xml.resource.org/public/rfc/xml/rfc2616.xml' />
</reference>
<!-- transclude from:
curl -s http://xml.resource.org/public/rfc/bibxml3/reference.I-D.ietf-core-coap.xml
-->
<reference anchor='I-D.ietf-core-coap'>
<front>
<title>Constrained Application Protocol (CoAP)</title>
<author initials='Z' surname='Shelby' fullname='Zach Shelby'>
<organization />
</author>
<author initials='B' surname='Frank' fullname='Brian Frank'>
<organization />
</author>
<author initials='D' surname='Sturek' fullname='Don Sturek'>
<organization />
</author>
<date month='October' day='25' year='2010' />
<abstract><t>This document specifies the Constrained Application Protocol (CoAP), a specialized web transfer protocol for use with constrained networks and nodes for machine-to-machine applications such as smart energy and building automation. These constrained nodes often have 8-bit microcontrollers with small amounts of ROM and RAM, while networks such as 6LoWPAN often have high packet error rates and a typical throughput of 10s of kbit/s. CoAP provides a method/response interaction model between application end-points, supports built-in resource discovery, and includes key web concepts such as URIs and content-types. CoAP easily translates to HTTP for integration with the web while meeting specialized requirements such as multicast support, very low overhead and simplicity for constrained environments.</t></abstract>
</front>
<seriesInfo name='Internet-Draft' value='draft-ietf-core-coap-03' />
<format type='TXT'
target='http://www.ietf.org/internet-drafts/draft-ietf-core-coap-03.txt' />
</reference>
</references>
<references title='Informative References'>
<reference anchor="REST">
<front>
<title>Architectural Styles and the Design of Network-based Software Architectures</title>
<author initials="R" surname="Fielding" fullname="Roy Fielding">
<organization>University of California, Irvine</organization>
</author>
<date year="2000" />
</front>
</reference>
</references>
</back>
</rfc>
<!-- LocalWords: CoAP datagram CoRE WG RESTful IP Etag reassembler
-->
<!-- LocalWords: blockwise idempotence statelessly keepalive
-->
<!-- LocalWords: acknowledgement
-->
| PAFTECH AB 2003-2026 | 2026-04-23 14:32:50 |