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

pkg/nimble/netif/nimble_netif.c

@@ -331,6 +331,24 @@
     ble_l2cap_recv_ready(event->receive.chan, rxb);
 }
 
+/**
+ * @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(netnotify_t notify, uint8_t *addr)
+{
+    netnotify_l2_connec_t event = {
+        .l2addr = addr,
+        .l2addr_len = BLE_ADDR_LEN,
+        .if_pid = _netif.pid,
+    };
+
+    gnrc_netapi_notify(GNRC_NETTYPE_L2_DISCOVERY, GNRC_NETREG_DEMUX_CTX_ALL,
+                       notify, &event, sizeof(netnotify_l2_connec_t));
+}
+
 static int _on_l2cap_client_evt(struct ble_l2cap_event *event, void *arg)
 {
     int handle = (int)arg;
@@ -349,6 +367,7 @@
             conn->state |= NIMBLE_NETIF_L2CAP_CLIENT;
             conn->state &= ~NIMBLE_NETIF_CONNECTING;
             _notify(handle, NIMBLE_NETIF_CONNECTED_MASTER, conn->addr);
+            _dispatch_connection_event(NETNOTIFY_L2_CONNECTED, conn->addr);
             break;
         case BLE_L2CAP_EVENT_COC_DISCONNECTED:
             assert(conn->state & NIMBLE_NETIF_L2CAP_CLIENT);
@@ -404,6 +423,7 @@
             }
 
             _notify(handle, NIMBLE_NETIF_CONNECTED_SLAVE, conn->addr);
+            _dispatch_connection_event(NETNOTIFY_L2_CONNECTED, conn->addr);
             break;
         case BLE_L2CAP_EVENT_COC_DISCONNECTED:
             conn = nimble_netif_conn_from_gaphandle(event->disconnect.conn_handle);
@@ -450,7 +470,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 +518,7 @@
             nimble_netif_conn_free(handle, addr);
             thread_flags_set(_netif_thread, FLAG_TX_NOTCONN);
             _notify(handle, type, addr);
+            _dispatch_connection_event(NETNOTIFY_L2_DISCONNECTED, addr);
             break;
         }
         case BLE_GAP_EVENT_CONN_UPDATE:
@@ -542,6 +563,7 @@
             nimble_netif_conn_free(handle, addr);
             thread_flags_set(_netif_thread, FLAG_TX_NOTCONN);
             _notify(handle, type, addr);
+            _dispatch_connection_event(NETNOTIFY_L2_DISCONNECTED, addr);
             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/ipv6/nib/nc.h

@@ -233,6 +233,29 @@ 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.
+ *
+ * @return  0 on success.
+ * @return  -ENOTSUP, if the interface does not represent a 6LN or when
+ *           gnrc_netif_t::device_type of the iface does not support IID conversion.
+ * @return  -EINVAL, when @p addr_len is invalid for the
+ *          gnrc_netif_t::device_type of @p netif.
+ * @return  -ENOMEM, if no space is left in neighbor cache.
+ */
+int gnrc_ipv6_nib_nc_try_set_6ln(unsigned iface, const uint8_t *l2addr,
+                                 size_t l2addr_len);
+#else /* CONFIG_GNRC_IPV6_NIB_6LN */
+#define gnrc_ipv6_nib_nc_try_set_6ln(unsigned iface, const uint8_t *l2addr,
+                                 size_t l2addr_len)   (-ENOTSUP)
+#endif /* CONFIG_GNRC_IPV6_NIB_6LN */
+
 /**
  * @brief   Deletes neighbor with address @p ipv6 from NIB
  *
@@ -245,6 +268,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.
+ *
+ * @return  True, if a neighbor with @p l2addr existed.
+ * @return  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/netnotify.h"
 #include "net/gnrc/nettype.h"
 #include "net/gnrc/pkt.h"
 
@@ -88,10 +89,15 @@ 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 event notifications to the network stack.
+ */
+#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
@@ -103,6 +109,15 @@ typedef struct {
     uint16_t data_len;          /**< size of the data / the buffer */
 } gnrc_netapi_opt_t;
 
