gnrc, nimble/ble: notify network layer of BLE connection events

pkg/nimble/netif/nimble_netif.c

@@ -39,6 +39,7 @@
 #include "host/ble_gap.h"
 #include "host/util/util.h"
 #include "mem/mem.h"
+#include <string.h>
 
 #define ENABLE_DEBUG            0
 #include "debug.h"
@@ -331,6 +332,27 @@
     ble_l2cap_recv_ready(event->receive.chan, rxb);
 }
 
+#ifdef MODULE_GNRC_IPV6
+/**
+ * @brief   Sends a netapi notification for a connection event.
+ *
+ * @param[in] notify    The type of notification event.
+ * @param[in] addr      BLE address of the node that (dis-)connected.
+ */
+static inline void _dispatch_connection_event(netapi_notify_t notify, uint8_t *addr)
+{
+    netapi_notify_l2_connection_t event = {
+        .l2addr_len = BLE_ADDR_LEN,
+        .if_pid = _netif.pid,
+    };
+
+    memcpy(event.l2addr, addr, BLE_ADDR_LEN);
+
+    gnrc_netapi_notify(GNRC_NETTYPE_L2_DISCOVERY, GNRC_NETREG_DEMUX_CTX_ALL,
+                       notify, &event, sizeof(netapi_notify_l2_connection_t));
+}
+#endif /* MODULE_GNRC_IPV6 */
+
 static int _on_l2cap_client_evt(struct ble_l2cap_event *event, void *arg)
 {
     int handle = (int)arg;
@@ -349,6 +371,9 @@
             conn->state |= NIMBLE_NETIF_L2CAP_CLIENT;
             conn->state &= ~NIMBLE_NETIF_CONNECTING;
             _notify(handle, NIMBLE_NETIF_CONNECTED_MASTER, conn->addr);
+#ifdef MODULE_GNRC_IPV6
+            _dispatch_connection_event(NETAPI_NOTIFY_L2_NEIGH_CONNECTED, conn->addr);
+#endif /* MODULE_GNRC_IPV6 */
             break;
         case BLE_L2CAP_EVENT_COC_DISCONNECTED:
             assert(conn->state & NIMBLE_NETIF_L2CAP_CLIENT);
@@ -404,6 +429,9 @@
             }
 
             _notify(handle, NIMBLE_NETIF_CONNECTED_SLAVE, conn->addr);
+#ifdef MODULE_GNRC_IPV6
+            _dispatch_connection_event(NETAPI_NOTIFY_L2_NEIGH_CONNECTED, conn->addr);
+#endif /* MODULE_GNRC_IPV6 */
             break;
         case BLE_L2CAP_EVENT_COC_DISCONNECTED:
             conn = nimble_netif_conn_from_gaphandle(event->disconnect.conn_handle);
@@ -450,7 +478,7 @@
 {
     struct ble_gap_conn_desc desc;
     int res = ble_gap_conn_find(conn->gaphandle, &desc);
     assert(res == 0) ;
     (void)res;
 
     conn->itvl = desc.conn_itvl;
@@ -498,6 +526,9 @@
             nimble_netif_conn_free(handle, addr);
             thread_flags_set(_netif_thread, FLAG_TX_NOTCONN);
             _notify(handle, type, addr);
+#ifdef MODULE_GNRC_IPV6
+            _dispatch_connection_event(NETAPI_NOTIFY_L2_NEIGH_DISCONNECTED, addr);
+#endif /* MODULE_GNRC_IPV6 */
             break;
         }
         case BLE_GAP_EVENT_CONN_UPDATE:
@@ -542,6 +573,9 @@
             nimble_netif_conn_free(handle, addr);
             thread_flags_set(_netif_thread, FLAG_TX_NOTCONN);
             _notify(handle, type, addr);
+#ifdef MODULE_GNRC_IPV6
+            _dispatch_connection_event(NETAPI_NOTIFY_L2_NEIGH_DISCONNECTED, addr);
+#endif /* MODULE_GNRC_IPV6 */
             break;
         }
         case BLE_GAP_EVENT_CONN_UPDATE:

pkg/nimble/rpble/nimble_rpble.c

