[Docs] [txt|pdf] [Tracker] [Email] [Diff1] [Diff2] [Nits]

Versions: (draft-hudson-ayers) 00 01

Independent Submission                                          H. Ayers
Internet-Draft                                                  P. Levis
Intended status: Informational                       Stanford University
Expires: January 14, 2021                                  July 13, 2020


         Design Considerations for Low Power Internet Protocols
                    draft-ayers-low-power-interop-01

Abstract

   Low-power wireless networks provide IPv6 connectivity through
   6LoWPAN, a set of standards to aggressively compress IPv6 packets
   over small maximum transfer unit (MTU) links such as 802.15.4.

   The entire purpose of IP was to interconnect different networks, but
   we find that different 6LoWPAN implementations fail to reliably
   communicate with one another.  These failures are due to stacks
   implementing different subsets of the standard out of concern for
   code size.  We argue that this failure stems from 6LoWPAN's design,
   not implementation, and is due to applying traditional Internet
   protocol design principles to low-power networks.

   We propose three design principles for Internet protocols on low-
   power networks, designed to prevent similar failures in the future.
   These principles are based around the importance of providing
   flexible tradeoffs between code size and energy efficiency.  We apply
   these principles to 6LoWPAN and show that the modified protocol
   provides a wide range of implementation strategies while allowing
   implementations with different strategies to reliably communicate.

Status of This Memo

   This Internet-Draft is submitted in full conformance with the
   provisions of BCP 78 and BCP 79.

   Internet-Drafts are working documents of the Internet Engineering
   Task Force (IETF).  Note that other groups may also distribute
   working documents as Internet-Drafts.  The list of current Internet-
   Drafts is at https://datatracker.ietf.org/drafts/current/.

   Internet-Drafts are draft documents valid for a maximum of six months
   and may be updated, replaced, or obsoleted by other documents at any
   time.  It is inappropriate to use Internet-Drafts as reference
   material or to cite them other than as "work in progress."

   This Internet-Draft will expire on January 14, 2021.




Ayers & Levis           Expires January 14, 2021                [Page 1]


Internet-Draft                 Design-Low                      July 2020


