idnits 2.17.1 draft-ietf-cbor-array-tags-08.txt: Checking boilerplate required by RFC 5378 and the IETF Trust (see https://trustee.ietf.org/license-info): ---------------------------------------------------------------------------- No issues found here. Checking nits according to https://www.ietf.org/id-info/1id-guidelines.txt: ---------------------------------------------------------------------------- No issues found here. Checking nits according to https://www.ietf.org/id-info/checklist : ---------------------------------------------------------------------------- No issues found here. Miscellaneous warnings: ---------------------------------------------------------------------------- == The copyright year in the IETF Trust and authors Copyright Line does not match the current year -- The document date (October 08, 2019) is 1655 days in the past. Is this intentional? -- Found something which looks like a code comment -- if you have code sections in the document, please surround them with '' and '' lines. Checking references for intended status: Proposed Standard ---------------------------------------------------------------------------- (See RFCs 3967 and 4897 for information about using normative references to lower-maturity documents in RFCs) -- Looks like a reference, but probably isn't: '2' on line 375 -- Looks like a reference, but probably isn't: '3' on line 267 -- Possible downref: Non-RFC (?) normative reference: ref. 'C' -- Possible downref: Non-RFC (?) normative reference: ref. 'Cplusplus' -- Possible downref: Non-RFC (?) normative reference: ref. 'IEEE754' ** Obsolete normative reference: RFC 7049 (Obsoleted by RFC 8949) -- Possible downref: Non-RFC (?) normative reference: ref. 'TypedArrayES6' Summary: 1 error (**), 0 flaws (~~), 1 warning (==), 8 comments (--). Run idnits with the --verbose option for more detailed information about the items above. -------------------------------------------------------------------------------- 2 Network Working Group C. Bormann, Ed. 3 Internet-Draft Universitaet Bremen TZI 4 Intended status: Standards Track October 08, 2019 5 Expires: April 10, 2020 7 Concise Binary Object Representation (CBOR) Tags for Typed Arrays 8 draft-ietf-cbor-array-tags-08 10 Abstract 12 The Concise Binary Object Representation (CBOR, RFC 7049) is a data 13 format whose design goals include the possibility of extremely small 14 code size, fairly small message size, and extensibility without the 15 need for version negotiation. 17 The present document makes use of this extensibility to define a 18 number of CBOR tags for typed arrays of numeric data, as well as two 19 additional tags for multi-dimensional and homogeneous arrays. It is 20 intended as the reference document for the IANA registration of the 21 CBOR tags defined. 23 Status of This Memo 25 This Internet-Draft is submitted in full conformance with the 26 provisions of BCP 78 and BCP 79. 28 Internet-Drafts are working documents of the Internet Engineering 29 Task Force (IETF). Note that other groups may also distribute 30 working documents as Internet-Drafts. The list of current Internet- 31 Drafts is at https://datatracker.ietf.org/drafts/current/. 33 Internet-Drafts are draft documents valid for a maximum of six months 34 and may be updated, replaced, or obsoleted by other documents at any 35 time. It is inappropriate to use Internet-Drafts as reference 36 material or to cite them other than as "work in progress." 38 This Internet-Draft will expire on April 10, 2020. 40 Copyright Notice 42 Copyright (c) 2019 IETF Trust and the persons identified as the 43 document authors. All rights reserved. 45 This document is subject to BCP 78 and the IETF Trust's Legal 46 Provisions Relating to IETF Documents 47 (https://trustee.ietf.org/license-info) in effect on the date of 48 publication of this document. Please review these documents 49 carefully, as they describe your rights and restrictions with respect 50 to this document. Code Components extracted from this document must 51 include Simplified BSD License text as described in Section 4.e of 52 the Trust Legal Provisions and are provided without warranty as 53 described in the Simplified BSD License. 55 Table of Contents 57 1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . 2 58 1.1. Terminology . . . . . . . . . . . . . . . . . . . . . . . 3 59 2. Typed Arrays . . . . . . . . . . . . . . . . . . . . . . . . 3 60 2.1. Types of numbers . . . . . . . . . . . . . . . . . . . . 4 61 3. Additional Array Tags . . . . . . . . . . . . . . . . . . . . 5 62 3.1. Multi-dimensional Array . . . . . . . . . . . . . . . . . 6 63 3.1.1. Row-major Order . . . . . . . . . . . . . . . . . . . 6 64 3.1.2. Column-Major order . . . . . . . . . . . . . . . . . 7 65 3.2. Homogeneous Array . . . . . . . . . . . . . . . . . . . . 8 66 4. Discussion . . . . . . . . . . . . . . . . . . . . . . . . . 9 67 5. CDDL typenames . . . . . . . . . . . . . . . . . . . . . . . 10 68 6. IANA Considerations . . . . . . . . . . . . . . . . . . . . . 11 69 7. Security Considerations . . . . . . . . . . . . . . . . . . . 13 70 8. References . . . . . . . . . . . . . . . . . . . . . . . . . 14 71 8.1. Normative References . . . . . . . . . . . . . . . . . . 14 72 8.2. Informative References . . . . . . . . . . . . . . . . . 14 73 Contributors . . . . . . . . . . . . . . . . . . . . . . . . . . 15 74 Acknowledgements . . . . . . . . . . . . . . . . . . . . . . . . 15 75 Author's Address . . . . . . . . . . . . . . . . . . . . . . . . 15 77 1. Introduction 79 The Concise Binary Object Representation (CBOR, [RFC7049]) provides 80 for the interchange of structured data without a requirement for a 81 pre-agreed schema. RFC 7049 defines a basic set of data types, as 82 well as a tagging mechanism that enables extending the set of data 83 types supported via an IANA registry. 85 Recently, a simple form of typed arrays of numeric data has received 86 interest both in the Web graphics community [TypedArray] and in the 87 JavaScript specification [TypedArrayES6], as well as in corresponding 88 implementations [ArrayBuffer]. 90 Since these typed arrays may carry significant amounts of data, there 91 is interest in interchanging them in CBOR without the need of lengthy 92 conversion of each number in the array. This can also save space 93 overhead with encoding a type for each element of an array. 95 This document defines a number of interrelated CBOR tags that cover 96 these typed arrays, as well as two additional tags for multi- 97 dimensional and homogeneous arrays. It is intended as the reference 98 document for the IANA registration of the tags defined. 100 Note that an application that generates CBOR with these tags has 101 considerable freedom in choosing variants, e.g., with respect to 102 endianness, embedded type (signed vs. unsigned), and number of bits 103 per element, or whether a tag defined in this specification is used 104 at all instead of more basic CBOR. In contrast to representation 105 variants of single CBOR numbers, there is no representation that 106 could be identified as "preferred". If deterministic encoding is 107 desired in a CBOR-based protocol making use of these tags, the 108 protocol has to define which of the encoding variants are used in 109 which case. 111 1.1. Terminology 113 The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", 114 "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and 115 "OPTIONAL" in this document are to be interpreted as described in 116 BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all 117 capitals, as shown here. 119 The term "byte" is used in its now customary sense as a synonym for 120 "octet". Where bit arithmetic is explained, this document uses the 121 notation familiar from the programming language C [C] (including 122 C++14's 0bnnn binary literals [Cplusplus]), except that the operator 123 "**" stands for exponentiation. 125 The term "array" is used in a general sense in this document, unless 126 further specified. The term "classical CBOR array" describes an 127 array represented with CBOR major type 4. A "homogeneous array" is 128 an array of elements that are all of the same type (the term is 129 neutral as to whether that is a representation type or an application 130 data model type). 132 The terms "big endian" and "little endian" are used to indicate a 133 most significant byte first (MSB first) representation of integers, 134 and a least significant byte first (LSB first) representation, 135 respectively. 137 2. Typed Arrays 139 Typed arrays are homogeneous arrays of numbers, all of which are 140 encoded in a single form of binary representation. The concatenation 141 of these representations is encoded as a single CBOR byte string 142 (major type 2), enclosed by a single tag indicating the type and 143 encoding of all the numbers represented in the byte string. 145 2.1. Types of numbers 147 Three classes of numbers are of interest: unsigned integers (uint), 148 signed integers (two's complement, sint), and IEEE 754 binary 149 floating point numbers (which are always signed). For each of these 150 classes, there are multiple representation lengths in active use: 152 +-----------+--------+--------+-----------+ 153 | Length ll | uint | sint | float | 154 +-----------+--------+--------+-----------+ 155 | 0 | uint8 | sint8 | binary16 | 156 | 1 | uint16 | sint16 | binary32 | 157 | 2 | uint32 | sint32 | binary64 | 158 | 3 | uint64 | sint64 | binary128 | 159 +-----------+--------+--------+-----------+ 161 Table 1: Length values 163 Here, sintN stands for a signed integer of exactly N bits (for 164 instance, sint16), and uintN stands for an unsigned integer of 165 exactly N bits (for instance, uint32). The name binaryN stands for 166 the number form of the same name defined in IEEE 754 [IEEE754]. 168 Since one objective of these tags is to be able to directly ship the 169 ArrayBuffers underlying the Typed Arrays without re-encoding them, 170 and these may be either in big endian (network byte order) or in 171 little endian form, we need to define tags for both variants. 173 In total, this leads to 24 variants. In the tag, we need to express 174 the choice between integer and floating point, the signedness (for 175 integers), the endianness, and one of the four length values. 177 In order to simplify implementation, a range of tags is being 178 allocated that allows retrieving all this information from the bits 179 of the tag: Tag values from 64 to 87. 181 The value is split up into 5 bit fields: 0b010_f_s_e_ll, as detailed 182 in Table 2. 184 +-------+-------------------------------------------------------+ 185 | Field | Use | 186 +-------+-------------------------------------------------------+ 187 | 0b010 | the constant bits 0, 1, 0 | 188 | f | 0 for integer, 1 for float | 189 | s | 0 for float or unsigned integer, 1 for signed integer | 190 | e | 0 for big endian, 1 for little endian | 191 | ll | A number for the length (Table 1). | 192 +-------+-------------------------------------------------------+ 194 Table 2: Bit fields in the low 8 bits of the tag 196 The number of bytes in each array element can then be calculated by 197 "2**(f + ll)" (or "1 << (f + ll)" in a typical programming language). 198 (Notice that 0f and ll are the two least significant bits, 199 respectively, of each nibble (4bit) in the byte.) 201 In the CBOR representation, the total number of elements in the array 202 is not expressed explicitly, but implied from the length of the byte 203 string and the length of each representation. It can be computed 204 from the length, in bytes, of the byte string comprising the 205 representation of the array by inverting the previous formula: 206 "bytelength >> (f + ll)". 208 For the uint8/sint8 values, the endianness is redundant. Only the 209 tag for the big endian variant is used and assigned as such. The Tag 210 that would signify the little endian variant of sint8 MUST NOT be 211 used, its tag number is marked as reserved. As a special case, the 212 Tag that would signify the little endian variant of uint8 is instead 213 assigned to signify that the numbers in the array are using clamped 214 conversion from integers, as described in more detail in 215 Section 7.1.11 ("ToUint8Clamp") of the ES6 JavaScript specification 216 [TypedArrayES6]; the assumption here is that a program-internal 217 representation of this array after decoding would be marked this way 218 for further processing, providing "roundtripping" of JavaScript typed 219 arrays through CBOR. 221 IEEE 754 binary floating numbers are always signed. Therefore, for 222 the float variants ("f" == 1), there is no need to distinguish 223 between signed and unsigned variants; the "s" bit is always zero. 224 The Tag numbers where "s" would be one (which would have Tag values 225 88 to 95) remain free to use by other specifications. 227 3. Additional Array Tags 229 This specification defines three additional array tags. The Multi- 230 dimensional Array tags can be combined with classical CBOR arrays as 231 well as with Typed Arrays in order to build multi-dimensional arrays 232 with constant numbers of elements in the sub-arrays. The Homogeneous 233 Array tag can be used as a signal by an application to identify a 234 classical CBOR array as a homogeneous array, even when a Typed Array 235 does not apply. 237 3.1. Multi-dimensional Array 239 A multi-dimensional array is represented as a tagged array that 240 contains two (one-dimensional) arrays. The first array defines the 241 dimensions of the multi-dimensional array (in the sequence of outer 242 dimensions towards inner dimensions) while the second array 243 represents the contents of the multi-dimensional array. If the 244 second array is itself tagged as a Typed Array then the element type 245 of the multi-dimensional array is known to be the same type as that 246 of the Typed Array. 248 Two tags are defined by this document, one for elements arranged in 249 row-major order, and one for column-major order [RowColMajor]. 251 3.1.1. Row-major Order 253 Tag: 40 255 Data Item: array (major type 4) of two arrays, one array (major type 256 4) of dimensions, which are unsigned integers distinct from zero, 257 and one array (either a CBOR array of major type 4, or a Typed 258 Array, or a Homogeneous Array) of elements 260 Data in the second array consists of consecutive values where the 261 last dimension is considered contiguous (row-major order). 263 Figure 1 shows a declaration of a two-dimensional array in the C 264 language, a representation of that in CBOR using both a 265 multidimensional array tag and a typed array tag. 267 uint16_t a[2][3] = { 268 {2, 4, 8}, /* row 0 */ 269 {4, 16, 256}, 270 }; 272 # multi-dimensional array tag 273 82 # array(2) 274 82 # array(2) 275 02 # unsigned(2) 1st Dimension 276 03 # unsigned(3) 2nd Dimension 277 # uint16 array 278 4c # byte string(12) 279 0002 # unsigned(2) 280 0004 # unsigned(4) 281 0008 # unsigned(8) 282 0004 # unsigned(4) 283 0010 # unsigned(16) 284 0100 # unsigned(256) 286 Figure 1: Multi-dimensional array in C and CBOR 288 Figure 2 shows the same two-dimensional array using the 289 multidimensional array tag in conjunction with a basic CBOR array 290 (which, with the small numbers chosen for the example, happens to be 291 shorter). 293 # multi-dimensional array tag 294 82 # array(2) 295 82 # array(2) 296 02 # unsigned(2) 1st Dimension 297 03 # unsigned(3) 2nd Dimension 298 86 # array(6) 299 02 # unsigned(2) 300 04 # unsigned(4) 301 08 # unsigned(8) 302 04 # unsigned(4) 303 10 # unsigned(16) 304 19 0100 # unsigned(256) 306 Figure 2: Multi-dimensional array using basic CBOR array 308 3.1.2. Column-Major order 310 The multidimensional arrays specified in the previous sub-subsection 311 are in "row major" order, which is the preferred order for the 312 purposes of this specification. An analogous representation that 313 uses "column major" order arrays is provided in this subsection under 314 the tag 1040, as illustrated in Figure 3. 316 Tag: 1040 318 Data Item: as with tag 40, except that the data in the second array 319 consists of consecutive values where the first dimension is 320 considered contiguous (column-major order). 322 # multi-dimensional array tag, column major order 323 82 # array(2) 324 82 # array(2) 325 02 # unsigned(2) 1st Dimension 326 03 # unsigned(3) 2nd Dimension 327 86 # array(6) 328 02 # unsigned(2) 329 04 # unsigned(4) 330 04 # unsigned(4) 331 10 # unsigned(16) 332 08 # unsigned(8) 333 19 0100 # unsigned(256) 335 Figure 3: Multi-dimensional array using basic CBOR array, column 336 major order 338 3.2. Homogeneous Array 340 Tag: 41 342 Data Item: array (major type 4) 344 This tag identifies the classical CBOR array (a one-dimensional 345 array) tagged by it as a homogeneous array, that is, it has elements 346 that are all of the same application model data type. The element 347 type of the array is thus determined by the application model data 348 type of the first array element. 350 This can be used in application data models that apply specific 351 semantics to homogeneous arrays. Also, in certain cases, 352 implementations in strongly typed languages may be able to create 353 native homogeneous arrays of specific types instead of ordered lists 354 while decoding. Which CBOR data items constitute elements of the 355 same application type is specific to the application. 357 Figure 4 shows an example for a homogeneous array of booleans in C++ 358 [Cplusplus] and CBOR. 360 bool boolArray[2] = { true, false }; 362 # Homogeneous Array Tag 363 82 #array(2) 364 F5 # true 365 F4 # false 367 Figure 4: Homogeneous array in C++ and CBOR 369 Figure 5 extends the example with a more complex structure. 371 typedef struct { 372 bool active; 373 int value; 374 } foo; 375 foo myArray[2] = { {true, 3}, {true, -4} }; 377 378 82 # array(2) 379 82 # array(2) 380 F5 # true 381 03 # 3 382 82 # array(2) 383 F5 # true 384 23 # -4 386 Figure 5: Homogeneous array in C++ and CBOR 388 4. Discussion 390 Support for both little- and big-endian representation may seem out 391 of character with CBOR, which is otherwise fully big endian. This 392 support is in line with the intended use of the typed arrays and the 393 objective not to require conversion of each array element. 395 This specification allocates a sizable chunk out of the single-byte 396 tag space. This use of code point space is justified by the wide use 397 of typed arrays in data interchange. 399 Providing a column-major order variant of the multi-dimensional array 400 may seem superfluous to some, and useful to others. It is cheap to 401 define the additional tag so it is available when actually needed. 402 Allocating it out of a different number space makes the preference 403 for row-major evident. 405 Applying a Homogeneous Array tag to a Typed Array would usually be 406 redundant and is therefore not provided by the present specification. 408 5. CDDL typenames 410 For the use with CDDL [RFC8610], the typenames defined in Figure 6 411 are recommended: 413 ta-uint8 = #6.64(bstr) 414 ta-uint16be = #6.65(bstr) 415 ta-uint32be = #6.66(bstr) 416 ta-uint64be = #6.67(bstr) 417 ta-uint8-clamped = #6.68(bstr) 418 ta-uint16le = #6.69(bstr) 419 ta-uint32le = #6.70(bstr) 420 ta-uint64le = #6.71(bstr) 421 ta-sint8 = #6.72(bstr) 422 ta-sint16be = #6.73(bstr) 423 ta-sint32be = #6.74(bstr) 424 ta-sint64be = #6.75(bstr) 425 ; reserved: #6.76(bstr) 426 ta-sint16le = #6.77(bstr) 427 ta-sint32le = #6.78(bstr) 428 ta-sint64le = #6.79(bstr) 429 ta-float16be = #6.80(bstr) 430 ta-float32be = #6.81(bstr) 431 ta-float64be = #6.82(bstr) 432 ta-float128be = #6.83(bstr) 433 ta-float16le = #6.84(bstr) 434 ta-float32le = #6.85(bstr) 435 ta-float64le = #6.86(bstr) 436 ta-float128le = #6.87(bstr) 437 homogeneous = #6.41(array) 438 multi-dim = #6.40([dim, array]) 439 multi-dim-column-major = #6.1040([dim, array]) 441 Figure 6: Recommended typenames for CDDL 443 6. IANA Considerations 445 IANA has allocated the tags in Table 3, with the present document as 446 the specification reference. (The reserved value is reserved for a 447 future revision of typed array tags.) 449 The allocations came out of the "specification required" space 450 (24..255), with the exception of 1040, which came out of the "first 451 come first served" space (256..). 453 +------+-------------------+----------------------------------------+ 454 | Tag | Data Item | Semantics | 455 +------+-------------------+----------------------------------------+ 456 | 64 | byte string | uint8 Typed Array | 457 | 65 | byte string | uint16, big endian, Typed Array | 458 | 66 | byte string | uint32, big endian, Typed Array | 459 | 67 | byte string | uint64, big endian, Typed Array | 460 | 68 | byte string | uint8 Typed Array, clamped arithmetic | 461 | 69 | byte string | uint16, little endian, Typed Array | 462 | 70 | byte string | uint32, little endian, Typed Array | 463 | 71 | byte string | uint64, little endian, Typed Array | 464 | 72 | byte string | sint8 Typed Array | 465 | 73 | byte string | sint16, big endian, Typed Array | 466 | 74 | byte string | sint32, big endian, Typed Array | 467 | 75 | byte string | sint64, big endian, Typed Array | 468 | 76 | byte string | (reserved) | 469 | 77 | byte string | sint16, little endian, Typed Array | 470 | 78 | byte string | sint32, little endian, Typed Array | 471 | 79 | byte string | sint64, little endian, Typed Array | 472 | 80 | byte string | IEEE 754 binary16, big endian, Typed | 473 | | | Array | 474 | 81 | byte string | IEEE 754 binary32, big endian, Typed | 475 | | | Array | 476 | 82 | byte string | IEEE 754 binary64, big endian, Typed | 477 | | | Array | 478 | 83 | byte string | IEEE 754 binary128, big endian, Typed | 479 | | | Array | 480 | 84 | byte string | IEEE 754 binary16, little endian, | 481 | | | Typed Array | 482 | 85 | byte string | IEEE 754 binary32, little endian, | 483 | | | Typed Array | 484 | 86 | byte string | IEEE 754 binary64, little endian, | 485 | | | Typed Array | 486 | 87 | byte string | IEEE 754 binary128, little endian, | 487 | | | Typed Array | 488 | 40 | array of two | Multi-dimensional Array, row-major | 489 | | arrays* | order | 490 | 1040 | array of two | Multi-dimensional Array, column-major | 491 | | arrays* | order | 492 | 41 | array | Homogeneous Array | 493 +------+-------------------+----------------------------------------+ 495 Table 3: Values for Tags 497 *) 40 or 1040 data item: second element of outer array in data item 498 is native CBOR array (major type 4) or Typed Array (one of Tag 499 64..87) 501 7. Security Considerations 503 The security considerations of RFC 7049 apply; special attention is 504 drawn to the second paragraph of Section 8 of RFC 7049. 506 The Tag for homogeneous arrays makes a promise about its tagged data 507 item that a maliciously constructed CBOR input can then choose to 508 ignore. As always, the decoder therefore has to ensure that it is 509 not driven into an undefined state by array elements that do not 510 fulfill the promise and that it does continue to fulfill its API 511 contract in this case as well. 513 As with all formats that are used for data interchange, an attacker 514 may have control over the shape of the data delivered as input to the 515 application, which therefore needs to validate that shape before it 516 makes it the basis of its further processing. One unique aspect that 517 typed arrays add to this is that an attacker might substitute a 518 Uint8ClampedArray for where the application expects a Uint8Array, or 519 vice versa, potentially leading to very different (and unexpected) 520 processing semantics of the in-memory data structures constructed. 521 Applications that could be affected by this therefore will need to be 522 careful about making this distinction in their input validation. 524 8. References 526 8.1. Normative References 528 [C] "Information technology -- Programming languages -- C", 529 ISO/IEC 9899, 2018. 531 [Cplusplus] 532 "Programming languages -- C++", ISO/IEC 14882, 2017. 534 [IEEE754] IEEE, "IEEE Standard for Floating-Point Arithmetic", IEEE 535 Std 754-2008. 537 [RFC2119] Bradner, S., "Key words for use in RFCs to Indicate 538 Requirement Levels", BCP 14, RFC 2119, 539 DOI 10.17487/RFC2119, March 1997, 540 . 542 [RFC7049] Bormann, C. and P. Hoffman, "Concise Binary Object 543 Representation (CBOR)", RFC 7049, DOI 10.17487/RFC7049, 544 October 2013, . 546 [RFC8174] Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC 547 2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174, 548 May 2017, . 550 [RFC8610] Birkholz, H., Vigano, C., and C. Bormann, "Concise Data 551 Definition Language (CDDL): A Notational Convention to 552 Express Concise Binary Object Representation (CBOR) and 553 JSON Data Structures", RFC 8610, DOI 10.17487/RFC8610, 554 June 2019, . 556 [TypedArrayES6] 557 "22.2 TypedArray Objects", in: ECMA-262 6th Edition, The 558 ECMAScript 2015 Language Specification, June 2015, 559 . 562 8.2. Informative References 564 [ArrayBuffer] 565 Mozilla Developer Network, "JavaScript typed arrays", 566 2013, . 569 [RowColMajor] 570 Wikipedia, "Row- and column-major order", September 2019, 571 . 574 [TypedArray] 575 Vukicevic, V. and K. Russell, "Typed Array Specification", 576 February 2011, 577 . 580 Contributors 582 The initial draft for this specification was written by Johnathan 583 Roatch (roatch@gmail.com). Many thanks for getting this ball 584 rolling. 586 Glenn Engel suggested the tags for multi-dimensional arrays and 587 homogeneous arrays. 589 Acknowledgements 591 Jim Schaad provided helpful comments and reminded us that column- 592 major order still is in use. Jeffrey Yaskin helped improve the 593 definition of homogeneous arrays. IANA helped correct an error in a 594 previous version. Francesca Palombini acted as a shepherd, and 595 Alexey Melnikov as responsible area director. Elwyn Davies as Gen- 596 ART reviewer and IESG members Martin Vigoureux, Adam Roach, Roman 597 Danyliw, and Benjamin Kaduk helped finding further improvements of 598 the text; thanks also to the other reviewers. 600 Author's Address 602 Carsten Bormann (editor) 603 Universitaet Bremen TZI 604 Postfach 330440 605 Bremen D-28359 606 Germany 608 Phone: +49-421-218-63921 609 Email: cabo@tzi.org