@@ -222,9 +222,6 @@ static void _on_netif_evt(int handle, nimble_netif_event_t event,
         case NIMBLE_NETIF_CONNECTED_MASTER:
             /* parent selected */
             assert(_current_parent == handle);
-            /* send a DIS once connected to a (new) parent) */
-            gnrc_rpl_send_DIS(NULL, (ipv6_addr_t *) &ipv6_addr_all_rpl_nodes,
-                              NULL, 0);
             break;
         case NIMBLE_NETIF_CONNECTED_SLAVE:
             /* child added */

sys/include/net/gnrc.h

@@ -288,6 +288,7 @@
 
 #include "net/netopt.h"
 #include "net/gnrc/netapi.h"
+#include "net/gnrc/netapi/notify.h"
 #include "net/gnrc/netreg.h"
 #include "net/gnrc/nettype.h"
 #include "net/gnrc/netif.h"

sys/include/net/gnrc/ipv6/nib/nc.h

@@ -233,6 +233,36 @@ static inline unsigned gnrc_ipv6_nib_nc_get_ar_state(const gnrc_ipv6_nib_nc_t *e
 int gnrc_ipv6_nib_nc_set(const ipv6_addr_t *ipv6, unsigned iface,
                          const uint8_t *l2addr, size_t l2addr_len);
 
+#if IS_ACTIVE(CONFIG_GNRC_IPV6_NIB_6LN) || defined(DOXYGEN)
+/**
+ * @brief   Adds an unmanaged neighbor entry to the NIB if the interface represents a 6LN node
+ *          and the IPv6 address can be constructed from the L2 address @p l2addr.
+ *
+ * @param[in] iface         The interface to the neighbor.
+ * @param[in] l2addr        The neighbor's layer 2 address.
+ * @param[in] l2addr_len    Length of @p l2addr.
+ *
+ * @retval  0 on success.
+ * @retval  -ENOTSUP if the interface does not represent a 6LN or when
+ *           gnrc_netif_t::device_type of the iface does not support IID conversion.
+ * @retval  -EINVAL when @p addr_len is invalid for the
+ *          gnrc_netif_t::device_type of @p netif.
+ * @retval  -ENOMEM if no space is left in neighbor cache.
+ */
+int gnrc_ipv6_nib_nc_set_6ln(unsigned iface, const uint8_t *l2addr,
+                             size_t l2addr_len);
+#else /* CONFIG_GNRC_IPV6_NIB_6LN */
+static inline int gnrc_ipv6_nib_nc_set_6ln(unsigned iface, const uint8_t *l2addr,
+                                           size_t l2addr_len)
+{
+    (void)iface;
+    (void)l2addr;
+    (void)l2addr_len;
+
+    return -ENOTSUP;
+}
+#endif /* CONFIG_GNRC_IPV6_NIB_6LN */
+
 /**
  * @brief   Deletes neighbor with address @p ipv6 from NIB
  *
@@ -245,6 +275,21 @@ int gnrc_ipv6_nib_nc_set(const ipv6_addr_t *ipv6, unsigned iface,
  */
 void gnrc_ipv6_nib_nc_del(const ipv6_addr_t *ipv6, unsigned iface);
 
+/**
+ * @brief   Deletes neighbor with link-layer address @p l2addr from NIB.
+ *
+ * @param[in] iface         The interface to the neighbor.
+ * @param[in] l2addr        The neighbor's l2addr address.
+ * @param[in] l2addr_len    Length of @p l2addr.
+ *
+ *
+ * If the @p l2addr can't be found for a neighbor in the NIB nothing happens.
+ *
+ * @retval  True if a neighbor with @p l2addr existed.
+ * @retval  False otherwise.
+ */
+bool gnrc_ipv6_nib_nc_del_l2(unsigned iface, const uint8_t *l2addr, size_t l2addr_len);
+
 /**
  * @brief   Mark neighbor with address @p ipv6 as reachable
  *

sys/include/net/gnrc/netapi.h

@@ -60,6 +60,7 @@
 
 #include "thread.h"
 #include "net/netopt.h"
+#include "net/gnrc/netapi/notify.h"
 #include "net/gnrc/nettype.h"
 #include "net/gnrc/pkt.h"
 
@@ -88,10 +89,17 @@ extern "C" {
 #define GNRC_NETAPI_MSG_TYPE_GET        (0x0204)
 
 /**
- * @brief   @ref core_msg type for replying to get and set option messages
+ * @brief   @ref core_msg type for replying to get/set option, and notify messages
  */
 #define GNRC_NETAPI_MSG_TYPE_ACK        (0x0205)
 
+/**
+ * @brief   @ref core_msg type for sending a general event notifications to one or more subscribers
+ *
+ * This sends back a @ref GNRC_NETAPI_MSG_TYPE_ACK, so it should be used with `msg_send_receive()`.
+ */
+#define GNRC_NETAPI_MSG_TYPE_NOTIFY     (0x0207)
+
 /**
  * @brief   Data structure to be send for setting (@ref GNRC_NETAPI_MSG_TYPE_SET)
  *          and getting (@ref GNRC_NETAPI_MSG_TYPE_GET) options
@@ -183,6 +191,24 @@ static inline int gnrc_netapi_dispatch_send(gnrc_nettype_t type, uint32_t demux_
     return gnrc_netapi_dispatch(type, demux_ctx, GNRC_NETAPI_MSG_TYPE_SND, pkt);
 }
 
+/**
+ * @brief   Sends a @ref GNRC_NETAPI_MSG_TYPE_NOTIFY command to all subscribers to
+ *          (@p type, @p demux_ctx).
+ *
+ * @note    This blocks the sender until all registered subscribers have ack'ed the notification
+ *          or sending has failed. The @p data can be freed after the function returned.
+ *
+ * @param[in] type          Type of the targeted network module.
+ * @param[in] demux_ctx     Demultiplexing context for @p type.
+ * @param[in] event         Notification event type.
+ * @param[in] data          Data associated with the event.
+ * @param[in] data_len      Size of @p data.
+ *
+ * @return Number of subscribers to (@p type, @p demux_ctx).
+ */
+int gnrc_netapi_notify(gnrc_nettype_t type, uint32_t demux_ctx, netapi_notify_t event,
+                       void *data, size_t data_len);
+
 /**
  * @brief   Shortcut function for sending @ref GNRC_NETAPI_MSG_TYPE_RCV messages
  *

sys/include/net/gnrc/netapi/notify.h

@@ -0,0 +1,104 @@
+/*
+ * SPDX-FileCopyrightText: 2025 TU Dresden
+ * SPDX-License-Identifier: LGPL-2.1-only
+ */
+
+#pragma once
+
+/**
+ * @defgroup    net_gnrc_netapi_notify  Notification events for network APIs.
+ * @ingroup     net_gnrc_netapi
+ * @brief       Network event notification types.
+ * @{
+ *
+ * @file
+ * @brief   Network event notification type definitions.
+ *
+ * @details The purpose of this API is to allow lower layers in the network
+ *          stack to inform higher layers of general, protocol-independent
+ *          network events.
+ *          It can be used through the @ref net_gnrc_netapi to notify any
+ *          other network interfaces that have registered themselves through
+ *          @ref net_gnrc_netreg for the corresponding @ref net_gnrc_nettype.
+ *
+ * @note    Notification events are associated with type-dependent event data.
+ *          Receivers should not access the data directly, but instead use the
+ *          the dedicated API functions to copy the data from the sender's.
+ *          If the data is read manually, the receiver is responsible for
+ *          calling @ref gnrc_netapi_notify_ack to unblock the sender.
+ *
+ * @author  Elena Frank <[email protected]>
+ */
+
+#include <stdint.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "net/gnrc/netif/conf.h"
+#include "sema_inv.h"
+
+/**
+ * @brief   Definition of notification event types in the network stack.
+ *
+ * @note    Expand at will.
+ *          If event data is associated with the type, a helper function must also
+ *          be added for parsing the data and calling @ref gnrc_netapi_notify_ack.
+ */
+typedef enum {
+    NETAPI_NOTIFY_L2_NEIGH_CONNECTED,       /**< Connection established on layer 2. */
+    NETAPI_NOTIFY_L2_NEIGH_DISCONNECTED,    /**< Connection closed on layer 2. */
+    NETAPI_NOTIFY_L3_DISCOVERED,            /**< Discovered node on the network layer. */
+    NETAPI_NOTIFY_L3_UNREACHABLE,           /**< Node became unreachable on the network layer. */
+} netapi_notify_t;
+
+/**
+ * @brief   Data structure to be sent for netapi notification events.
+ */
+typedef struct {
+    netapi_notify_t event;          /**< the type of event */
+    void *_data;                    /**< associated event data. */
+    uint16_t _data_len;             /**< size of the event data */
+    sema_inv_t ack;                 /**< inverse semaphore for collecting ack's */
+} gnrc_netapi_notify_t;
+
+/**
+ * @brief   L2 connection event data associated with @ref NETAPI_NOTIFY_L2_NEIGH_CONNECTED or
+ *          @ref NETAPI_NOTIFY_L2_NEIGH_DISCONNECTED events.
+ */
+typedef struct {
+    uint8_t l2addr[GNRC_NETIF_L2ADDR_MAXLEN];   /**< L2 address of the node */
+    uint8_t l2addr_len;                         /**< length of L2 address in byte */
+    kernel_pid_t if_pid;                        /**< PID of network interface */
+} netapi_notify_l2_connection_t;
+
+/**
+ * @brief   Acknowledge that a notify event was received and its data read.
+ *
+ * @param[in] ack           Pointer to semaphore that is used to collect ack's.
+ */
+static inline void gnrc_netapi_notify_ack(sema_inv_t *ack)
+{
+    sema_inv_post(ack);
+}
+
+/**
+ * @brief   Copy the connection event data associated with a @ref gnrc_netapi_notify_t event.
+ *
+ * @note    This will call @ref gnrc_netapi_notify_ack.
+ *
+ * @param[in] notify        Pointer to the received notify event.
+ * @param[in] data_len      Size of the expected data type.
+ * @param[out] data         Connection data received in the @p notify event.
+ *
+ * @retval                  Size of the data type on success.
+ * @retval                  -EINVAL if the data in @p notify is invalid or doesn't match the expected
+ *                          data length.
+ */
+int gnrc_netapi_notify_copy_event_data(gnrc_netapi_notify_t *notify, uint8_t data_len, void *data);
+
+#ifdef __cplusplus
+}
+#endif
+
+/** @} */

sys/include/net/gnrc/netreg.h

@@ -330,7 +330,8 @@ static inline void gnrc_netreg_entry_init_cb(gnrc_netreg_entry_t *entry,
  * @brief   Registers a thread to the registry.
  *
  * @details The semantics are: Thread gnrc_netreg_entry_t::pid is interested in
- *          packets of protocol @p type with context gnrc_netreg_entry_t::demux_ctx.
+ *          packets or network events of protocol @p type with context
+ *          gnrc_netreg_entry_t::demux_ctx.
  *
  * @param[in] type      Type of the protocol. Must not be < GNRC_NETTYPE_UNDEF or
  *                      >= GNRC_NETTYPE_NUMOF.

sys/include/net/gnrc/nettype.h

@@ -120,6 +120,15 @@ typedef enum {
 #endif
     /** @} */
 
+    /**
+     * @{
+     * @name Protocol-independent network events.
+     * }
+     */
+    GNRC_NETTYPE_L2_DISCOVERY,  /**< Layer 2 node discovery */
+    GNRC_NETTYPE_L3_ROUTING,    /**< Layer 3 routing info */
+    /** @} */
+
     /**
      * @{
      * @name Testing

sys/include/net/gnrc/rpl/dodag.h

@@ -129,6 +129,18 @@ void gnrc_rpl_dodag_remove_all_parents(gnrc_rpl_dodag_t *dodag);
 bool gnrc_rpl_parent_add_by_addr(gnrc_rpl_dodag_t *dodag, ipv6_addr_t *addr,
                                  gnrc_rpl_parent_t **parent);
 
+/**
+ * @brief   Iterate over all parents in all DODAGs with @p IPv6 address.
+ *
+ * @param[in]   idx         Index to start searching from.
+ * @param[in]   addr        IPV6 address of the parent.
+ * @param[out]  parent      Pointer to the parent if one was found. Otherwise NULL.
+ *
+ * @retval  Index > 0 to continue next search from, if parent was found.
+ * @retval  -ENONENT if not found
+ */
+int gnrc_rpl_parent_iter_by_addr(ipv6_addr_t *addr, gnrc_rpl_parent_t **parent, int idx);
+
 /**
  * @brief   Remove the @p parent from its DODAG.
  *

sys/net/gnrc/Makefile

@@ -43,6 +43,9 @@ endif
 ifneq (,$(filter gnrc_netapi,$(USEMODULE)))
   DIRS += netapi
 endif
+ifneq (,$(filter gnrc_netapi_notify,$(USEMODULE)))
+  DIRS += netapi/notify
+endif
 ifneq (,$(filter gnrc_netif gnrc_netif_%,$(USEMODULE)))
     DIRS += netif
 endif