draft-ietf-cbor-array-tags-02.txt   draft-ietf-cbor-array-tags-03.txt 
Network Working Group J. Roatch Network Working Group J. Roatch
Internet-Draft Internet-Draft
Intended status: Informational C. Bormann Intended status: Informational C. Bormann
Expires: September 1, 2019 Universitaet Bremen TZI Expires: September 6, 2019 Universitaet Bremen TZI
February 28, 2019 March 05, 2019
Concise Binary Object Representation (CBOR) Tags for Typed Arrays Concise Binary Object Representation (CBOR) Tags for Typed Arrays
draft-ietf-cbor-array-tags-02 draft-ietf-cbor-array-tags-03
Abstract Abstract
The Concise Binary Object Representation (CBOR, RFC 7049) is a data The Concise Binary Object Representation (CBOR, RFC 7049) is a data
format whose design goals include the possibility of extremely small format whose design goals include the possibility of extremely small
code size, fairly small message size, and extensibility without the code size, fairly small message size, and extensibility without the
need for version negotiation. need for version negotiation.
The present document makes use of this extensibility to define a The present document makes use of this extensibility to define a
number of CBOR tags for typed arrays of numeric data, as well as two number of CBOR tags for typed arrays of numeric data, as well as two
skipping to change at page 1, line 40 skipping to change at page 1, line 40
Internet-Drafts are working documents of the Internet Engineering Internet-Drafts are working documents of the Internet Engineering
Task Force (IETF). Note that other groups may also distribute Task Force (IETF). Note that other groups may also distribute
working documents as Internet-Drafts. The list of current Internet- working documents as Internet-Drafts. The list of current Internet-
Drafts is at https://datatracker.ietf.org/drafts/current/. Drafts is at https://datatracker.ietf.org/drafts/current/.
Internet-Drafts are draft documents valid for a maximum of six months Internet-Drafts are draft documents valid for a maximum of six months
and may be updated, replaced, or obsoleted by other documents at any and may be updated, replaced, or obsoleted by other documents at any
time. It is inappropriate to use Internet-Drafts as reference time. It is inappropriate to use Internet-Drafts as reference
material or to cite them other than as "work in progress." material or to cite them other than as "work in progress."
This Internet-Draft will expire on September 1, 2019. This Internet-Draft will expire on September 6, 2019.
Copyright Notice Copyright Notice
Copyright (c) 2019 IETF Trust and the persons identified as the Copyright (c) 2019 IETF Trust and the persons identified as the
document authors. All rights reserved. document authors. All rights reserved.
This document is subject to BCP 78 and the IETF Trust's Legal This document is subject to BCP 78 and the IETF Trust's Legal
Provisions Relating to IETF Documents Provisions Relating to IETF Documents
(https://trustee.ietf.org/license-info) in effect on the date of (https://trustee.ietf.org/license-info) in effect on the date of
publication of this document. Please review these documents publication of this document. Please review these documents
skipping to change at page 2, line 17 skipping to change at page 2, line 17
include Simplified BSD License text as described in Section 4.e of include Simplified BSD License text as described in Section 4.e of
the Trust Legal Provisions and are provided without warranty as the Trust Legal Provisions and are provided without warranty as
described in the Simplified BSD License. described in the Simplified BSD License.
Table of Contents Table of Contents
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . 2 1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1. Terminology . . . . . . . . . . . . . . . . . . . . . . . 3 1.1. Terminology . . . . . . . . . . . . . . . . . . . . . . . 3
2. Typed Arrays . . . . . . . . . . . . . . . . . . . . . . . . 3 2. Typed Arrays . . . . . . . . . . . . . . . . . . . . . . . . 3
2.1. Types of numbers . . . . . . . . . . . . . . . . . . . . 3 2.1. Types of numbers . . . . . . . . . . . . . . . . . . . . 3
3. Additional Array Tags . . . . . . . . . . . . . . . . . . . . 4 3. Additional Array Tags . . . . . . . . . . . . . . . . . . . . 5
3.1. Multi-dimensional Array . . . . . . . . . . . . . . . . . 5 3.1. Multi-dimensional Array . . . . . . . . . . . . . . . . . 5
3.2. Homogeneous Array . . . . . . . . . . . . . . . . . . . . 7 3.2. Homogeneous Array . . . . . . . . . . . . . . . . . . . . 7
4. Discussion . . . . . . . . . . . . . . . . . . . . . . . . . 8 4. Discussion . . . . . . . . . . . . . . . . . . . . . . . . . 8
5. CDDL typenames . . . . . . . . . . . . . . . . . . . . . . . 9 5. CDDL typenames . . . . . . . . . . . . . . . . . . . . . . . 9
6. IANA Considerations . . . . . . . . . . . . . . . . . . . . . 10 6. IANA Considerations . . . . . . . . . . . . . . . . . . . . . 10
7. Security Considerations . . . . . . . . . . . . . . . . . . . 12 7. Security Considerations . . . . . . . . . . . . . . . . . . . 12
8. References . . . . . . . . . . . . . . . . . . . . . . . . . 13 8. References . . . . . . . . . . . . . . . . . . . . . . . . . 13
8.1. Normative References . . . . . . . . . . . . . . . . . . 13 8.1. Normative References . . . . . . . . . . . . . . . . . . 13
8.2. Informative References . . . . . . . . . . . . . . . . . 13 8.2. Informative References . . . . . . . . . . . . . . . . . 13
Contributors . . . . . . . . . . . . . . . . . . . . . . . . . . 14 Contributors . . . . . . . . . . . . . . . . . . . . . . . . . . 14
skipping to change at page 4, line 13 skipping to change at page 4, line 13
ArrayBuffers underlying the Typed Arrays without re-encoding them, ArrayBuffers underlying the Typed Arrays without re-encoding them,
and these may be either in big endian (network byte order) or in and these may be either in big endian (network byte order) or in
little endian form, we need to define tags for both variants. little endian form, we need to define tags for both variants.
In total, this leads to 24 variants. In the tag, we need to express In total, this leads to 24 variants. In the tag, we need to express
the choice between integer and floating point, the signedness (for the choice between integer and floating point, the signedness (for
integers), the endianness, and one of the four length values. integers), the endianness, and one of the four length values.
In order to simplify implementation, a range of tags is being In order to simplify implementation, a range of tags is being
allocated that allows retrieving all this information from the bits allocated that allows retrieving all this information from the bits
of the tag: Tag values from TBD64 to TBD87. of the tag: Tag values from 64 to 87.
The value is split up into 5 bit fields: TBD0b010_f_s_e_ll, as The value is split up into 5 bit fields: 0b010_f_s_e_ll, as detailed
detailed in Table 2. in Table 2.
+----------+-------------------------------------------------------+ +-------+-------------------------------------------------------+
| Field | Use | | Field | Use |
+----------+-------------------------------------------------------+ +-------+-------------------------------------------------------+
| TBD0b010 | a constant such as '010', to be defined | | 0b010 | the constant bits 0, 1, 0 |
| f | 0 for integer, 1 for float | | f | 0 for integer, 1 for float |
| s | 0 for unsigned integer or float, 1 for signed integer | | s | 0 for unsigned integer or float, 1 for signed integer |
| e | 0 for big endian, 1 for little endian | | e | 0 for big endian, 1 for little endian |
| ll | A number for the length (Table 1). | | ll | A number for the length (Table 1). |
+----------+-------------------------------------------------------+ +-------+-------------------------------------------------------+
Table 2: Bit fields in the low 8 bits of the tag Table 2: Bit fields in the low 8 bits of the tag
The number of bytes in each array element can then be calculated by The number of bytes in each array element can then be calculated by
"2**(f + ll)" (or "1 << (f + ll)" in a typical programming language). "2**(f + ll)" (or "1 << (f + ll)" in a typical programming language).
(Notice that f and ll are the lsb of each nibble (4bit) in the byte.) (Notice that f and ll are the lsb of each nibble (4bit) in the byte.)
In the CBOR representation, the total number of elements in the array In the CBOR representation, the total number of elements in the array
is not expressed explicitly, but implied from the length of the byte is not expressed explicitly, but implied from the length of the byte
string and the length of each representation. It can be computed string and the length of each representation. It can be computed
inversely to the previous formula: "bytelength >> (f + ll)". inversely to the previous formula from the length of the byte string
in bytes: "bytelength >> (f + ll)".
For the uint8/sint8 values, the endianness is redundant. Only the For the uint8/sint8 values, the endianness is redundant. Only the
big endian variant is used. The little endian variant of sint8 MUST big endian variant is used. The little endian variant of sint8 MUST
NOT be used, its tag is marked as reserved. As a special case, the NOT be used, its tag is marked as reserved. As a special case, the
tag number that would have been the little endian variant of uint8 is tag number that would have been the little endian variant of uint8 is
used to signify that the numbers in the array are using clamped used to signify that the numbers in the array are using clamped
conversion from integers, as described in more detail in Section 7.1 conversion from integers, as described in more detail in Section 7.1
of [TypedArrayUpdate]. of [TypedArrayUpdate].
3. Additional Array Tags 3. Additional Array Tags
skipping to change at page 5, line 11 skipping to change at page 5, line 17
This specification defines three additional array tags. The Multi- This specification defines three additional array tags. The Multi-
dimensional Array tags can be combined with classical CBOR arrays as dimensional Array tags can be combined with classical CBOR arrays as
well as with Typed Arrays in order to build multi-dimensional arrays well as with Typed Arrays in order to build multi-dimensional arrays
with constant numbers of elements in the sub-arrays. The Homogeneous with constant numbers of elements in the sub-arrays. The Homogeneous
Array tag can be used to facilitate the ingestion of homogeneous Array tag can be used to facilitate the ingestion of homogeneous
classical CBOR arrays, providing performance advantages even when a classical CBOR arrays, providing performance advantages even when a
Typed Array does not apply. Typed Array does not apply.
3.1. Multi-dimensional Array 3.1. Multi-dimensional Array
Tag: TBD40 Tag: 40
Data Item: array (major type 4) of two arrays, one array (major type Data Item: array (major type 4) of two arrays, one array (major type
4) of dimensions, and one array (major type 4, a Typed Array, or a 4) of dimensions, and one array (major type 4, a Typed Array, or a
Homogeneous Array) of elements Homogeneous Array) of elements
A multi-dimensional array is represented as a tagged array that A multi-dimensional array is represented as a tagged array that
contains two (one-dimensional) arrays. The first array defines the contains two (one-dimensional) arrays. The first array defines the
dimensions of the multi-dimensional array (in the sequence of outer dimensions of the multi-dimensional array (in the sequence of outer
dimensions towards inner dimensions) while the second array dimensions towards inner dimensions) while the second array
represents the contents of the multi-dimensional array. If the represents the contents of the multi-dimensional array. If the
skipping to change at page 5, line 37 skipping to change at page 6, line 10
Figure 1 shows a declaration of a two-dimensional array in the C Figure 1 shows a declaration of a two-dimensional array in the C
language, a representation of that in CBOR using both a language, a representation of that in CBOR using both a
multidimensional array tag and a typed array tag. multidimensional array tag and a typed array tag.
uint16_t a[2][3] = { uint16_t a[2][3] = {
{2, 4, 8}, /* row 0 */ {2, 4, 8}, /* row 0 */
{4, 16, 256}, {4, 16, 256},
}; };
<Tag TBD40> # multi-dimensional array tag <Tag 40> # multi-dimensional array tag
82 # array(2) 82 # array(2)
82 # array(2) 82 # array(2)
02 # unsigned(2) 1st Dimension 02 # unsigned(2) 1st Dimension
03 # unsigned(3) 2nd Dimension 03 # unsigned(3) 2nd Dimension
<Tag TBD65> # uint16 array <Tag 65> # uint16 array
4c # byte string(12) 4c # byte string(12)
0002 # unsigned(2) 0002 # unsigned(2)
0004 # unsigned(4) 0004 # unsigned(4)
0008 # unsigned(8) 0008 # unsigned(8)
0004 # unsigned(4) 0004 # unsigned(4)
0010 # unsigned(16) 0010 # unsigned(16)
0100 # unsigned(256) 0100 # unsigned(256)
Figure 1: Multi-dimensional array in C and CBOR Figure 1: Multi-dimensional array in C and CBOR
Figure 2 shows the same two-dimensional array using the Figure 2 shows the same two-dimensional array using the
multidimensional array tag in conjunction with a basic CBOR array multidimensional array tag in conjunction with a basic CBOR array
(which, with the small numbers chosen for the example, happens to be (which, with the small numbers chosen for the example, happens to be
shorter). shorter).
<Tag TBD40> # multi-dimensional array tag <Tag 40> # multi-dimensional array tag
82 # array(2) 82 # array(2)
82 # array(2) 82 # array(2)
02 # unsigned(2) 1st Dimension 02 # unsigned(2) 1st Dimension
03 # unsigned(3) 2nd Dimension 03 # unsigned(3) 2nd Dimension
86 # array(6) 86 # array(6)
02 # unsigned(2) 02 # unsigned(2)
04 # unsigned(4) 04 # unsigned(4)
08 # unsigned(8) 08 # unsigned(8)
04 # unsigned(4) 04 # unsigned(4)
10 # unsigned(16) 10 # unsigned(16)
19 0100 # unsigned(256) 19 0100 # unsigned(256)
Figure 2: Multi-dimensional array using basic CBOR array Figure 2: Multi-dimensional array using basic CBOR array
Tag: TBD1040 Tag: 1040
Data Item: as with tag TBD40 Data Item: as with tag 40
Note that above arrays are in "row major" order, which is the Note that above arrays are in "row major" order, which is the
preferred order for the purposes of this specification. An analogous preferred order for the purposes of this specification. An analogous
representation that uses "column major" order arrays is provided representation that uses "column major" order arrays is provided
under the tag TBD1040, as illustrated in Figure 3. under the tag 1040, as illustrated in Figure 3.
<Tag TBD1040> # multi-dimensional array tag, column major order <Tag 1040> # multi-dimensional array tag, column major order
82 # array(2) 82 # array(2)
82 # array(2) 82 # array(2)
02 # unsigned(2) 1st Dimension 02 # unsigned(2) 1st Dimension
03 # unsigned(3) 2nd Dimension 03 # unsigned(3) 2nd Dimension
86 # array(6) 86 # array(6)
02 # unsigned(2) 02 # unsigned(2)
04 # unsigned(4) 04 # unsigned(4)
04 # unsigned(4) 04 # unsigned(4)
10 # unsigned(16) 10 # unsigned(16)
08 # unsigned(8) 08 # unsigned(8)
19 0100 # unsigned(256) 19 0100 # unsigned(256)
Figure 3: Multi-dimensional array using basic CBOR array, column Figure 3: Multi-dimensional array using basic CBOR array, column
major order major order
3.2. Homogeneous Array 3.2. Homogeneous Array
Tag: TBD41 Tag: 41
Data Item: array (major type 4) Data Item: array (major type 4)
This tag provides a hint to decoders that the array tagged by it has This tag provides a hint to decoders that the array tagged by it has
elements that are all of the same application type. The element type elements that are all of the same application type. The element type
of the array is thus determined by the application type of the first of the array is thus determined by the application type of the first
array element. This can be used by implementations in strongly typed array element. This can be used by implementations in strongly typed
languages while decoding to create native homogeneous arrays of languages while decoding to create native homogeneous arrays of
specific types instead of ordered lists. specific types instead of ordered lists.
Which CBOR data items constitute elements of the same application Which CBOR data items constitute elements of the same application
type is specific to the application. However, type systems of type is specific to the application. However, type systems of
programming languages have enough commonality that an application programming languages have enough commonality that an application
should be able to create portable homogeneous arrays. should be able to create portable homogeneous arrays.
Figure 4 shows an example for a homogeneous array of booleans in C++ Figure 4 shows an example for a homogeneous array of booleans in C++
and CBOR. and CBOR.
bool boolArray[2] = { true, false }; bool boolArray[2] = { true, false };
<Tag TBD41> # Homogeneous Array Tag <Tag 41> # Homogeneous Array Tag
82 #array(2) 82 #array(2)
F5 # true F5 # true
F4 # false F4 # false
Figure 4: Homogeneous array in C++ and CBOR Figure 4: Homogeneous array in C++ and CBOR
Figure 5 extends the example with a more complex structure. Figure 5 extends the example with a more complex structure.
typedef struct { typedef struct {
bool active; bool active;
int value; int value;
} foo; } foo;
foo myArray[2] = { {true, 3}, {true, -4} }; foo myArray[2] = { {true, 3}, {true, -4} };
<Tag TBD41> <Tag 41>
82 # array(2) 82 # array(2)
82 # array(2) 82 # array(2)
F5 # true F5 # true
03 # 3 03 # 3
82 # array(2) 82 # array(2)
F5 # true F5 # true
23 # -4 23 # -4
Figure 5: Homogeneous array in C++ and CBOR Figure 5: Homogeneous array in C++ and CBOR
skipping to change at page 9, line 10 skipping to change at page 9, line 10
for row-major evident. for row-major evident.
Applying a Homogeneous Array tag to a Typed Array would be redundant Applying a Homogeneous Array tag to a Typed Array would be redundant
and is therefore not provided by the present specification. and is therefore not provided by the present specification.
5. CDDL typenames 5. CDDL typenames
For the use with CDDL [I-D.ietf-cbor-cddl], the typenames defined in For the use with CDDL [I-D.ietf-cbor-cddl], the typenames defined in
Figure 6 are recommended: Figure 6 are recommended:
ta-uint8 = #6.TBD64(bstr) ta-uint8 = #6.64(bstr)
ta-uint16be = #6.TBD65(bstr) ta-uint16be = #6.65(bstr)
ta-uint32be = #6.TBD66(bstr) ta-uint32be = #6.66(bstr)
ta-uint64be = #6.TBD67(bstr) ta-uint64be = #6.67(bstr)
ta-uint8-clamped = #6.TBD68(bstr) ta-uint8-clamped = #6.68(bstr)
ta-uint16le = #6.TBD69(bstr) ta-uint16le = #6.69(bstr)
ta-uint32le = #6.TBD70(bstr) ta-uint32le = #6.70(bstr)
ta-uint64le = #6.TBD71(bstr) ta-uint64le = #6.71(bstr)
ta-sint8 = #6.TBD72(bstr) ta-sint8 = #6.72(bstr)
ta-sint16be = #6.TBD73(bstr) ta-sint16be = #6.73(bstr)
ta-sint32be = #6.TBD74(bstr) ta-sint32be = #6.74(bstr)
ta-sint64be = #6.TBD75(bstr) ta-sint64be = #6.75(bstr)
; reserved: #6.TBD76(bstr) ; reserved: #6.76(bstr)
ta-sint16le = #6.TBD77(bstr) ta-sint16le = #6.77(bstr)
ta-sint32le = #6.TBD78(bstr) ta-sint32le = #6.78(bstr)
ta-sint64le = #6.TBD79(bstr) ta-sint64le = #6.79(bstr)
ta-float16be = #6.TBD80(bstr) ta-float16be = #6.80(bstr)
ta-float32be = #6.TBD81(bstr) ta-float32be = #6.81(bstr)
ta-float64be = #6.TBD82(bstr) ta-float64be = #6.82(bstr)
ta-float128be = #6.TBD83(bstr) ta-float128be = #6.83(bstr)
ta-float16le = #6.TBD84(bstr) ta-float16le = #6.84(bstr)
ta-float32le = #6.TBD85(bstr) ta-float32le = #6.85(bstr)
ta-float64le = #6.TBD86(bstr) ta-float64le = #6.86(bstr)
ta-float128le = #6.TBD87(bstr) ta-float128le = #6.87(bstr)
homogeneous<array> = #6.TBD41(array) homogeneous<array> = #6.41(array)
multi-dim<dim, array> = #6.TBD40([dim, array]) multi-dim<dim, array> = #6.40([dim, array])
multi-dim-column-major<dim, array> = #6.TBD1040([dim, array]) multi-dim-column-major<dim, array> = #6.1040([dim, array])
Figure 6: Recommended typenames for CDDL Figure 6: Recommended typenames for CDDL
6. IANA Considerations 6. IANA Considerations
IANA is requested to allocate the tags in Table 3, with the present IANA has allocated the tags in Table 3, with the present document as
document as the specification reference. (The reserved value is the specification reference. (The reserved value is reserved for a
reserved for a future revision of typed array tags.) future revision of typed array tags.)
The allocations come out of the "specification required" space The allocations came out of the "specification required" space
(24..255), with the exception of TBD1040, which comes out of the (24..255), with the exception of 1040, which came out of the "first
"first come first served" space (256..). come first served" space (256..).
+---------+------------------+--------------------------------------+ +------+-------------------+----------------------------------------+
| Tag | Data Item | Semantics | | Tag | Data Item | Semantics |
+---------+------------------+--------------------------------------+ +------+-------------------+----------------------------------------+
| TBD64 | byte string | uint8 Typed Array | | 64 | byte string | uint8 Typed Array |
| TBD65 | byte string | uint16, big endian, Typed Array | | 65 | byte string | uint16, big endian, Typed Array |
| TBD66 | byte string | uint32, big endian, Typed Array | | 66 | byte string | uint32, big endian, Typed Array |
| TBD67 | byte string | uint64, big endian, Typed Array | | 67 | byte string | uint64, big endian, Typed Array |
| TBD68 | byte string | uint8 Typed Array, clamped | | 68 | byte string | uint8 Typed Array, clamped arithmetic |
| | | arithmetic | | 69 | byte string | uint16, little endian, Typed Array |
| TBD69 | byte string | uint16, little endian, Typed Array | | 70 | byte string | uint32, little endian, Typed Array |
| TBD70 | byte string | uint32, little endian, Typed Array | | 71 | byte string | uint64, little endian, Typed Array |
| TBD71 | byte string | uint64, little endian, Typed Array | | 72 | byte string | sint8 Typed Array |
| TBD72 | byte string | sint8 Typed Array | | 73 | byte string | sint16, big endian, Typed Array |
| TBD73 | byte string | sint16, big endian, Typed Array | | 74 | byte string | sint32, big endian, Typed Array |
| TBD74 | byte string | sint32, big endian, Typed Array | | 75 | byte string | sint64, big endian, Typed Array |
| TBD75 | byte string | sint64, big endian, Typed Array | | 76 | byte string | (reserved) |
| TBD76 | byte string | (reserved) | | 77 | byte string | sint16, little endian, Typed Array |
| TBD77 | byte string | sint16, little endian, Typed Array | | 78 | byte string | sint32, little endian, Typed Array |
| TBD78 | byte string | sint32, little endian, Typed Array | | 79 | byte string | sint64, little endian, Typed Array |
| TBD79 | byte string | sint64, little endian, Typed Array | | 80 | byte string | IEEE 754 binary16, big endian, Typed |
| TBD80 | byte string | IEEE 754 binary16, big endian, Typed | | | | Array |
| | | Array | | 81 | byte string | IEEE 754 binary32, big endian, Typed |
| TBD81 | byte string | IEEE 754 binary32, big endian, Typed | | | | Array |
| | | Array | | 82 | byte string | IEEE 754 binary64, big endian, Typed |
| TBD82 | byte string | IEEE 754 binary64, big endian, Typed | | | | Array |
| | | Array | | 83 | byte string | IEEE 754 binary128, big endian, Typed |
| TBD83 | byte string | IEEE 754 binary128, big endian, | | | | Array |
| | | Typed Array | | 84 | byte string | IEEE 754 binary16, little endian, |
| TBD84 | byte string | IEEE 754 binary16, little endian, | | | | Typed Array |
| | | Typed Array | | 85 | byte string | IEEE 754 binary32, little endian, |
| TBD85 | byte string | IEEE 754 binary32, little endian, | | | | Typed Array |
| | | Typed Array | | 86 | byte string | IEEE 754 binary64, little endian, |
| TBD86 | byte string | IEEE 754 binary64, little endian, | | | | Typed Array |
| | | Typed Array | | 87 | byte string | IEEE 754 binary128, little endian, |
| TBD87 | byte string | IEEE 754 binary128, little endian, | | | | Typed Array |
| | | Typed Array | | 40 | array of two | Multi-dimensional Array, row-major |
| TBD40 | array of two | Multi-dimensional Array, row-major | | | arrays* | order |
| | arrays* | order | | 1040 | array of two | Multi-dimensional Array, column-major |
| TBD1040 | array of two | Multi-dimensional Array, column- | | | arrays* | order |
| | arrays* | major order | | 41 | array | Homogeneous Array |
| TBD41 | array | Homogeneous Array | +------+-------------------+----------------------------------------+
+---------+------------------+--------------------------------------+
Table 3: Values for Tags Table 3: Values for Tags
*) TBD40 or TBD1040 data item: second element of outer array in data *) 40 or 1040 data item: second element of outer array in data item
item is native CBOR array (major type 4) or Typed Array (one of Tag is native CBOR array (major type 4) or Typed Array (one of Tag
TBD64..TBD87) 64..87)
RFC editor note: Please replace TBDnn by the tag numbers allocated by
IANA throughout the document and delete this note; this also applies
to the binary representation TBD0b010 in Section 2.1, which becomes
0b010 if the numbers are allocated as proposed. IANA note: To make
the calculations work, TDB64 to TBD87 need to come from a contiguous
range the start of which is divisible by 32, which they do if the
"TBD" is simply removed.
7. Security Considerations 7. Security Considerations
The security considerations of RFC 7049 apply; special attention is The security considerations of RFC 7049 apply; special attention is
drawn to the second paragraph of Section 8 of RFC 7049. The tags drawn to the second paragraph of Section 8 of RFC 7049. The tags
introduced here are not expected to raise security considerations introduced here are not expected to raise security considerations
beyond those. beyond those.
8. References 8. References
skipping to change at page 14, line 8 skipping to change at page 14, line 8
[TypedArrayUpdate] [TypedArrayUpdate]
Herman, D. and K. Russell, "Typed Array Specification", Herman, D. and K. Russell, "Typed Array Specification",
July 2013, July 2013,
<https://www.khronos.org/registry/typedarray/specs/ <https://www.khronos.org/registry/typedarray/specs/
latest/>. latest/>.
Contributors Contributors
Glenn Engel suggested the tags for multi-dimensional arrays and Glenn Engel suggested the tags for multi-dimensional arrays and
homogeneous arrays, Jim Schaad reminded us that column-major order homogeneous arrays.
still is in use. IANA helped correct an error in a previous version.
Acknowledgements Acknowledgements
TBD Jim Schaad reminded us that column-major order still is in use. IANA
helped correct an error in a previous version.
Authors' Addresses Authors' Addresses
Johnathan Roatch Johnathan Roatch
Email: jroatch@gmail.com Email: jroatch@gmail.com
Carsten Bormann Carsten Bormann
Universitaet Bremen TZI Universitaet Bremen TZI
Postfach 330440 Postfach 330440
 End of changes. 26 change blocks. 
117 lines changed or deleted 110 lines changed or added

This html diff was produced by rfcdiff 1.47. The latest version is available from http://tools.ietf.org/tools/rfcdiff/