Guidelines for HTTP-CoAP Mapping Implementations
draft-ietf-core-http-mapping-04

Abstract

This draft provides reference information for HTTP-CoAP protocol translation proxy implementation, focusing on the reverse proxy case. It details deployment options, defines a template for URI mapping, and provides a set of guidelines and considerations related to protocol translation.

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 http://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 5, 2015.

Copyright Notice

Copyright (c) 2014 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 (http://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. Terminology
• 3. Cross-Protocol Usage of URIs
• 4. Use Cases
• 5. URI Mapping
• 5.1. URI Terminology
• 5.2. Default Mapping
• 5.2.1. Optional scheme
• 5.2.2. Encoding Caveats
• 5.3. URI Mapping Template
• 5.3.1. Simple Form
• 5.3.2. Enhanced Form
• 5.4. Discovery
• 5.4.1. Examples
• 6. HTTP-CoAP Reverse Proxy
• 6.1. Proxy Placement
• 6.2. Response Code Translations
• 6.3. Media Type mapping
• 6.3.1. Loose Media Type Mapping
• 6.3.2. Internet Media Type to Content Format Mapping Algorithm
• 6.3.3. Content Transcoding
• 6.4. Caching and Congestion Control
• 6.5. Cache Refresh via Observe
• 6.6. Use of CoAP Blockwise Transfer
• 6.7. Security Translation
• 6.8. Other guidelines
• 7. IANA Considerations
• 8. Security Considerations
• 8.1. Traffic overflow
• 8.2. Handling Secured Exchanges
• 8.3. URI Mapping
• 9. Acknowledgements
• 10. References
• 10.1. Normative References
• 10.2. Informative References
• Appendix A. Change Log
• Authors' Addresses

1. Introduction

CoAP [RFC7252] has been designed with the twofold aim to be an application protocol specialized for constrained environments and to be easily used in REST architectures such as the Web. The latter goal has led to define CoAP to easily interoperate with HTTP [RFC7230] through an intermediary proxy which performs cross-protocol conversion.

Section 10 of [RFC7252] describes the fundamentals of the CoAP-to-HTTP and the HTTP-to-CoAP cross-protocol mapping process. However, implementing such a cross-protocol proxy can be complex, and many details regarding its internal procedures and design choices require further elaboration. Therefore a first goal of this document is to provide more detailed information to proxy designers and implementers, to help implement proxies that correctly inter-work with other CoAP and HTTP client/server implementations that adhere to the HTTP and CoAP specifications.

The second goal of this informational document is to define a consistent set of guidelines that a HTTP-to-CoAP proxy implementation MAY adhere to. The main reason of adhering to such guidelines is to reduce variation between proxy implementations, thereby increasing interoperability. (As an example use case, a proxy conforming to these guidelines made by vendor A can be easily replaced by a proxy from vendor B that also conforms to the guidelines.)

This draft is organized as follows:

• Section 2 describes terminology to identify proxy types, mapping approaches and proxy deployments;
• Section 3 discusses how URIs refer to resources independent of access protocols;
• Section 4 briefly lists use cases in which HTTP clients need to contact CoAP servers;
• Section 5 introduces a default HTTP-to-CoAP URI mapping syntax;
• Section 6 describes the properties of the HTTP-to-CoAP reverse proxy;
• Section 8 discusses possible security impact related to HTTP-CoAP protocol mapping.

2. Terminology

This document assumes readers are familiar with the terms Reverse Proxy as defined in [RFC7230] and Interception Proxy as defined in [RFC3040]. In addition, the following terms are defined:

HC Proxy: is a proxy performing a cross-protocol mapping, in the context of this document a HTTP-CoAP (HC) mapping. A Cross-Protocol Proxy can behave as a Forward Proxy, Reverse Proxy or Interception Proxy. Note: In this document we focus on the Reverse Proxy mode of the Cross-Protocol Proxy.

Forward Proxy: a message forwarding agent that is selected by the client, usually via local configuration rules, to receive requests for some type(s) of absolute URI and to attempt to satisfy those requests via translation to the protocol indicated by the absolute URI. The user decides (is willing to) use the proxy as the forwarding/dereferencing agent for a predefined subset of the URI space.

Reverse Proxy: a receiving agent that acts as a layer above some other server(s) and translates the received requests to the underlying server's protocol. It behaves as an origin (HTTP) server on its connection towards the (HTTP) client and as a (CoAP) client on its connection towards the (CoAP) origin server. The (HTTP) client uses the "origin-form" [RFC7230] as a request-target URI.

Reverse and Forward proxies are technically very similar, with main differences being that the former appears to a client as an origin server while the latter does not, and that clients may be unaware they are communicating with a proxy.

Placement terms: a server-side (SS) proxy is placed in the same network domain as the server; conversely a client-side (CS) proxy is in the same network domain as the client. In any other case than SS or CS, the proxy is said to be External (E).

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in [RFC2119].

3. Cross-Protocol Usage of URIs

A Uniform Resource Identifier (URI) provides a simple and extensible method for identifying a resource. It enables uniform identification of resources via a separately defined extensible set of naming schemes [RFC3986].

URIs are formed of at least three components: scheme, authority and path. The scheme often corresponds to the protocol used to access the resource. However, as noted in Section 1.2.2 of [RFC3986] the scheme does not imply that a particular protocol is used to access the resource. So, we can define the same resource to be accessible by different protocols i.e. the resource can have cross-protocol URIs referring to it.

HTTP clients only support 'http' and 'https' schemes and cannot directly access CoAP servers (which support 'coap' and/or 'coaps'). In this situation, communication is enabled by a HC Proxy, as shown in Figure 1, supporting URI mapping features. Such features are discussed in Section 5.

4. Use Cases

To illustrate in which situations HTTP to CoAP request mapping may be used, three use cases are briefly described.

1. Smartphone and home sensor: Any smartphone can access directly a home sensor using an authenticated 'https' request, if its home router contains a HTTP-CoAP proxy. For this use-case an HTML5 application can be built providing a friendlier UI to the user.

2. Legacy building control application without CoAP: A building control application that uses HTTP but not CoAP, can check the status of sensors and/or actuators via a HTTP-CoAP proxy.

3. Making sensor data available to 3rd parties: For demonstration or public interest purposes, a HTTP-CoAP proxy may be configured to expose the contents of a sensor to the world via the web (HTTP and/or HTTPS). The sensor can only handle secure 'coaps' requests, therefore the proxy is configured to translate any request to a 'coaps' secured request. The proxy is furthermore configured to only pass through GET requests. In this way even unattended HTTP clients, such as web crawlers, may index sensor data as regular web pages.

5. URI Mapping

Though, in principle, a CoAP URI could be directly used by a HTTP user agent to de-reference a CoAP resource through a HC Proxy, the reality is that all major web browsers and command line tools do not allow making HTTP requests using URIs with a scheme different from "http" or "https".

Thus, there is a need for web applications to "pack" a CoAP URI into a HTTP URI so that it can be (non-destructively) transported from the user agent to the HC Proxy. The HC Proxy can then "unpack" the CoAP URI and finally de-reference it via a CoAP request to the target Server.

URI Mapping is the process through which the URI of a CoAP resource is transformed in to an HTTP URI so that:

• the requesting HTTP user agent can handle it;
• the receiving HC Proxy can extract the intended CoAP URI unambiguously.

To this end, the remainder of this section will identify:

• the default mechanism to map a CoAP URI into a HTTP URI;
• the URI template format to express a class of CoAP-HTTP URI mapping functions;
• the discovery mechanism based on [RFC6690] through which clients of a HC Proxy can dynamically discover information about the supported URI Mapping Template(s), as well as the base URI where the HC Proxy function is anchored.

5.1. URI Terminology

In the remainder of this section, the following terms will be used with a distinctive meaning:

Target CoAP URI:

URI which refers to the (final) CoAP resource that has to be de-referenced. It conforms to syntax defined in section 6 of [RFC7252]. Specifically, it has a scheme of "coap" or "coaps".

Hosting HTTP URI:

URI that conforms to syntax in section 2.7 of [RFC7230]. Its authority component refers to an HC Proxy, whereas path (and query) component(s) embed the information used by an HC Proxy to extract the Target CoAP URI.

5.2. Default Mapping

The default is for the Target CoAP URI to be appended as-is to a base URI provided by the HC Proxy to form the Hosting HTTP URI.

For example: given a base URI http://p.example.com/hc and a Target CoAP URI coap://s.example.com/light, the resulting Hosting HTTP URI would be http://p.example.com/hc/coap://s.example.com/light.

Provided a correct Target CoAP URI, the Hosting HTTP URI resulting from the default mapping is always syntactically correct. Furthermore, the Target CoAP URI can always be extracted in an unambiguous way from the Hosting HTTP URI. Also worth noting that, using the default mapping, a query component in the target CoAP resource URI is naturally encoded into the query component of the Hosting URI, e.g.: coap://s.example.com/light?dim=5 becomes http://p.example.com/hc/coap://s.example.com/light?dim=5.

There is no default for the base URI. Therefore it is either known in advance, e.g. as a configuration preset, or dynamically discovered using the mechanism described in Section 5.4.

The default URI mapping function is RECOMMENDED to be implemented and activated by default in a HC Proxy, unless there are valid reasons, e.g. application specific, to use a different mapping function.

5.2.1. Optional scheme

When found in a Hosting HTTP URI, the scheme (i.e. "coap" or "coaps"), the scheme component delimiter (":"), and the double slash ("//") preceding the authority MAY be omitted. In such case, a local default - not defined by this document - applies.

So, http://p.example.com/hc/s.coap.example.com/foo could either represent the target coap://s.coap.example.com/foo or coaps://s.coap.example.com/foo depending on application specific presets.

5.2.2. Encoding Caveats

When the authority of the Target CoAP URI is given as an IPv6address, then the surrounding square brackets MUST be percent-encoded in the Hosting HTTP URI, in order to comply with the syntax defined in Section 3.3. of [RFC3986] for a URI path segment. E.g.: coap://[2001:db8::1]/light?on becomes http://p.example.com/hc/coap://%5B2001:db8::1%5D/light?on.

Everything else can be safely copied verbatim from the Target CoAP URI to the Hosting HTTP URI.

5.3. URI Mapping Template

This section defines a format for the URI template used by a HC Proxy to inform its clients about the expected syntax for the Hosting HTTP URI.

When instantiated, an URI Mapping Template is always concatenated to a base URI provided by the HC Proxy via discovery (see Section 5.4), or by other means.

A simple form (Section 5.3.1) and an enhanced form (Section 5.3.2) are provided to fit different users' requirements.

Both forms are expressed as level 2 URI template's to take care of the expansion of values that are allowed to include reserved URI characters.

5.3.1. Simple Form

The simple form MUST be used for mappings where the Target CoAP URI is going to be copied verbatim at some fixed position into the Hosting HTTP URI.

    cu = coap-URI   ; from [RFC7252], Section 6.1
    su = coaps-URI  ; from [RFC7252], Section 6.2
    tu = cu / su
          

The following template variables MUST be used in mutual exclusion in a template definition: Section 5.2.1 apply.

5.3.1.1. Examples

All the following examples (given as a specific URI mapping template, a Target CoAP URI, and the produced Hosting HTTP URI) use http://p.example.com/hc as the base URI.

    ?coap_target_uri={+cu}

    coap://s.example.com/light

    http://p.example.com/hc?coap_target_uri=coap://s.example.com/light
                

    ?coaps_target_uri={+su}

    coaps://s.example.com/light

    http://p.example.com/hc?coaps_target_uri=coaps://s.example.com/light
                  

    ?target_uri={+tu}

    coap://s.example.com/light 

    http://p.example.com/hc?target_uri=coap://s.example.com/light

    or

    coaps://s.example.com/light 

    http://p.example.com/hc?target_uri=coaps://s.example.com/light
                  

    /{+tu}

    coap://s.example.com/light

    http://p.example.com/hc/coap://s.example.com/light 

    or

    coaps://s.example.com/light

    http://p.example.com/hc/coaps://s.example.com/light
                  

1. "coap" URI is a query argument of the Hosting HTTP URI:
2. "coaps" URI is a query argument of the Hosting HTTP URI:
3. Target CoAP URI as a query argument of the Hosting HTTP URI:
4. Target CoAP URI in the path component of the Hosting HTTP URI (i.e. the default URI Mapping template):

5.3.2. Enhanced Form

The enhanced form can be used to express more sophisticated mappings, i.e. those that do not fit into the simple form.

    s  = "coap" / "coaps" ; from [RFC7252], Sections 6.1 and 6.2
    hp = host [":" port]  ; from [RFC3986] Sections 3.2.2 and 3.2.3
    p  = path-abempty     ; from [RFC3986] Section 3.3.
    q  = [ "?" query ]    ; from [RFC3986] Section 3.4 
          

There MUST be at most one instance of each of the following template variables in a template definition:

5.3.2.1. Examples

All the following examples (given as a specific URI mapping template, a Target CoAP URI, and the produced Hosting HTTP URI) use http://p.example.com/hc as the base URI.

    {+s}{+hp}{+p}{+q}

    coap://s.example.com/light 

    http://p.example.com/hc/coap/s.example.com/light

    or

    coap://s.example.com/light?on  

    http://p.example.com/hc/coap/s.example.com/light?on
                

    ?s={+s}&hp={+hp}&p={+p}&q={+q}

    coap://s.example.com/light 

    http://p.example.com/hc?s=coap&hp=s.example.com&p=/light&q 

    or

    coaps://s.example.com/light?on 

    http://p.example.com/hc?s=coaps&hp=s.example.com&p=/light&q=on
                  

1. Target CoAP URI components in path segments, and optional query in query component:
2. Target CoAP URI components split in individual query arguments:

5.4. Discovery

In order to accommodate site specific needs while allowing third parties to discover the proxy function, the HC Proxy SHOULD publish information related to the location and syntax of the HC Proxy function using the CoRE Link Format [RFC6690] interface.

To this aim a new Resource Type, "core.hc", is associated with a base URI, and can be used as the value for the "rt" attribute in a query to the /.well-known/core in order to locate the base URI where the HC Proxy function is anchored.

Along with it, the new target attribute "hct" MAY be returned in a "core.hc" link to provide the associated URI Mapping Template. The default template given in Section 5.2, i.e. {+tu}, MUST be assumed if no "hct" attribute is found in the returned link. If an "htc" attribute is present in the returned link, then a compliant client MUST use it to create the Hosting HTTP URI.

Discovery SHOULD be available on both the HTTP and the CoAP side of the HC proxy, with one important difference: on the CoAP side the link associated to the "core.hc" resource needs an explicit anchor referring to the HTTP origin, while on the HTTP interface the link context is already the HTTP origin carried in the request's Host header, and doesn't have to be made explicit.

5.4.1. Examples

    Req:  GET coap://[ff02::1]/.well-known/core?rt=core.hc

    Res:  2.05 Content
          </hc>;anchor="http://p.example.com";rt="core.hc"
                

    Req:  GET coap://[ff02::1]/.well-known/core?rt=core.hc

    Res:  2.05 Content
          </hc>;anchor="http://p.example.com";rt="core.hc";hct="?uri={+tu}"
                

    Req:  GET /.well-known/core?rt=core.hc HTTP/1.1
          Host: p.example.com

    Res:  HTTP/1.1 200 OK
          Content-Type: application/link-format
          Content-Length: 18

          </hc>;rt="core.hc"
                

    Req:  GET /.well-known/core?rt=core.hc HTTP/1.1
          Host: p.example.com

    Res:  HTTP/1.1 200 OK
          Content-Type: application/link-format+json
          Content-Length: 31

          [{"href":"/hc","rt":"core.hc"}]
                

    Req:  GET /.well-known/core?rt=core.hc HTTP/1.1
          Host: p.example.com

    Res:  HTTP/1.1 200 OK
          Link: </hc>;rt="core.hc"
                

    Req:  GET /.well-known/core?rt=core.hc
          Host: p.example.com

    Res:  HTTP/1.1 200 OK
          Content-Type: application/link-format+json
          Content-Length: 111

          [
            {"href":"/hc/plaintext","rt":"core.hc","htc":"{+cu}"},
            {"href":"/hc/secure","rt":"core.hc","htc":"{+su}"}
          ]
                

• The first example exercises the CoAP interface, and assumes that the default template, {+tu}, is used:
• The second example - also on the CoAP side of the HC Proxy - uses a custom template, i.e. one where the CoAP URI is carried inside the query component, thus the returned link carries the URI template to be used in an explicit "hct" attribute:

On the HTTP side link information can be serialised in more than one way:

• using the 'application/link-format' content type:
• using the 'application/link-format+json' content type:
• using the Link header:
• An HC Proxy may expose two different base URIs to differentiate between Target CoAP resources in the "coap" and "coaps" scheme:

6. HTTP-CoAP Reverse Proxy

A HTTP-CoAP Reverse Cross-Protocol Proxy is accessed by web clients only supporting HTTP, and handles their requests by mapping these to CoAP requests, which are forwarded to CoAP servers; and mapping back the received CoAP responses to HTTP. This mechanism is transparent to the client, which may assume that it is communicating with the intended target HTTP server. In other words, the client accesses the proxy as an origin server using the "origin-form" [RFC7230] as a Request Target.

Normative requirements on the translation of HTTP requests to CoAP and of the CoAP responses back to HTTP responses are defined in Section 10.2 of [RFC7252]. However, that section only considers the case of a HTTP-CoAP Forward Cross-Protocol Proxy in which a client explicitly indicates it targets a request to a CoAP server, and does not cover all aspects of proxy implementation in detail. The present section provides guidelines and more details for the implementation of a Reverse Cross-Protocol Proxy, which MAY be followed in addition to the normative requirements.

Translation of unicast HTTP requests into multicast CoAP requests is currently out of scope since in a reverse proxy scenario a HTTP client typically expects to receive a single response, not multiple. However a HC Proxy MAY include custom application-specific functions to generate a multicast CoAP request based on a unicast HTTP request and aggregate multiple CoAP responses into a single HTTP response.

Note that the guidelines in this section also apply to an HTTP-CoAP Intercepting Cross-Protocol Proxy.

6.1. Proxy Placement

Typically, a Cross-Protocol Proxy is located at the edge of the constrained network. See Figure 1. The arguments supporting server-side (SS) placement are the following:

Caching:

Efficient caching requires that all request traffic to a CoAP server is handled by the same proxy which receives HTTP requests from multiple source locations. This maximally reduces the load on (constrained) CoAP servers.

Multicast:

To support CoAPs use of local-multicast functionality available in a constrained network, the Cross-Protocol Proxy requires a network interface directly attached to the constrained network.

TCP/UDP:

Translation between HTTP and CoAP requires also TCP/UDP translation; TCP may be the preferred way for communicating with the constrained network due to its reliability or due to intermediate gateways configured to block UDP traffic.

Arguments against SS placement, in favor of client-side (CS), are:

Scalability:

A solution where a single SS proxy has to manage numerous open TCP/IP connections to a large number of HTTP clients is not scalable. (Unless multiple SS proxies are employed with a load-balancing mechanism, which adds complexity.)

                            +------+                                  
                            |      |                                  
                            | DNS  |                                 
                            |      |                                 
                            +------+            Constrained Network                 
                                                --------------------
                                               /                    \
                                              /  /-----\     /-----\ \
                                             /     CoAP       CoAP    \
                                            /    server      server    \
                                           ||    \-----/     \-----/   ||
    +------+       HTTP Request      +----------+                      ||
    |HTTP  |------------------------>| HTTP-CoAP|  Req   /-----\       ||
    |Client|                         |  Cross-  |------->| CoAP        ||
    |      |<------------------------|  Proxy   |<-------|server       ||
    +------+       HTTP Response     +----------+  Resp  \-----/       ||
                                           ||                          ||
                                           ||   /-----\                ||
                                           ||    CoAP                  ||
                                            \    server                /
                                             \  \-----/               /
                                              \         /-----\      /
                                               \         CoAP       /
                                                \        server    /
                                                 \      \-----/   /
                                                  ----------------
    

        INPUT:  C-T and C-E
        OUTPUT: C-F or Fail

        1.  if no C-T: return Fail
        2.  C-F = MAP[C-T, C-E]
        3.  if C-F is not None: return C-F
        4.  if C-E is not "identity":
        5.    if C-E is supported (e.g. gzip):
        6.      decode the representation accordingly
        7.      set C-E to "identity"
        8.    else:
        9.      return Fail
        10. repeat steps 2. and 3.
        11. if C-T allows a non-lossy transformation into \
        12.    one of the supported C-F:
        13.      transcode the representation accordingly
        14.      return C-F
        15. if GMAP is defined:
        16.   C-F = GMAP[C-T]
        17.   if C-F is not None: return C-F
        18. return Fail