Merge pull request #6117 from kb2ma/gcoap/sock

gcoap: rebase networking on sock

Author: miri64

Makefile.dep

@@ -96,10 +96,6 @@ ifneq (,$(filter gnrc_zep,$(USEMODULE)))
   USEMODULE += xtimer
 endif
 
-ifneq (,$(filter gcoap,$(USEMODULE)))
-  USEMODULE += gnrc_udp
-endif
-
 ifneq (,$(filter gnrc_tftp,$(USEMODULE)))
   USEMODULE += gnrc_udp
   USEMODULE += xtimer

examples/gcoap/Makefile

@@ -1,4 +1,4 @@
-# Default Makefile, for host native networking
+# Default Makefile, for host native GNRC-based networking
 
 # name of your application
 APPLICATION = gcoap
@@ -29,15 +29,14 @@ BOARD_BLACKLIST := nrf52dk
 USEPKG += nanocoap
 # Required by nanocoap, but only due to issue #5959.
 USEMODULE += posix
-# Required by nanocoap to compile nanocoap_sock.
-USEMODULE += gnrc_sock_udp
 
 # Include packages that pull up and auto-init the link layer.
 # NOTE: 6LoWPAN will be included if IEEE802.15.4 devices are present
 USEMODULE += gnrc_netdev_default
 USEMODULE += auto_init_gnrc_netif
 # Specify the mandatory networking modules
 USEMODULE += gnrc_ipv6_default
+USEMODULE += gnrc_sock_udp
 USEMODULE += gcoap
 # Additional networking modules that can be dropped if not needed
 USEMODULE += gnrc_icmpv6_echo

examples/gcoap/Makefile.slip

@@ -1,4 +1,4 @@
-# Border router Makefile for SLIP based networking
+# Border router Makefile for GNRC and SLIP based networking
 # Assumes use of SAMR21 board
 
 # name of your application
@@ -45,14 +45,13 @@ CFLAGS += -DSLIP_BAUDRATE=$(SLIP_BAUDRATE)
 USEPKG += nanocoap
 # Required by nanocoap, but only due to issue #5959.
 USEMODULE += posix
-# Required by nanocoap to compile nanocoap_sock.
-USEMODULE += gnrc_sock_udp
 
 # Include packages that pull up and auto-init the link layer.
 # NOTE: 6LoWPAN will be included if IEEE802.15.4 devices are present
 USEMODULE += gnrc_netdev_default
 USEMODULE += auto_init_gnrc_netif
 # Specify the mandatory networking modules
+USEMODULE += gnrc_sock_udp
 USEMODULE += gcoap
 # Add a routing protocol
 USEMODULE += gnrc_rpl

examples/gcoap/README.md

@@ -1,6 +1,6 @@
 # gcoap Example
 
-This application provides command line access to gcoap, a GNRC implementation of CoAP. See the [CoAP spec][1] for background, and the Modules>Networking>GNRC>CoAP topic in the source documentation for the structure of the implementation.
+This application provides command line access to gcoap, a high-level API for CoAP messaging. See the [CoAP spec][1] for background, and the Modules>Networking>CoAP topic in the source documentation for detailed usage instructions and implementation notes.
 
 We support two setup options for this example:
 

examples/gcoap/gcoap_cli.c

@@ -22,7 +22,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include "net/gnrc/coap.h"
+#include "net/gcoap.h"
 #include "od.h"
 #include "fmt.h"
 