+/**
+ * @brief   Data structure to be send for notification events.
+ */
+typedef struct {
+    netnotify_t event;          /**< the type of event */
+    void *data;                 /**< event data */
+    uint16_t data_len;          /**< size of the data */
+} gnrc_netapi_notify_t;
+
 /**
  * @brief   Shortcut function for sending @ref GNRC_NETAPI_MSG_TYPE_SND or
  *          @ref GNRC_NETAPI_MSG_TYPE_RCV messages
@@ -183,6 +198,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, netnotify_t event,
+                       void *data, size_t data_len);
+
 /**
  * @brief   Shortcut function for sending @ref GNRC_NETAPI_MSG_TYPE_RCV messages
  *

sys/include/net/gnrc/netnotify.h

@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2025 Elena Frank <[email protected]>
+ *
+ * This file is subject to the terms and conditions of the GNU Lesser
+ * General Public License v2.1. See the file LICENSE in the top level
+ * directory for more details.
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "sched.h"
+
+/**
+ * @brief   Definition of notification event types in the network stack.
+ *
+ * @note    Expand at will.
+ */
+typedef enum {
+    NETNOTIFY_L2_CONNECTED,
+    NETNOTIFY_L2_DISCONNECTED,
+    NETNOTIFY_L3_DISCOVERED,
+    NETNOTIFY_L3_UNREACHABLE,
+} netnotify_t;
+
+/**
+ * @brief   L2 (dis-)connection event data.
+ */
+typedef struct netnotify_l2_connec {
+    uint8_t *l2addr;            /**< L2 address of the node */
+    uint8_t l2addr_len;         /**< length of L2 address in byte */
+    kernel_pid_t if_pid;        /**< PID of network interface */
+} netnotify_l2_connec_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+/** @} */

sys/include/net/gnrc/nettype.h

@@ -105,6 +105,10 @@
     GNRC_NETTYPE_ICMPV6,        /**< Protocol is ICMPv6 */
 #endif
 
+    GNRC_NETTYPE_L2_DISCOVERY,  /**< L2 node discovery */
+
+    GNRC_NETTYPE_L3_ROUTING,    /**< L3 routing info */
+
 #if IS_USED(MODULE_GNRC_NETTYPE_CCN) || defined(DOXYGEN)
     GNRC_NETTYPE_CCN,           /**< Protocol is CCN */
     GNRC_NETTYPE_CCN_CHUNK,     /**< Protocol is CCN, packet contains a content
@@ -142,7 +146,7 @@
 
 /**
  * @brief   Translates an Ether Type number to @ref gnrc_nettype_t
  * @see     [IANA, ETHER TYPES](http://www.iana.org/assignments/ieee-802-numbers/ieee-802-numbers.xhtml)
  *
  * @param[in] type  An Ether Type number
  *
@@ -179,7 +183,7 @@
 
 /**
  * @brief   Translates @ref gnrc_nettype_t to an Ether Type number
  * @see     [IANA, ETHER TYPES](http://www.iana.org/assignments/ieee-802-numbers/ieee-802-numbers.xhtml)
  *
  * @param[in] type  A protocol type
  *

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.
+ *
+ * @return  Index > 0 to continue next search from, if parent was found.
+ * @return  -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/netapi/gnrc_netapi.c

@@ -141,3 +141,41 @@
 
     return numof;
 }
+
+int gnrc_netapi_notify(gnrc_nettype_t type, uint32_t demux_ctx, netnotify_t event,
+                       void *data, size_t data_len)
+{
+    gnrc_netapi_notify_t notify;
+    msg_t cmd;
+    msg_t ack;
+
+    notify.event = event;
+    notify.data = data;
+    notify.data_len = data_len;
+
+    cmd.type = GNRC_NETAPI_MSG_TYPE_NOTIFY;
+    cmd.content.ptr = (void *)&notify;
+
+    gnrc_netreg_acquire_shared();
+
+    int numof = gnrc_netreg_num(type, demux_ctx);
+
+    if (numof != 0) {
+        /* Look up the registered threads for this message type. */
+        gnrc_netreg_entry_t *sendto = gnrc_netreg_lookup(type, demux_ctx);
+
+        /* Dispatch to all registered threads sequentially. */
+        while (sendto) {
+            /* Need to wait for an ACK to ensure that the msg was received and that
+               there won't be any dangling pointers after the function returned. */
+            /* TODO: First send to all threads, then wait for all ACK's?*/
+            msg_send_receive(&cmd, &ack, sendto->target.pid);
+            assert(ack.type == GNRC_NETAPI_MSG_TYPE_ACK);
+            sendto = gnrc_netreg_getnext(sendto);
+        }
+    }
+
+    gnrc_netreg_release_shared();
+
+    return numof;
+}