Copyright Notice

   Copyright (c) 2020 IETF Trust and the persons identified as the
   document authors.  All rights reserved.

   This document is subject to BCP 78 and the IETF Trust's Legal
   Provisions Relating to IETF Documents
   (https://trustee.ietf.org/license-info) in effect on the date of
   publication of this document.  Please review these documents
   carefully, as they describe your rights and restrictions with respect
   to this document.  Code Components extracted from this document must
   include Simplified BSD License text as described in Section 4.e of
   the Trust Legal Provisions and are provided without warranty as
   described in the Simplified BSD License.

Table of Contents

   1.  Introduction  . . . . . . . . . . . . . . . . . . . . . . . .   2
   2.  Background  . . . . . . . . . . . . . . . . . . . . . . . . .   4
   3.  6LoWPAN Today . . . . . . . . . . . . . . . . . . . . . . . .   6
   4.  Traditional Principles: Not Low-Power . . . . . . . . . . . .  10
   5.  Three Principles  . . . . . . . . . . . . . . . . . . . . . .  10
     5.1.  Principle 1: Capability Spectrum  . . . . . . . . . . . .  10
     5.2.  Principle 2: Capability Discovery . . . . . . . . . . . .  11
     5.3.  Principle 3: Explicit and Finite Bounds . . . . . . . . .  12
   6.  A Principled 6LoWPAN  . . . . . . . . . . . . . . . . . . . .  12
     6.1.  Principle 1: Capability Spectrum  . . . . . . . . . . . .  13
     6.2.  Principle 2: Capability Discovery . . . . . . . . . . . .  16
     6.3.  Principle 3: Provide Reasonable Bounds  . . . . . . . . .  16
   7.  Evaluation  . . . . . . . . . . . . . . . . . . . . . . . . .  17
     7.1.  Implementations . . . . . . . . . . . . . . . . . . . . .  17
     7.2.  Compile-Time Costs  . . . . . . . . . . . . . . . . . . .  18
     7.3.  Run-time Performance  . . . . . . . . . . . . . . . . . .  20
   8.  Discussion and Conclusions  . . . . . . . . . . . . . . . . .  21
   9.  Definitions . . . . . . . . . . . . . . . . . . . . . . . . .  22
     9.1.  Terminology . . . . . . . . . . . . . . . . . . . . . . .  22
   10. Security Considerations . . . . . . . . . . . . . . . . . . .  22
   11. IANA Considerations . . . . . . . . . . . . . . . . . . . . .  22
   12. References  . . . . . . . . . . . . . . . . . . . . . . . . .  22
     12.1.  Normative References . . . . . . . . . . . . . . . . . .  22
     12.2.  Informative References . . . . . . . . . . . . . . . . .  23
   Authors' Addresses  . . . . . . . . . . . . . . . . . . . . . . .  25

1.  Introduction

   Interoperability has been fundamental to the Internet's success.  The
   Internet Protocol (IP) allows devices with different software and
   link layers to communicate.  IP provides a basic communication



Ayers & Levis           Expires January 14, 2021                [Page 2]


Internet-Draft                 Design-Low                      July 2020


   substrate for many higher layer protocols and applications.  In the
   decades of the Internet's evolution, we have accumulated and
   benefited from a great deal of wisdom and guidance in how to design,
   specify, and implement robust, interoperable protocols.

   Over the past decade, the Internet has extended to tens of billions
   of low-power, embedded systems such as sensor networks and the
   Internet of Things.  Hundreds of proprietary protocols have been
   replaced by 6LoWPAN, a standardized format for IP networking on low-
   power wireless link layers such as 802.15.4 [RFC6282] and Bluetooth
   Low Energy [RFC7668]. 6LoWPAN was created with the express purpose of
   bringing interoperable IP networking to low power devices, as stated
   in the 6LoWPAN WG charter.  Many embedded operating systems have
   adopted 6LoWPAN, [tinyos] [riot] [mbedos] [contiki-ng] [contiki]
   [lite-os] and [zephyr], and every major protocol suite uses it
   (zigbee, openthread).  In fact, devices today can communicate with
   the broader Internet.

   However, in many cases 6LoWPAN implementations cannot communicate
   _with each other_. We find that no pairing of the major
   implementations fully interoperates.  Despite 6LoWPAN's focus on
   interoperability, two key features of the protocol -- range extension
   via mesh networking of devices, and the convenience of different
   vendors being able to share a gateway -- are largely impossible 10
   years later.

   Each of the openly available 6LoWPAN stacks, most of which are used
   in production, implements a subset of the protocol _and_ includes
   compile-time flags to cut out additional compression/decompression
   options.  As a result, two devices might both use 6LoWPAN, yet be
   unable to exchange certain IP packets because they use required
   features the other does not implement.  This is especially
   problematic for gateways, which _need_ to be able to talk to multiple
   implementations to enable significant scaling in real world
   applications.

   This draft argues that the failure of 6LoWPAN interoperability stems
   from applying traditional protocol design principles to low-power
   networks.  Low-power protocols minimize energy consumption via
   compression.  Squeezing every bit out of packet headers, however,
   requires many different options/operating modes.  Principles such as
   Postel's Law - "Be liberal in what you accept, and conservative in
   what you send" [RFC1122] - state that an implementation must be able
   to receive every feature, even thought it only sends some of them.
   However, code space is tight on many systems.  As a result, when an
   application does not fit, developers cut out portions of the
   networking stack and stop working with other devices.  Put another
   way, 3kB of unused compression code seems tiny, but when removing it



Ayers & Levis           Expires January 14, 2021                [Page 3]


Internet-Draft                 Design-Low                      July 2020


   allows an additional 3kB of useful features, developers cut out parts
   of 6LoWPAN and devices become part of a custom networked system
   rather than the Internet.

   This draft presents three design principles which resolve this
   tension between interoperability and efficiency.  Protocols following
   these principles get the best of both worlds: resource-limited
   devices can implement subsets of a protocol to save code space while
   remaining able to communicate with every other implementation.

   *Capability spectrum:* a low-power protocol specifies a linear
   spectrum of capabilities.  Simpler implementations have fewer
   capabilities and save less energy, while fuller implementations have
   strictly more capabilities and are able to save more energy.  When
   two devices differ in capability levels, communication can always
   fall back to the lower one.

   *Capability discovery:* a low-power protocol provides mechanisms to
   discover the capability of communicating devices.  This discovery can
   be proactive (advertisements) or reactive (in response to errors).

   *Explicit, finite bounds:* a low-power protocol specifies explicit,
   finite bounds on growth during decompression.  Without explicit
   bounds, buffers must be sized too conservatively.  In practice,
   implementations allocate smaller buffers and silently drop packets
   they cannot decompress.

   This draft is not the first to observe poor 6LoWPAN interoperability
   [probe-it-plugtest], but it is the first to identify this root cause.
   It is the first to define design principles for protocols that allow
   implementations to reduce code size and still interoperate.  This
   draft examines how these principles could be applied to a low power
   protocol and evaluates the overhead of doing so.  It finds that
   applying these principles to 6LoWPAN promises interoperability across
   a wide range of device capabilities, while imposing a code size cost
   of less than 10%. In particular, capability discovery requires an
   order of magnitude less code than the code size difference at the
   extremes of our capability spectrum, with minimal runtime overhead.

2.  Background

   6LoWPAN is a set of standards on communicating IPv6 over low-power
   wireless link layers such as IEEE 802.15.4 and Bluetooth[RFC4944]
   [RFC6282] [RFC7668].  6LoWPAN primarily specifies two things:
   aggressive compression of IPv6 headers and how to fragment/re-
   assemble packets on link layers whose MTU is smaller than the minimum
   1280 bytes required by IPv6. 6LoWPAN also specifies optimized IPv6




Ayers & Levis           Expires January 14, 2021                [Page 4]


Internet-Draft                 Design-Low                      July 2020


   Neighbor Discovery.  6LoWPAN is critical to ensuring that IPv6
   communication does not exceed the energy budget of low power systems.

   The interoperability IP provides is a goal in and of itself, and so
   many different network stacks, including ZigBee and Thread, have
   transitioned to supporting IP connectivity with 6LoWPAN.  IP
   connectivity allows systems to easily incorporate new services and
   applications, and allows applications to build on all of the existing
   Internet systems, such as network management and monitoring.

   *Low Power Hardware and Operating Systems*


         **IoT Platform**       **Code (kB)**   **Year**
         -------------------- --------------- ----------
         EMB-WMB                           64       2012
         Zolertia Z1                       92       2013
         TI CC2650                        128       2015
         NXP MKW40Z                       160       2015
         SAMR21 XPro                      256       2014
         Nordic NRF52840 DK               512       2018

                 Figure 1: Flash Size across IoT Platforms

   Figure 1 shows a variety of older and more recent low-power
   platforms.  Modern microcontrollers typically have 128-512 kB of code
   flash.  Applications often struggle with these limits on code flash,
   and rarely leave code space unused.  Embedded systems are application
   specific, and use their limited available resources toward different
   ends.  Despite this, they still rely on a small number of reusable
   OSes for basic abstractions.

   To support the highly constrained applications and devices for which
   embedded OSes are used, embedded OSes must be minimal.  However, the
   manner in which they must be minimal varies - some applications
   require minimal use of radio energy, which can require code size
   consuming techniques like compression, while others require tiny/low
   cost MCUs without space for those mechanisms.  To support this
   variety, OSes have compile-time flags to include or exclude parts of
   the system or networking stack (contiki,mbedos,contiki-ng).  Some
   systems take a more extreme approach, dynamically generating the
   minimum code to compile from the application itself (tinyos).  Part
   of this minimalist focus is that until application developers demand
   certain features, OSes are likely to leave them out entirely (a
   requirement often specified in contribution guides - contiki-ng).
   These techniques are critical to ensuring a given OS can support a
   wide range of embedded platforms, and influence the implementation of
   network protocols.



Ayers & Levis           Expires January 14, 2021                [Page 5]


Internet-Draft                 Design-Low                      July 2020


3.  6LoWPAN Today

   The original 6LoWPAN working group charter stated "The Working Group
   will generate the necessary documents to ensure interoperable
   implementations of 6LoWPAN networks".  However looking at
   implementations today, we find that each includes a different subset
   of the protocol.  Source code shows this is due to concerns with code
   size.  Experiences with a new implementation verify these concerns.

   *Feature Fail* A 6LoWPAN receiver has much less flexibility than a
   sender: it must be able to process any valid compression it receives.
   Figure 2 shows the receiver features supported by 6 major open-source
   6LoWPAN stacks.  Some, such as TinyOS, are mostly developed and used
   in academia.  Others, such as ARM Mbed and Nest's OpenThread, are
   developed and supported commercially.  Contiki and Contiki-NG sit
   somewhere in the middle, having both significant academic and
   commercial use.  Riot is an open-source OS with hundreds of
   contributors for industrial, academic, and hobbyist use.  Two widely
   used open source stacks excluded from this analysis are LiteOS
   [lite-os] and Zephyr [zephyr] -- they are excluded because LiteOS
   uses the same 6LoWPAN library (LWIP) used in MBED-OS, and Zephyr
   simply imports OpenThread.

   In almost all cases, each stack's support for features is symmetric
   for sending and receiving.  There are significant mismatches in
   feature support between stacks.  These mismatches lead to
   deterministic cases when IP communication fails.  We verified these
   failures by modifying existing network applications and testing them
   on hardware, using Wireshark to verify packets were compressed and
   formatted as we expected when receivers failed to decode packets.
   Every implementation pair fails for some type of packet which can be
   organically generated by one of the stacks.  This result may be
   surprising when compared to prior work which demonstrated successful
   interoperability, such as [RPL-interop].  However, this early success
   preceded the release of RFC 6282, which increased the complexity (and
   overhead) of 6LoWPAN.















Ayers & Levis           Expires January 14, 2021                [Page 6]


Internet-Draft                 Design-Low                      July 2020


     Feature                                          Stack
     ------------------------------------- ------- -- -- ---- --- ------
                                           Contiki NG OT Riot Arm TinyOS
     ------------------------------------- ------- -- -- ---- --- ------
     Uncompressed IPv6                        o    o      o    o    o
     6LoWPAN Fragmentation                    o    o   o  o    o    o
     1280 byte packets                        o    o   o  o    o    o
     Dispatch_IPHC header prefix              o    o   o  o    o    o
     IPv6 Stateless Address Compression       o    o   o  o    o    o
     Stateless multicast addr compression     o    o   o  o    o    o
     802.15.4 16 bit short address support         o   o  o    o    o
     IPv6 Address Autoconfiguration           o    o   o  o    o    o
     Stateful Address Compression             o    o   o  o    o    o
     Stateful multicast addr compression               o  o    o
     TC and Flow label compression            o    o   o  o    o    o
     NH Compression: Ipv6 (tunneled)                   o       o    o
     IPv6 NH Compression: UDP                 o    o   o  o    o    o
     UDP port compression                     o    o   o  o    o    o
     UDP checksum elision                                           o
     Compression + headers past first frag                o    o
     Compression of IPv6 Extension Headers         ~   ~       o    o
     Mesh Header                                       o       o    ~
     Broadcast Header                                               o
     Regular IPv6 ND                          o    o      o    o    ~
     RFC 6775 6LoWPAN ND                                  o    o
     RFC 7400 Generic Header Compression
     ------------------------------------- ------- -- -- ---- --- ------
     ~ = Partial Support


                 Figure 2: 6LoWPAN Interoperability Matrix




















Ayers & Levis           Expires January 14, 2021                [Page 7]


Internet-Draft                 Design-Low                      July 2020


      +-----------+---------+-------------+------+----------------+
      |   Stack         Code Size Measurements (kB)               |
      +-----------+---------+-------------+------+----------------+
      |           | 6Lo-All | Compression | Frag | Mesh/Bcast Hdr |
      +-----------+---------+-------------+------+----------------+
      | Contiki-NG|     6.2 |         3.4 |  1.9 |            N/A |
      | Contiki   |    11.3 |         6.0 |  3.3 |            N/A |
      | OT        |    26.6 |        20.0 |  1.3 |            4.5 |
      | Riot      |     7.5 |        >4.7 |  1.5 |            N/A |
      | Arm Mbed  |    22.1 |        18.0 |  3.1 |           1331 |
      | TinyOS    |    16.2 |        ---- | ---- |            0.6 |
      +-----------+---------+-------------+------+----------------+

   Figure 3: 6LoWPAN stack code size for 6 open source stacks.  The code
    size varies by over a factor of 4, in part due to different feature
     sets.  Compression dominated the code requirements of each stack.
    Individual components do not add up to total as some size cannot be
      clearly attributed to any subcomponent.  TinyOS's whole-program
    optimization model precluded separating out subcomponents, and only
                 includes incomplete mesh header support.

   *Why?*

   IP communication can consistently fail in low-power networks, despite
   the presence of succinct standards (RFC 6282 + RFC 4944 is 52 pages)
   designed for low-power devices.  Worse, this failure is silent: the
   receiver will simply drop the packet.  Examining the documentation
   and implementation of each stack, code size concerns motivated
   feature elision.  Mbed, Riot, and Contiki even provide compile-time
   flags to remove additional features for particularly constrained use
   cases.

   Figure 3 shows a break down of the code size of each stack.
   Compression dominates the code size of 6LoWPAN implementations, and
   in several cases 6LoWPAN's size is comparable to the whole rest of
   the IPv6 stack.  The Contiki and Contiki-NG implementations are
   significantly smaller than the others in part because they elide
   significant and complex features.  The ARM Mbed IPv6 stack uses 45kB
   of flash.  This is nearly 1/3 of the available space on a CC2650,
   just for IPv6: it does not include storage, sensors, the OS kernel,
   cryptography, higher layer protocols, signal processing, or
   applications.

   Can a careful developer implement a leaner, fully-featured stack?  To
   answer this question, we implemented our own 6LoWPAN stack.  Our
   open-source implementation is written in Rust, for Tock, a secure
   embedded OS [tock].




Ayers & Levis           Expires January 14, 2021                [Page 8]


Internet-Draft                 Design-Low                      July 2020


   Our experiences support the comments and documentation of the other
   stacks.  We surpassed the size of the Contiki-NG and Riot 6LoWPAN
   code before adding support for recursive compression of IPv6 or the
   mesh and broadcast headers.  We noted several aspects of the protocol
   required surprisingly complex code to properly handle.  For example,
   6LoWPAN requires IPv6 tunneled inside a compressed packet to compress
   interior headers as well.  This requires the decompression library to
   support recursive invocation, which increases minimum execution stack
   sizes and makes tracking buffer offsets during decompression more
   difficult.  Refusing to support tunneled IPv6 packets (e.g., Contiki)
   greatly simplified the code.  Another example: headers in the first
   6LoWPAN sub-IP fragment must be compressed, while headers in
   subsequent fragments must not be compressed.  Given that low-power
   link layers have variable length headers, correctly determining
   exactly where to fragment and what should be compressed requires
   complex interactions between layers of the stack.  Finally, 6LoWPAN
   requires support for out-of-order reception of fragments, potentially
   from different packets.  This forced our receiver to store and track
   state for a collection of received packets, preventing reliance on a
   single global receive buffer.  The exercise of implementing a 6LoWPAN
   stack from the ground up affirmed that code size concerns encourage
   feature elision.

   *Why does it matter?*

   For any 6LoWPAN implementation, there exists a border router
   implementation that can connect it to the broader Internet.  But this
   status-quo model of connectivity forces vertical integration and
   fails to meet the original design goals of 6LoWPAN, for two reasons.

   First, a 6LoWPAN gateway can not know how to safely compress packets
   for different nodes, unless it communicates only with devices
   produced by the same vendor.  As a result, for a coverage area
   containing devices produced by 5 different vendors, 5 gateways are
   required.  If not for feature mismatches, a single gateway would
   suffice.  Second, the current situation significantly limits the
   potential for range extension via mesh topologies.  Most existing
   6LoWPAN meshes rely on "route-over" mesh routing at the network
   layer, which requires that each node can at least partially
   decompress and recompress IP headers when forwarding.  Mesh-under
   routing is no better, as implementation of the mesh header is not
   universal (see Figure 2).  Poor interoperability worsens the
   usability, range, cost, and efficiency of these networks.








Ayers & Levis           Expires January 14, 2021                [Page 9]


Internet-Draft                 Design-Low                      July 2020


4.  Traditional Principles: Not Low-Power

   Over the past 45 years, the Internet community has coalesced on a
   small number of design principles.  Connectivity through
   interoperability is a key premise of the Internet.  Principles such
   as layering and encapsulation support composing protocols in new ways
   (e.g., tunneling), while the end-to-end principle [end-to-end] allows
   building a robust network out of an enormous and complex collection
   of unreliable parts.  The robustness principle asserts that
   implementations should make no assumptions on packets they receive:
   bugs, transmission errors, and even memory corruption can cause a
   device to receive arbitrarily formatted packets.  It also asserts
   that an implementation must be ready to receive any and all properly
   formatted packets.  This aspect of the principle is often attributed
   to John Postel as Postel's Law, first written down in the initial
   specification of IPv4: "In general, an implementation should be
   conservative in its sending behavior, and liberal in its receiving
   behavior."

   Protocols often have optional features ("MAY, SHOULD, and OPTIONAL"
   in RFC language).  Implicitly, due to Postel's Law, a receiver needs
   to handle either case.  This scenario creates an asymmetry, where
   sender code can have reduced complexity but receiver code must be
   large and complex.

   We need to think about low-power protocols differently.  They need
   new principles to help guide their design.  These principles need to
   embrace that there is no "one size fits all" design, while defining
   how devices choosing different design points interoperate.
   Flexibility needs to exist not only for senders, but also receivers,
   without harming interoperability.

5.  Three Principles

   This section describes three protocol design principles which prevent
   failures in low-power protocols.  These principles are absolutely
   necessary to ensure interoperable implementations in this space, and
   should be closely observed.

5.1.  Principle 1: Capability Spectrum

   A low power protocol should be deployable/installable on devices
   which are at the low end of code and RAM resources.  Rather than
   require every device pay the potential energy costs of fewer
   optimizations, a protocol should support a linear spectrum of device
   capabilities.





Ayers & Levis           Expires January 14, 2021               [Page 10]


Internet-Draft                 Design-Low                      July 2020


   This may seem familiar -- the IP [RFC0791] and TCP [RFC0793]
   specifications provide optional fields which can be used by endpoints
   at their leisure; many non-standard HTTP headers will be ignored
   unless both client and server support them; TLS ciphersuite support
   is often asymmetrical.  But this principle is different.  For those
   examples, no linear spectrum exists -- support for any particular
   capability is generally unrelated to support for any other.  Checking
   for support of any feature requires explicit enumeration of each,
   making it impossible to effectively compress such options.  A non-
   linear spectrum requires storing feature support for every neighbor
   in RAM, or re-discovering capabilities on every exchange.

   Low power protocols require simpler capability management.  A low
   power protocol should define a capability spectrum with a clear
   ordering in which especially resource constrained devices can reduce
   code size or RAM use by eliding features.  Such a spectrum makes a
   protocol usable by extremely low resource devices without forcing
   more resourceful devices to communicate inefficiently.

   This capability spectrum should be a linear scale.  For a device to
   support capability level $N$, it must also support all lower
   capability levels.  More complex configuration approaches (e.g., a
   set of independent options) might allow for a particular
   implementation to be more efficient, picking the features that give
   the most benefit for the least added complexity.  However, this sort
   of optimization makes interoperability more difficult, as two devices
   must negotiate each specific feature to use.

5.2.  Principle 2: Capability Discovery

   The second principle follows from the first: if different capability
   levels exist, there should be a mechanism for two devices to
   determine what level to communicate with.

   The capability negotiation we propose here differs from capability
   discovery mechanisms built for traditional systems, such as IP Path
   MTU discovery or the Link Layer Discovery Protocol (LLDP).  IP Path
   MTU discovery relies on continual probing until an acceptable value
   is discovered.  LLDP requires regular, detailed capability
   advertisements at a fixed interval.  The energy overhead of network
   probing or advertising is unacceptable in most low power
   environments.  Capability discovery in low power networks should
   require no more than one failure between any two neighbors, even if
   this slightly increases the overhead per error.  Proactive capability
   discovery should be built into baseline communication required for
   tasks like neighbor discovery or route maintenance.  Further,
   assumptions for traditional systems that prohibit storing per-
   endpoint state do not apply, as nodes store information about link-



Ayers & Levis           Expires January 14, 2021               [Page 11]


Internet-Draft                 Design-Low                      July 2020


   layer neighbors, _not IP endpoints_. This is needed because low-power
   networks with route over topologies frequently involve decompression
   and re-compression at each hop to enable forwarding.  Low power nodes
   have few neighbors, so storing a few bits of state for each is
   feasible and can significantly reduce the amount of radio energy
   needed for communication.  The code size cost of storing state is
   small compared to the cost of complex compression mechanisms.

   In a low power network with capability discovery, if two devices wish
   to communicate, they default to the lower of their supported
   capability levels.  E.g. a level 2 and a level 4 device should
   communicate at level 2.  One offshoot of this principle is that it
   requires implementations have symmetric capabilities for send and
   receive - no benefits can be realized from an asymmetric
   implementation.

5.3.  Principle 3: Explicit and Finite Bounds

   Protocols must specify explicit and reasonable bounds on recursive or
   variable features so implementations can bound RAM use.  This allow
   implementations to safely limit their RAM use without silent
   interoperability failures.  This also ensures that capability
   discovery is sufficient for interoperability.

   The idea of imposing bounds is, on its own, not unique to this space.
   TCP enforces a finite limit of 40 bytes for TCP options which may be
   appended to the TCP header, as does IPv4.  DHCP allows for the
   communication of maximum DHCP message sizes.  In the space of low
   power Internet protocols, however, this idea _must be pervasive._
   Notably, the original designers of a specification may not know
   exactly what these values should be.  This is not a new problem: TCP
   congestion control, for example, had to specify initial congestion
   window values.  In this space, bounds should initially be very
   conservative.  Over time, if increasing resources or knowledge
   suggests they should grow, then future devices will have the onus of
   using fewer resources to interoperate with earlier ones.  The
   capability spectrum defined in the previous two principles can be
   helpful in this regard.

6.  A Principled 6LoWPAN

   This section proposes how to apply the three principles in the
   previous section to 6LoWPAN through specific modifications to the
   protocol.  These modifications ensure that two 6LoWPAN devices can
   communicate even if they choose different code size/energy efficiency
   tradeoffs.  We refer to this modified protocol as Principled 6LoWPAN
   (P6LoWPAN).




Ayers & Levis           Expires January 14, 2021               [Page 12]


Internet-Draft                 Design-Low                      July 2020


   This application of our principles is not intended as a suggestion
   that these changes be made immediately to 6LoWPAN, as modifying an
   established protocol is a complex task very different from
   constructing new protocols.  Instead, this application is a tool for
   evaluating these principles, and an example for how they should be
   applied.

6.1.  Principle 1: Capability Spectrum

   We propose replacing the large collection of "MUST" requirements --
   the features in Figure 2 --into 6 levels of functionality.  These
   "Capability Levels" are depicted in Figure 4.

   +----------------+-----------------------------------+
   | **Capability** | **Basic Description / Added       |
   |                | Features**                        |
   +================+===================================+
   | Level 0        | Uncompressed IPv6 + ability to    |
   |                | send ICMP errors                  |
   +----------------+-----------------------------------+
   |                | -   Uncompressed IPv6             |
   |                |                                   |
   |                | -   6LoWPAN Fragmentation         |
   |                |     (Fragment Header)             |
   |                |                                   |
   |                | -   1280 Byte Packets             |
   |                |                                   |
   |                | -   Stateless decompression of    |
   |                |     source addresses              |
   +----------------+-----------------------------------+
   | Level 1        | IPv6 Compression Basics +         |
   |                | Stateless Addr Compression        |
   +----------------+-----------------------------------+
   |                | -   Support for the               |
   |                |     Dispatch\_IPHC Header Prefix  |
   |                |                                   |
   |                | -   Correctly handle elision of   |
   |                |     IPv6 length and version       |
   |                |                                   |
   |                | -   Stateless compression of all  |
   |                |     unicast addresses             |
   |                |                                   |
   |                | -   Stateless compression of      |
   |                |     multicast addresses           |
   |                |                                   |
   |                | -   Compression + 16 bit          |
   |                |     link-layer addresses          |
   |                |                                   |



Ayers & Levis           Expires January 14, 2021               [Page 13]


Internet-Draft                 Design-Low                      July 2020


   |                | -   IPv6 address                  |
   |                |     autoconfiguration             |
   +----------------+-----------------------------------+
   | Level 2        | Stateful IPv6 Address Compression |
   +----------------+-----------------------------------+
   |                | -   Stateful compression of       |
   |                |     unicast addresses             |
   |                |                                   |
   |                | -   Stateful compression of       |
   |                |     multicast addresses           |
   +----------------+-----------------------------------+
   | Level 3        | IPv6 Traffic Class and Flow Label |
   |                | Compression                       |
   +----------------+-----------------------------------+
   |                | -   Traffic Class compression     |
   |                |                                   |
   |                | -   Flow Label Compression        |
   |                |                                   |
   |                | -   Hop Limit Compression         |
   +----------------+-----------------------------------+
   | Level 4        | Next Header Compression + UDP     |
   |                | Port Compression                  |
   +----------------+-----------------------------------+
   |                | -   Handle Tunneled IPv6          |
   |                |     correctly                     |
   |                |                                   |
   |                | -   Handle the compression of the |
   |                |     UDP Next Header               |
   |                |                                   |
   |                | -   Correctly handle elision of   |
   |                |     the UDP length field          |
   |                |                                   |
   |                | -   Correctly handle the          |
   |                |     compression of UDP ports      |
   |                |                                   |
   |                | -   Handle headers past the first |
   |                |     fragment, when first fragment |
   |                |     compressed.                   |
   +----------------+-----------------------------------+
   | Level 5        | Entire Specification              |
   | (all routers)  |                                   |
   +----------------+-----------------------------------+
   |                | -   Support the broadcast header  |
   |                |     and the mesh header           |
   |                |                                   |
   |                | -   Support compression of all    |
   |                |     IPv6 Extension headers        |
   +----------------+-----------------------------------+



Ayers & Levis           Expires January 14, 2021               [Page 14]


Internet-Draft                 Design-Low                      July 2020


                       Figure 4: Capability Spectrum

   These levels prioritize features which provide the greatest energy
   savings per byte of added code size, based off our code size
   measurements and the number of bits saved by each additional
   compression mechanism.  They allow for a wide range of code size/
   efficiency tradeoffs.

   For example, addresses dominate an uncompressed IPv6 header.  Level 0
   devices only support compressed source addresses, while level 1
   devices support all stateless address compression.  In one early
   design of this spectrum, Level 0 supported only uncompressed packets.
   However, this raises a problem with ICMP error generation.  If a node
   cannot decompress the source address of a received packet, it cannot
   send ICMP errors.  ICMP errors are required for capability discovery.
   Stateful compression depends on an out-of-band signal to set up
   state, such that nodes only send statefully compressed packets to
   nodes who also support it.  Therefore decompressing stateless source
   addresses is a minimum requirement.

   The classes in this scale do not precisely reflect the current
   feature support of the implementations described in Section 3.  For
   example, Contiki supports UDP port compression (level 4) but does not
   support 802.15.4 short addresses (level 2) or stateful multicast
   compression (level 3): following this formulation, Contiki only
   provides level 1 support.  If Contiki supported 16-bit addresses, it
   would provide level 2 support.  A concrete spectrum such as the one
   above gives stack designers a structure and set of guidelines on the
   order in which to implement features.  Based on our experiences
   developing a 6LoWPAN stack, we believe that if this scale existed as
   part of the initial specification, implementations would have made an
   effort to adhere to it.

   One additional advantage of this spectrum is that it allows for some
   future additions to the P6LoWPAN specification without breaking
   interoperability between new and old implementations.  For example,
   our scale does not include support for Generic Header Compression
   [RFC7400] because none of the open-source stacks we analyzed
   implement it.  Despite this, support for this RFC could easily be
   added as a new class on this linear scale (as Class 6), and devices
   supporting it would know to not use it when communicating with lower
   class implementations.

   This spectrum requires that a node store 3 bits of state for each
   neighbor.  Given that low-power nodes often store ten or more bytes
   for each entry in their link table (link quality estimates,
   addresses, etc.), this cost is small. 6LoWPAN already assumes that




Ayers & Levis           Expires January 14, 2021               [Page 15]


Internet-Draft                 Design-Low                      July 2020


   routers are more resourceful devices, P6LoWPAN routers are required
   to be level 5.

6.2.  Principle 2: Capability Discovery

   We propose two mechanisms by which P6LoWPAN performs capability
   discovery: neighbor discovery (ND) and ICMP\@. Neighbor discovery
   [RFC4861] is analogous to ARP in IPv4: it allows IPv6 devices to
   discover the link layer addresses of neighboring addresses as well as
   local gateways.  Devices use neighbor discovery to proactively
   discover capability levels and ICMP to detect when incompatible
   features are used.  Of the two, only ICMP is required.  Neighbor
   discovery simply allows a pair of differing nodes to avoid an initial
   ICMP error, and allows for optimization of host-router communication
   during neighbor discovery.

   *ICMP:* We propose adding a new ICMPv6 message type--P6LoWPAN Class
   Unsupported--which a device sends in response to receiving 6LoWPAN
   features it does not understand.  This error encodes the device's
   capability level.  A node receiving such an error updates its link
   table entry with the capability level.  In the future, any packets
   sent to that address use at most the supported level.

   *Neighbor discovery:* We propose adding an IPv6 ND option that allows
   a device to communicate its capability class during network
   association.  This option would be included in Router Solicitations
   and Neighbor Advertisements, and would allow all devices that obtain
   link-layer addresses via ND to also know how to send packets which
   that neighbor can receive.  When a node uses ND to resolve an IP
   address to a link layer address, it learns the supported capability
   level as well as the link layer address.  This option minimizes the
   energy cost of communicating capabilities.  It is worth noting that
   RFC 7400 already employs a similar method for communicating whether
   devices implement General Header Compression: adding such an option
   is clearly viable [RFC7400].

6.3.  Principle 3: Provide Reasonable Bounds

   Section 3 discussed two missing bounds which affect 6LoWPAN
   interoperability: limits on header decompression and bounds on
   recursion when decompressing tunneled IPv6.

   For P6LoWPAN, we propose that header decompression be bounded to 51
   bytes.  This bound allows for significant RAM savings in
   implementations that decompress first fragments into the same buffer
   in which the fragment was originally held. 51 bytes is a good
   tradeoff between RAM savings and how frequently we expect such a
   bound would force packets to be sent uncompressed.  A 51 byte limit



Ayers & Levis           Expires January 14, 2021               [Page 16]


Internet-Draft                 Design-Low                      July 2020


   allows for transmission of a packet containing a maximally compressed
   IP header (+38 bytes), a maximally compressed UDP header (+6 bytes),
   and one maximally compressed IPv6 extension header (+7 bytes).  This
   allows saving hundreds of bytes of RAM, without jeopardizing
   interoperability.  Packets requiring more decompression than this are
   extremely rare, and could be sent uncompressed.  How rare?  It is
   only possible to surpass this limit if tunneled IPv6 is used or
   multiple IPv6 extension headers are present.  As of 2014, a real-
   world study of IPv6 extension header use found that 99% of packets
   with _multiple_ extension headers were dropped in the real Internet,
   as published at IETF 90.

   Second, we propose that headers for tunneled IPv6 should not be
   compressed.  The primary motivation for this feature was from the RPL
   protocol [RFC6550], as discussed in Section 3.  However, the fact
   that RPL must tunnel IPv6 in this way is generally agreed to be a
   problem and a wart in its design that should be avoided when
   possible.  This change allows implementations to avoid recursive
   functions to decompress these headers, and instead use simple if/else
   statements.

7.  Evaluation

   This section evaluates the costs of applying our principles to
   6LoWPAN.  The principles are written such that interoperability comes
   by construction, and thus interoperability of the modified protocol
   cannot be directly evaluated without observing implementations
   written by different stakeholders.  But indirect evaluation is
   possible.  Can a reasonable set of capability levels provide a good
   range of implementation complexity from which a developer can choose?
   Is the overhead of the proposed mechanisms low enough to make them
   viable?  Are the savings afforded by a linear capability spectrum
   worth the associated limitations?  We find the incremental costs of
   capability discovery mechanisms is small, adding 172-388 bytes of
   code in the worst case.  We find that the capability spectrum allows
   meaningful savings in code size and memory usage.  Finally, we find
   capability discovery has a low run-time performance cost when a
   linear spectrum is used.

7.1.  Implementations

   First, we implemented the proposed P6LoWPAN on the Contiki-NG 6LoWPAN
   stack, modifying it such that a compile-time option determines which
   features of 6LoWPAN are compiled.  We selected Contiki-NG because it
   has the smallest 6LoWPAN stack of those tested, so any overheads the
   mechanisms introduce would be most pronounced.  Our changes required
   modifying 500 lines of code relative to the head of the 4.2 release
   of Contiki-NG.  We did not add additional 6LoWPAN features which were



Ayers & Levis           Expires January 14, 2021               [Page 17]


Internet-Draft                 Design-Low                      July 2020


   absent from the original Contiki-NG 6LoWPAN stack.  Our code size
   numbers therefore represent a conservative lower bound of the total
   possible savings.  All code sizes provided in this section are
   compiled with the Texas Instruments CC2650 as the target.

   We also added ICMP and ND support for capability discovery.  The
   updated stack responds to incompatible 6LoWPAN messages with an ICMP
   error, and communicates its capability level in Router Solicitation
   messages using the 6CIO prefix originally defined in [RFC7400].  It
   stores the capability class of each node in its link table, and
   compresses IPv6 packets by the maximum amount supported by the
   destination.

   Finally, we implemented a second modified 6LoWPAN stack in Contiki-
   NG, which does not follow the recommendation of using a linear
   capability spectrum.  In this modified implementation, each node can
   select any of the 6LoWPAN features it chooses.  We refer to this
   implementation as FLEX-6LoWPAN.  For this alternative policy, we
   isolated 26 features of 6LoWPAN as single bit flags in a 32 bit
   bitfield.  Thus, FLEX-6LoWPAN stores and communicates capabilities
   using 4 byte objects.  FLEX-6LOWPAN also supports the added
   granularity required to maximally compress outgoing messages intended
   for a device supporting any specific combination of features.  We did
   not add back in any 6LoWPAN features which the Contiki-NG stack did
   not originally support.  This second implementation required
   modifying about 300 additional lines of code from the P6LoWPAN
   implementation.

7.2.  Compile-Time Costs

   Figure 5 shows the size of the original Contiki-NG 6LoWPAN stack
   compiled at each possible capability level.  Each capability level
   adds between 0.25 and 1.05 kB of code, and the spectrum enables
   implementations to cut the size of the 6LoWPAN stack by up to 45%.
   The code size cost of adding capability discovery, using the P6LoWPAN
   implementation with the linear capability spectrum, is shown in
   Figure 6.  Capability discovery adds 178-388 bytes, a fraction of the
   size which implementations can save by supporting lower capability
   levels.  The code added for communication varies across capability
   levels because the number of code paths for ICMP error generation and
   compression changes.










Ayers & Levis           Expires January 14, 2021               [Page 18]


Internet-Draft                 Design-Low                      July 2020


           Capability       Code Size (kB)       Increase (kB)
     ---------------- -------------------- -------------------
     Level 0                           3.2                  \-
     Level 1                           4.2                 1.0
     Level 2                           4.8                 0.6
     Level 3                           5.1                 0.3
     Level 4                           5.6                 0.5
     Level 5                           6.2                 0.6
     ---------------- -------------------- -------------------

      Figure 5: 6LoWPAN code size of different capabilities levels in
   Contiki-NG.  The spectrum spans a nearly 100% increase in code size.

           Capability       Base       w/Discovery       Increase
     ---------------- ---------- ----------------- --------------
     Level 0                 3.2               3.4      188 bytes
     Level 1                 4.2               4.4      260 bytes
     Level 2                 4.8               5.2      388 bytes
     Level 3                 5.1               5.4      340 bytes
     Level 4                 5.6               5.9      296 bytes
     Level 5                 6.2               6.3      172 bytes
     ---------------- ---------- ----------------- --------------

   Figure 6: The cost of implementing capability discovery in Contiki-NG
     is on average less than 5% of the total 6LoWPAN size; the maximum
     size reduction from choosing a lower capability level is 10x the
                              discovery cost.

   Figure 7 presents the compile-time costs of using an arbitrary
   bitfield instead of a linear capability spectrum by comparing our
   P6LoWPAN implementation with our FLEX-6LoPWAN implementation.  The
   bitfield approach requires 32 bits per neighbor to store
   capabilities, instead of 3 bits.  More importantly, it complicates
   determining the allowable compression between two nodes, as
   demonstrated by the code size increase.  The important takeaway here
   is that opting for a less restrictive set of feature combinations
   mitigates much of the savings provided by implementing capabilities.
   For example, a FLEX-6LoWPAN device with the equivalent of level 4
   capabilities requires more code space than a level 5 P6LoWPAN device
   - the linear capability spectrum makes a difference.  The code size
   addition for FLEX-6LoWPAN is a conservative lower bound, as we did
   not need to add checks for handling 6LoWPAN compression features that
   Contiki-NG does not support.








Ayers & Levis           Expires January 14, 2021               [Page 19]


Internet-Draft                 Design-Low                      July 2020


7.3.  Run-time Performance

   *ND Cost* 6LoWPAN ND communication [RFC6775] is host-initiated and
   flows through routers (which must be level 5), and nodes store
   neighbor capability levels alongside link layer addresses: thus there
   is no possibility of communication failures due to capability
   mismatches.  Therefore the cost of capability discovery in networks
   that use IPv6 ND is exclusively that certain ND messages become
   longer (router solicitations and neighbor advertisements are sent
   with an added capability option).  To put this added cost in
   perspective, The equation below shows the total link-layer payload
   bytes sent/received for ND by a node in its initial wake-up period.
   This equation assumes the configuration described in RFC 6775 as the
   "Basic Router Solicitation Exchange" - route over topology, 1 6LoWPAN
   context, 1 on-link prefix, and the host requires address
   registration.  All variables not affected by the use of capability
   discovery are assigned the minimum possible value for the scenario
   discussed, so that the overhead of capability discovery represents a
   worst case.

   If C = total link layer payload sent/recieved for ND, and N =
   endpoints requiring address resolution:

   C = Router Soliciation {RS} + Min. IP Hdr {2} + Router Advertisement
   {104} + Min. IP Hdr {2} + (Neighbour Solicitation {24} + Min. IP Hdr
   {2})*N + (Neighbour Advertisement {24} + Min. IP Hdr {2})*N + Address
   Registration Options in first NS {24} + Address Registration Options
   in first NA {16}.

   Figure 8 shows the values of RS and NA for each 6LoWPAN
   implementation, and the resulting total ND cost.  Notably, use of an
   arbitrary bitfield increases the size of the capability option by 4
   bytes, making use of existing ND options like the 6CIO option
   impossible.  In both cases the additional bytes added for capability
   discovery are small compared to the total cost of ND( <= 8% linear
   spectrum / <= 16% arbitrary bitfield).

   *ICMP Cost* In networks that do not use IPv6 ND the cost of
   capability discovery is the energy/latency required for one ICMP
   packet per failure between any two nodes.  For P6LoWPAN capability
   based failures can only happen in one direction, so the size of this
   link-layer payload is:

   C_icmp = Compressed IP Header Size + 4

   For FLEX-6LoWPAN C_icmp = 48, because the recipient does not know the
   capabilities of the sender, and thus must send an uncompressed packet
   to ensure successful reception of its own capabilities.  This example



Ayers & Levis           Expires January 14, 2021               [Page 20]


Internet-Draft                 Design-Low                      July 2020


   reveals why use of an arbitrary bitfield is so undesirable - the
   ability to compress headers in ICMP errors can reduce overhead by a
   factor of 4 or more (in the common case of 8 byte compressed
   headers).

     --                        Linear Spectrum       Arbitrary Bitfield
     ------------------- --------------------- ------------------------
     6LoWPAN Code Size                  5.9 kB                   6.5 kB
     RAM per neighbor                 19 Bytes                 22 Bytes
     ------------------- --------------------- ------------------------


     Figure 7: Resource requirements for a 6LoWPAN stack in Contiki-NG
   using a linear capability spectrum vs. using an arbitrary capability
                                 bitfield.

    --                          RS              NA     C (Total ND Cost)
    -------------- --------------- --------------- ---------------------
    6LoWPAN                     20              24           168 + 52\*N
    P6LoWPAN                    24              28             172+56\*N
    FLEX-6LoWPAN                28              32             176+60\*N
    -------------- --------------- --------------- ---------------------


              Figure 8: Total ND cost for each implementation

8.  Discussion and Conclusions

   A new generation of low-power devices face a connectivity dilemma:
   Internet protocols are not designed for energy efficiency, but
   compression and other energy saving adaptations takes up precious
   code space.  Device deployments specialized for single-vendor local
   networks make trade-offs specific to their application requirements.
   As a result, IP communication between IP enabled devices fails.  This
   problem is not specific to 6LoWPAN -- Iova et. al. recently noted
   similar issues in the RPL protocol: "RPL has too large of a footprint
   for resource-constrained devices, and requires all devices in a
   network to run the same mode of operation, limiting heterogeneity"
   [iova].

   Part of the challenge is that some traditional protocol design
   principles do not apply well to the low-power setting.  We present
   three design principles for low-power protocols that attempt to
   remedy this.  These principles explicitly acknowledge the unique code
   space/energy tradeoffs of low-power devices.

   Looking forward, considering this tension is critical for protocol
   designers in this ecosystem of diverse hardware capabilities and



Ayers & Levis           Expires January 14, 2021               [Page 21]


Internet-Draft                 Design-Low                      July 2020


   application tradeoffs. 6LoWPAN is not the only low power Internet
   protocol -- the low power space uses its own routing protocols,
   address discovery protocols, and application layer protocols
   [RFC6550] [RFC7252].  Additional protocols will follow as the space
   matures.  Many of these protocols will be initially developed outside
   the IETF -- Jonathan Hui was a graduate student when he presented the
   first complete IPv6-based network architecture for sensor nets [hui],
   as was Adam Dunkels when he created Contiki.  We present a roadmap
   for how these principles can reframe the discussion of how to connect
   the next hundred billion devices to the Internet.

9.  Definitions

9.1.  Terminology

   In this document, the key words "MUST", "MUST NOT", "REQUIRED",
   "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY",
   and "OPTIONAL" are to be interpreted as described in BCP 14, RFC 2119
   [RFC2119].

10.  Security Considerations

   This informational document does have some implications for security
   if followed.

   First, capability advertisements of the type recommended in this
   document are liable to leak some information regarding the type of
   device sending those advertisements.  In any situation for which this
   information is privileged, such advertisements must be suppressed.

   Second, implementations should be careful not to take for granted
   that the suggestions in this document will be implemented by all
   other transmitting devices.  Accordingly, though this document
   recommends reasonable bounds, receivers still must be careful to
   prevent buffer overflows in the event these bounds are not followed.

11.  IANA Considerations

   This document has no actions for IANA.

12.  References

12.1.  Normative References

   [RFC4861]  Narten, T., Nordmark, E., Simpson, W., and H. Soliman,
              "Neighbor Discovery for IP version 6 (IPv6)", RFC 4861,
              DOI 10.17487/RFC4861, September 2007,
              <https://www.rfc-editor.org/info/rfc4861>.



Ayers & Levis           Expires January 14, 2021               [Page 22]


Internet-Draft                 Design-Low                      July 2020


   [RFC4944]  Montenegro, G., Kushalnagar, N., Hui, J., and D. Culler,
              "Transmission of IPv6 Packets over IEEE 802.15.4
              Networks", RFC 4944, DOI 10.17487/RFC4944, September 2007,
              <https://www.rfc-editor.org/info/rfc4944>.

   [RFC6282]  Hui, J., Ed. and P. Thubert, "Compression Format for IPv6
              Datagrams over IEEE 802.15.4-Based Networks", RFC 6282,
              DOI 10.17487/RFC6282, September 2011,
              <https://www.rfc-editor.org/info/rfc6282>.

   [RFC6775]  Shelby, Z., Ed., Chakrabarti, S., Nordmark, E., and C.
              Bormann, "Neighbor Discovery Optimization for IPv6 over
              Low-Power Wireless Personal Area Networks (6LoWPANs)",
              RFC 6775, DOI 10.17487/RFC6775, November 2012,
              <https://www.rfc-editor.org/info/rfc6775>.

12.2.  Informative References

   [contiki]  Dunkels, A., "Contiki OS", n.d.,
              <http://www.contiki-os.org/>.

   [contiki-ng]
              Duquennoy, S., "Contiki-NG", n.d.,
              <https://github.com/contiki-ng/contiki-ng>.

   [end-to-end]
              Clark, D., "End-to-end Arguments in System Design", n.d..

   [hui]      Culler, D., "IP is Dead, Long Live IP for Wireless Sensor
              Networks", n.d..

   [iova]     Kiraly, C., "RPL The Routing Standard for the Internet of
              Things...Or Is It?", n.d..

   [lite-os]  Huawei, ., "LiteOS", n.d., <https://liteos.github.io/>.

   [mbedos]   ARM, ., "ARM MbedOS", n.d., <https://os.mbed.com/>.

   [probe-it-plugtest]
              Huang, X., "Tehcnical Interoperability 6LoWPAN-CoAP Report
              from Interop Event", n.d..

   [RFC0791]  Postel, J., "Internet Protocol", STD 5, RFC 791,
              DOI 10.17487/RFC0791, September 1981,
              <https://www.rfc-editor.org/info/rfc791>.






Ayers & Levis           Expires January 14, 2021               [Page 23]


Internet-Draft                 Design-Low                      July 2020


   [RFC0793]  Postel, J., "Transmission Control Protocol", STD 7,
              RFC 793, DOI 10.17487/RFC0793, September 1981,
              <https://www.rfc-editor.org/info/rfc793>.

   [RFC1122]  Braden, R., Ed., "Requirements for Internet Hosts -
              Communication Layers", STD 3, RFC 1122,
              DOI 10.17487/RFC1122, October 1989,
              <https://www.rfc-editor.org/info/rfc1122>.

   [RFC2119]  Bradner, S., "Key words for use in RFCs to Indicate
              Requirement Levels", BCP 14, RFC 2119,
              DOI 10.17487/RFC2119, March 1997,
              <https://www.rfc-editor.org/info/rfc2119>.

   [RFC6550]  Winter, T., Ed., Thubert, P., Ed., Brandt, A., Hui, J.,
              Kelsey, R., Levis, P., Pister, K., Struik, R., Vasseur,
              JP., and R. Alexander, "RPL: IPv6 Routing Protocol for
              Low-Power and Lossy Networks", RFC 6550,
              DOI 10.17487/RFC6550, March 2012,
              <https://www.rfc-editor.org/info/rfc6550>.

   [RFC7252]  Shelby, Z., Hartke, K., and C. Bormann, "The Constrained
              Application Protocol (CoAP)", RFC 7252,
              DOI 10.17487/RFC7252, June 2014,
              <https://www.rfc-editor.org/info/rfc7252>.

   [RFC7400]  Bormann, C., "6LoWPAN-GHC: Generic Header Compression for
              IPv6 over Low-Power Wireless Personal Area Networks
              (6LoWPANs)", RFC 7400, DOI 10.17487/RFC7400, November
              2014, <https://www.rfc-editor.org/info/rfc7400>.

   [RFC7668]  Nieminen, J., Savolainen, T., Isomaki, M., Patil, B.,
              Shelby, Z., and C. Gomez, "IPv6 over BLUETOOTH(R) Low
              Energy", RFC 7668, DOI 10.17487/RFC7668, October 2015,
              <https://www.rfc-editor.org/info/rfc7668>.

   [riot]     Berlin, F., "riot OS", n.d., <https://www.riot-os.org/>.

   [RPL-interop]
              Ko, J., "Contikierpl and tinyrpl - Happy Together", n.d..

   [tinyos]   Levis, P., "TinyOS An Operating System for Sensor
              Networks", n.d., <https://link.springer.com/
              chapter/10.1007/3-540-27139-2_7>.

   [tock]     Levy, A., "Multiprogramming a 64kB Computer Safely and
              Efficiently", n.d..




Ayers & Levis           Expires January 14, 2021               [Page 24]


Internet-Draft                 Design-Low                      July 2020


   [zephyr]   Foundation, T., "zephyrOS", n.d.,
              <https://www.zephyrproject.org/>.

Authors' Addresses

   Hudson Ayers
   Stanford University
   350 Serra Mall
   Stanford, CA
   United States

   Email: hayers@stanford.edu


   Philip Levis
   Stanford University
   350 Serra Mall
   Stanford, CA
   United States

   Email: pal@cs.stanford.edu






























Ayers & Levis           Expires January 14, 2021               [Page 25]


Html markup produced by rfcmarkup 1.129d, available from https://tools.ietf.org/tools/rfcmarkup/