@@ -96,22 +96,27 @@ static ssize_t _stats_handler(coap_pkt_t* pdu, uint8_t *buf, size_t len)
 static size_t _send(uint8_t *buf, size_t len, char *addr_str, char *port_str)
 {
     ipv6_addr_t addr;
-    uint16_t port;
     size_t bytes_sent;
+    sock_udp_ep_t remote;
+
+    remote.family = AF_INET6;
+    remote.netif  = SOCK_ADDR_ANY_NETIF;
 
     /* parse destination address */
     if (ipv6_addr_from_str(&addr, addr_str) == NULL) {
         puts("gcoap_cli: unable to parse destination address");
         return 0;
     }
+    memcpy(&remote.addr.ipv6[0], &addr.u8[0], sizeof(addr.u8));
+
     /* parse port */
-    port = (uint16_t)atoi(port_str);
-    if (port == 0) {
+    remote.port = (uint16_t)atoi(port_str);
+    if (remote.port == 0) {
         puts("gcoap_cli: unable to parse destination port");
         return 0;
     }
 
-    bytes_sent = gcoap_req_send(buf, len, &addr, port, _resp_handler);
+    bytes_sent = gcoap_req_send2(buf, len, &remote, _resp_handler);
     if (bytes_sent > 0) {
         req_count++;
     }

examples/gcoap/main.c

@@ -21,7 +21,7 @@
 #include <stdio.h>
 #include "msg.h"
 
-#include "net/gnrc/coap.h"
+#include "net/gcoap.h"
 #include "kernel_types.h"
 #include "shell.h"
 

sys/Makefile

@@ -99,6 +99,9 @@ endif
 ifneq (,$(filter sema,$(USEMODULE)))
     DIRS += sema
 endif
+ifneq (,$(filter gcoap,$(USEMODULE)))
+    DIRS += net/application_layer/coap
+endif
 
 DIRS += $(dir $(wildcard $(addsuffix /Makefile, ${USEMODULE})))
 

sys/auto_init/auto_init.c

@@ -89,7 +89,7 @@
 #endif
 
 #ifdef MODULE_GCOAP
-#include "net/gnrc/coap.h"
+#include "net/gcoap.h"
 #endif
 
 #define ENABLE_DEBUG (0)

sys/include/net/gnrc/coap.h renamed to sys/include/net/gcoap.h

@@ -7,16 +7,23 @@
  */
 
 /**
- * @defgroup    net_gnrc_coap  CoAP
- * @ingroup     net_gnrc
- * @brief       GNRC implementation of CoAP protocol, RFC 7252
- *
- * ## Architecture ##
- * Requests and responses are exchanged via an asynchronous RIOT message
- * processing thread. Depends on nanocoap for base level structs and
- * functionality.
- *
- * Uses a single UDP port for communication to support RFC 6282 compression.
+ * @defgroup    net_gcoap  CoAP
+ * @ingroup     net
+ * @brief       High-level interface to CoAP messaging
+ *
+ * gcoap provides a high-level interface for writing CoAP messages via RIOT's
+ * sock networking API. gcoap internalizes network event processing so an
+ * application only needs to focus on request/response handling. For a server,
+ * gcoap accepts a list of resource paths with callbacks for writing the
+ * response. For a client, gcoap provides a function to send a request, with a
+ * callback for reading the server response. Generation of the request or
+ * response requires from one to three well-defined steps, depending on
+ * inclusion of a payload.
+ *
+ * gcoap allocates a RIOT message processing thread, so a single instance can
+ * serve multiple applications. This approach also means gcoap uses a single UDP
+ * port, which supports RFC 6282 compression. Internally, gcoap depends on the
+ * nanocoap package for base level structs and functionality.
  *
  * ## Server Operation ##
  *
@@ -61,11 +68,10 @@
  *
  * ## Client Operation ##
  *
- * gcoap uses RIOT's asynchronous messaging facility to send and receive
- * messages. So, client operation includes two phases:  creating and sending a
- * request, and handling the response aynchronously in a client supplied
- * callback.  See `examples/gcoap/gcoap_cli.c` for a simple example of sending
- * a request and reading the response.
+ * Client operation includes two phases:  creating and sending a request, and
+ * handling the response aynchronously in a client supplied callback.  See
+ * `examples/gcoap/gcoap_cli.c` for a simple example of sending a request and
+ * reading the response.
  *
  * ### Creating a request ###
  *
@@ -85,8 +91,8 @@
  * as described above. The gcoap_request() function is inline, and uses those
  * two functions.
  *
- * Finally, call gcoap_req_send() with the destination host and port, as well
- * as a callback function for the host's response.
+ * Finally, call gcoap_req_send2() for the destination endpoint, as well as a
+ * callback function for the host's response.
  *
  * ### Handling the response ###
  *
@@ -114,13 +120,13 @@
  * header and the payload. So, gcoap provides space in the buffer for them in
  * the request/response ...init() function, and then writes them during
  * gcoap_finish(). We trade some inefficiency/work in the buffer for
- * simplicity for the user.
+ * simplicity in the API.
  *
  * ### Waiting for a response ###
  *
- * We take advantage of RIOT's GNRC stack by using an xtimer to wait for a
- * response, so the gcoap thread does not block while waiting. The user is
- * notified via the same callback whether the message is received or the wait
+ * We take advantage of RIOT's asynchronous messaging by using an xtimer to wait
+ * for a response, so the gcoap thread does not block while waiting. The user is
+ * notified via the same callback, whether the message is received or the wait
  * times out. We track the response with an entry in the
  * `_coap_state.open_reqs` array.
  *
@@ -135,9 +141,7 @@
 #ifndef GCOAP_H
 #define GCOAP_H
 
-#include "net/gnrc.h"
-#include "net/gnrc/ipv6.h"
-#include "net/gnrc/udp.h"
+#include "net/sock/udp.h"
 #include "nanocoap.h"
 #include "xtimer.h"
 
@@ -199,15 +203,27 @@ extern "C" {
 #define GCOAP_MEMO_ERR      (4)  /**< Error processing response packet */
 /** @} */
 
+/** @brief Time in usec that the event loop waits for an incoming CoAP message */
+#define GCOAP_RECV_TIMEOUT   (1 * US_PER_SEC)
+
 /**
+ *
  * @brief Default time to wait for a non-confirmable response, in usec
  *
  * Set to 0 to disable timeout.
  */
 #define GCOAP_NON_TIMEOUT    (5000000U)
 
-/** @brief Identifies a gcoap-specific timeout IPC message */
-#define GCOAP_NETAPI_MSG_TYPE_TIMEOUT    (0x1501)
+/** @brief Identifies waiting timed out for a response to a sent message. */
+#define GCOAP_MSG_TYPE_TIMEOUT    (0x1501)
+
+/**
+ * @brief Identifies a request to interrupt listening for an incoming message
+ *        on a sock.
+ *
+ * Allows the event loop to process IPC messages.
+ */
+#define GCOAP_MSG_TYPE_INTR    (0x1502)
 
 /**
  * @brief  A modular collection of resources for a server
@@ -243,7 +259,6 @@ typedef struct {
  * @brief  Container for the state of gcoap itself
  */
 typedef struct {
-    gnrc_netreg_entry_t netreg_port;   /**< Registration for IP port */
     gcoap_listener_t *listeners;       /**< List of registered listeners */
     gcoap_request_memo_t open_reqs[GCOAP_REQ_WAITING_MAX];
                                        /**< Storage for open requests; if first
@@ -322,9 +337,25 @@ static inline ssize_t gcoap_request(coap_pkt_t *pdu, uint8_t *buf, size_t len,
                 : -1;
 }
 
+/**
+ * @brief  Sends a buffer containing a CoAP request to the provided endpoint.
+ *
+ * @param[in] buf Buffer containing the PDU
+ * @param[in] len Length of the buffer
+ * @param[in] remote Destination for the packet
+ * @param[in] resp_handler Callback when response received
+ *
+ * @return length of the packet
+ * @return 0 if cannot send
+ */
+size_t gcoap_req_send2(uint8_t *buf, size_t len, sock_udp_ep_t *remote,
+                                                 gcoap_resp_handler_t resp_handler);
+
 /**
  * @brief  Sends a buffer containing a CoAP request to the provided host/port.
  *
+ * @deprecated  Please use @ref gcoap_req_send2() instead
+ *
  * @param[in] buf Buffer containing the PDU
  * @param[in] len Length of the buffer
  * @param[in] addr Destination for the packet