Merge pull request #13615 from miri64/sock_async/api/callback-arg

sock_async: add optional callback argument

pkg/lwip/contrib/sock/ip/lwip_sock_ip.c

@@ -181,8 +181,9 @@ ssize_t sock_ip_send(sock_ip_t *sock, const void *data, size_t len,
 }
 
 #ifdef SOCK_HAS_ASYNC
-void sock_ip_set_cb(sock_ip_t *sock, sock_ip_cb_t cb)
+void sock_ip_set_cb(sock_ip_t *sock, sock_ip_cb_t cb, void *arg)
 {
+    sock->base.async_cb_arg = arg;
     sock->base.async_cb.ip = cb;
 }
 

pkg/lwip/contrib/sock/lwip_sock.c

@@ -312,7 +312,7 @@ static void _netconn_cb(struct netconn *conn, enum netconn_evt evt,
                 break;
         }
         if (flags && sock->async_cb.gen) {
-            sock->async_cb.gen(sock, flags);
+            sock->async_cb.gen(sock, flags, sock->async_cb_arg);
         }
     }
 #else

pkg/lwip/contrib/sock/tcp/lwip_sock_tcp.c

@@ -380,13 +380,16 @@ ssize_t sock_tcp_write(sock_tcp_t *sock, const void *data, size_t len)
 }
 
 #ifdef SOCK_HAS_ASYNC
-void sock_tcp_set_cb(sock_tcp_t *sock, sock_tcp_cb_t cb)
+void sock_tcp_set_cb(sock_tcp_t *sock, sock_tcp_cb_t cb, void *arg)
 {
+    sock->base.async_cb_arg = arg;
     sock->base.async_cb.tcp = cb;
 }
 
-void sock_tcp_queue_set_cb(sock_tcp_queue_t *queue, sock_tcp_queue_cb_t cb)
+void sock_tcp_queue_set_cb(sock_tcp_queue_t *queue, sock_tcp_queue_cb_t cb,
+                           void *arg)
 {
+    queue->base.async_cb_arg = arg;
     queue->base.async_cb.tcp_queue = cb;
 }
 

pkg/lwip/contrib/sock/udp/lwip_sock_udp.c

@@ -136,8 +136,9 @@ ssize_t sock_udp_send(sock_udp_t *sock, const void *data, size_t len,
 }
 
 #ifdef SOCK_HAS_ASYNC
-void sock_udp_set_cb(sock_udp_t *sock, sock_udp_cb_t cb)
+void sock_udp_set_cb(sock_udp_t *sock, sock_udp_cb_t cb, void *arg)
 {
+    sock->base.async_cb_arg = arg;
     sock->base.async_cb.udp = cb;
 }
 

pkg/lwip/include/sock_types.h

@@ -40,7 +40,8 @@ typedef struct lwip_sock_base lwip_sock_base_t;
  * @internal
  */
 typedef void (*lwip_sock_cb_t)(lwip_sock_base_t *sock,
-                               sock_async_flags_t flags);
+                               sock_async_flags_t flags,
+                               void *arg);
 #endif  /* SOCK_HAS_ASYNC */
 
 /**
@@ -74,6 +75,7 @@ struct lwip_sock_base {
         sock_udp_cb_t udp;          /**< UDP version */
 #endif
     } async_cb;
+    void *async_cb_arg;             /**< asynchronous callback argument */
 #ifdef SOCK_HAS_ASYNC_CTX
     sock_async_ctx_t async_ctx;     /**< asynchronous event context */
 #endif  /* SOCK_HAS_ASYNC_CTX */

sys/include/net/sock/async.h

@@ -44,8 +44,9 @@ extern "C" {
  *
  * @param[in] sock      A DTLS sock object.
  * @param[in] cb        An event callback. May be NULL to unset event callback.
+ * @param[in] cb_arg    Argument to provide to @p cb. May be NULL.
  */
-void sock_dtls_set_cb(sock_dtls_t *sock, sock_dtls_cb_t cb);
+void sock_dtls_set_cb(sock_dtls_t *sock, sock_dtls_cb_t cb, void *cb_arg);
 #endif  /* defined(MODULE_SOCK_DTLS) || defined(DOXYGEN) */
 
 #if defined(MODULE_SOCK_IP) || defined(DOXYGEN)
@@ -61,8 +62,9 @@ void sock_dtls_set_cb(sock_dtls_t *sock, sock_dtls_cb_t cb);
  *
  * @param[in] sock  A raw IPv4/IPv6 sock object.
  * @param[in] cb    An event callback. May be NULL to unset event callback.
+ * @param[in] cb_arg    Argument to provide to @p cb. May be NULL.
  */
-void sock_ip_set_cb(sock_ip_t *sock, sock_ip_cb_t cb);
+void sock_ip_set_cb(sock_ip_t *sock, sock_ip_cb_t cb, void *cb_arg);
 #endif  /* defined(MODULE_SOCK_IP) || defined(DOXYGEN) */
 
 #if defined(MODULE_SOCK_TCP) || defined(DOXYGEN)
@@ -78,8 +80,9 @@ void sock_ip_set_cb(sock_ip_t *sock, sock_ip_cb_t cb);
  *
  * @param[in] sock      A TCP sock object.
  * @param[in] cb        An event callback. May be NULL to unset event callback.
+ * @param[in] cb_arg    Argument to provide to @p cb. May be NULL.
  */
-void sock_tcp_set_cb(sock_tcp_t *sock, sock_tcp_cb_t cb);
+void sock_tcp_set_cb(sock_tcp_t *sock, sock_tcp_cb_t cb, void *cb_arg);
 
 /**
  * @brief   Sets event callback for @ref sock_tcp_queue_t
@@ -93,8 +96,10 @@ void sock_tcp_set_cb(sock_tcp_t *sock, sock_tcp_cb_t cb);
  *
  * @param[in] queue     A TCP listening queue.
  * @param[in] cb        An event callback. May be NULL to unset event callback.
+ * @param[in] cb_arg    Argument to provide to @p cb. May be NULL.
  */
-void sock_tcp_queue_set_cb(sock_tcp_queue_t *queue, sock_tcp_queue_cb_t cb);
+void sock_tcp_queue_set_cb(sock_tcp_queue_t *queue, sock_tcp_queue_cb_t cb,
+                           void *cb_arg);
 #endif  /* defined(MODULE_SOCK_TCP) || defined(DOXYGEN) */
 
 #if defined(MODULE_SOCK_UDP) || defined(DOXYGEN)
@@ -110,8 +115,9 @@ void sock_tcp_queue_set_cb(sock_tcp_queue_t *queue, sock_tcp_queue_cb_t cb);
  *
  * @param[in] sock      A UDP sock object.
  * @param[in] cb        An event callback. May be NULL to unset event callback.
+ * @param[in] cb_arg    Argument to provide to @p cb
  */
-void sock_udp_set_cb(sock_udp_t *sock, sock_udp_cb_t cb);
+void sock_udp_set_cb(sock_udp_t *sock, sock_udp_cb_t cb, void *cb_arg);
 #endif  /* defined(MODULE_SOCK_UDP) || defined(DOXYGEN) */
 
 #if defined(SOCK_HAS_ASYNC_CTX) || defined(DOXYGEN)

sys/include/net/sock/async/event.h

@@ -36,8 +36,9 @@
  * event_queue_t queue;
  * uint8_t buf[128];
  *
- * void handler(sock_udp_t *sock, sock_async_flags_t type)
+ * void handler(sock_udp_t *sock, sock_async_flags_t type, void *arg)
  * {
+ *     (void)arg;
  *     if (type & SOCK_ASYNC_MSG_RECV) {
  *         sock_udp_ep_t remote;
  *         ssize_t res;
@@ -65,7 +66,7 @@
  *     }
  *
  *     event_queue_init(&queue);
- *     sock_udp_event_init(&sock, &queue, handler);
+ *     sock_udp_event_init(&sock, &queue, handler, NULL);
  *     event_loop(&queue);
  *     return 0;
  * }
@@ -101,8 +102,9 @@
  * send, we print an according message:
  *
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.c}
- * void handler(sock_udp_t *sock, sock_async_flags_t type)
+ * void handler(sock_udp_t *sock, sock_async_flags_t type, void *arg)
  * {
+ *     (void)arg;
  *     if (type & SOCK_ASYNC_MSG_RECV) {
  *         sock_udp_ep_t remote;
  *         ssize_t res;
@@ -144,7 +146,7 @@
  *
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.c}
  *     event_queue_init(&queue);
- *     sock_udp_event_init(&sock, &queue, handler);
+ *     sock_udp_event_init(&sock, &queue, handler, NULL);
  *     event_loop(&queue);
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  *
@@ -183,11 +185,12 @@ extern "C" {
  * @param[in] ev_queue      The queue the events on @p sock will be added to.
  * @param[in] handler       The event handler function to call on an event on
  *                          @p sock.
+ * @param[in] handler_arg   Argument to provided to @p handler.
  *
  * @note    Only available with module `sock_dtls`.
  */
 void sock_dtls_event_init(sock_dtls_t *sock, event_queue_t *ev_queue,
-                          sock_dtls_cb_t handler);
+                          sock_dtls_cb_t handler, void *handler_arg);
 #endif  /* defined(MODULE_SOCK_DTLS) || defined(DOXYGEN) */
 
 #if defined(MODULE_SOCK_IP) || defined(DOXYGEN)
@@ -199,11 +202,12 @@ void sock_dtls_event_init(sock_dtls_t *sock, event_queue_t *ev_queue,
  * @param[in] ev_queue      The queue the events on @p sock will be added to.
  * @param[in] handler       The event handler function to call on an event on
  *                          @p sock.
+ * @param[in] handler_arg   Argument to provided to @p handler.
  *
  * @note    Only available with module `sock_ip`.
  */
 void sock_ip_event_init(sock_ip_t *sock, event_queue_t *ev_queue,
-                        sock_ip_cb_t handler);
+                        sock_ip_cb_t handler, void *handler_arg);
 #endif  /* defined(MODULE_SOCK_IP) || defined(DOXYGEN) */
 
 #if defined(MODULE_SOCK_TCP) || defined(DOXYGEN)
@@ -215,11 +219,12 @@ void sock_ip_event_init(sock_ip_t *sock, event_queue_t *ev_queue,
  * @param[in] ev_queue      The queue the events on @p sock will be added to.
  * @param[in] handler       The event handler function to call on an event on
  *                          @p sock.
+ * @param[in] handler_arg   Argument to provided to @p handler.
  *
  * @note    Only available with module `sock_tcp`.
  */
 void sock_tcp_event_init(sock_tcp_t *sock, event_queue_t *ev_queue,
-                         sock_tcp_cb_t handler);
+                         sock_tcp_cb_t handler, void *handler_arg);
 
 /**
  * @brief   Makes a TCP listening queue able to handle asynchronous events using
@@ -229,11 +234,12 @@ void sock_tcp_event_init(sock_tcp_t *sock, event_queue_t *ev_queue,
  * @param[in] ev_queue      The queue the events on @p sock will be added to.
  * @param[in] handler       The event handler function to call on an event on
  *                          @p sock.
+ * @param[in] handler_arg   Argument to provided to @p handler.
  *
  * @note    Only available with module `sock_tcp`.
  */
 void sock_tcp_queue_event_init(sock_tcp_queue_t *queue, event_queue_t *ev_queue,
-                               sock_tcp_queue_cb_t handler);
+                               sock_tcp_queue_cb_t handler, void *handler_arg);
 #endif  /* defined(MODULE_SOCK_TCP) || defined(DOXYGEN) */
 
 #if defined(MODULE_SOCK_UDP) || defined(DOXYGEN)
@@ -245,11 +251,12 @@ void sock_tcp_queue_event_init(sock_tcp_queue_t *queue, event_queue_t *ev_queue,
  * @param[in] ev_queue      The queue the events on @p sock will be added to.
  * @param[in] handler       The event handler function to call on an event on
  *                          @p sock.
+ * @param[in] handler_arg   Argument to provided to @p handler.
  *
  * @note    Only available with module `sock_udp`.
  */
 void sock_udp_event_init(sock_udp_t *sock, event_queue_t *ev_queue,
-                         sock_udp_cb_t handler);
+                         sock_udp_cb_t handler, void *handler_arg);
 #endif  /* defined(MODULE_SOCK_UDP) || defined(DOXYGEN) */
 
 #ifdef __cplusplus

sys/include/net/sock/async/types.h

@@ -54,8 +54,11 @@ typedef struct sock_dtls sock_dtls_t;       /**< forward declare for async */
  *                  - @ref SOCK_ASYNC_MSG_SENT,
  *                  - @ref SOCK_ASYNC_PATH_PROP, or
  *                  - a combination of them.
+ * @param[in] arg   Argument provided when setting the callback using
+ *                  @ref sock_dtls_set_cb(). May be NULL.
  */
-typedef void (*sock_dtls_cb_t)(sock_dtls_t *sock, sock_async_flags_t flags);
+typedef void (*sock_dtls_cb_t)(sock_dtls_t *sock, sock_async_flags_t flags,
+                               void *arg);
 #endif  /* defined(MODULE_SOCK_DTLS) || defined(DOXYGEN) */
 
 #if defined(MODULE_SOCK_IP) || defined(DOXYGEN)
@@ -74,8 +77,11 @@ typedef struct sock_ip sock_ip_t;       /**< forward declare for async */
  *                  - @ref SOCK_ASYNC_MSG_SENT,
  *                  - @ref SOCK_ASYNC_PATH_PROP, or
  *                  - a combination of them.
+ * @param[in] arg   Argument provided when setting the callback using
+ *                  @ref sock_ip_set_cb(). May be NULL.
  */
-typedef void (*sock_ip_cb_t)(sock_ip_t *sock, sock_async_flags_t flags);
+typedef void (*sock_ip_cb_t)(sock_ip_t *sock, sock_async_flags_t flags,
+                             void *arg);
 #endif  /* defined(MODULE_SOCK_IP) || defined(DOXYGEN) */
 
 #if defined(MODULE_SOCK_TCP) || defined(DOXYGEN)
@@ -97,8 +103,11 @@ typedef struct sock_tcp_queue sock_tcp_queue_t;/**< forward declare for async */
  *                  - @ref SOCK_ASYNC_MSG_SENT,
  *                  - @ref SOCK_ASYNC_PATH_PROP, or
  *                  - a combination of them.
+ * @param[in] arg   Argument provided when setting the callback using
+ *                  @ref sock_tcp_set_cb(). May be NULL.
  */
-typedef void (*sock_tcp_cb_t)(sock_tcp_t *sock, sock_async_flags_t flags);
+typedef void (*sock_tcp_cb_t)(sock_tcp_t *sock, sock_async_flags_t flags,
+                              void *arg);
 
 /**
  * @brief   Event callback for @ref sock_tcp_queue_t
@@ -110,9 +119,12 @@ typedef void (*sock_tcp_cb_t)(sock_tcp_t *sock, sock_async_flags_t flags);
  * @param[in] queue The TCP listening queue the event happened on
  * @param[in] flags The event flags. The only expected value is @ref
  *                  SOCK_ASYNC_CONN_RECV.
+ * @param[in] arg   Argument provided when setting the callback using
+ *                  @ref sock_tcp_queue_set_cb(). May be NULL.
  */
 typedef void (*sock_tcp_queue_cb_t)(sock_tcp_queue_t *queue,
-                                    sock_async_flags_t flags);
+                                    sock_async_flags_t flags,
+                                    void *arg);
 #endif  /* defined(MODULE_SOCK_TCP) || defined(DOXYGEN) */
 
 #if defined(MODULE_SOCK_UDP) || defined(DOXYGEN)
@@ -131,8 +143,11 @@ typedef struct sock_udp sock_udp_t;     /**< forward declare for async */
  *                  - @ref SOCK_ASYNC_MSG_SENT,
  *                  - @ref SOCK_ASYNC_PATH_PROP, or
  *                  - a combination of them.
+ * @param[in] arg   Argument provided when setting the callback using
+ *                  @ref sock_udp_set_cb(). May be NULL.
  */
-typedef void (*sock_udp_cb_t)(sock_udp_t *sock, sock_async_flags_t type);
+typedef void (*sock_udp_cb_t)(sock_udp_t *sock, sock_async_flags_t type,
+                              void *arg);
 #endif  /* defined(MODULE_SOCK_UDP) || defined(DOXYGEN) */
 
 #ifdef SOCK_HAS_ASYNC_CTX

sys/net/application_layer/gcoap/gcoap.c

@@ -46,7 +46,7 @@
 
 /* Internal functions */
 static void *_event_loop(void *arg);
-static void _on_sock_evt(sock_udp_t *sock, sock_async_flags_t type);
+static void _on_sock_evt(sock_udp_t *sock, sock_async_flags_t type, void *arg);
 static ssize_t _well_known_core_handler(coap_pkt_t* pdu, uint8_t *buf, size_t len, void *ctx);
 static size_t _handle_req(coap_pkt_t *pdu, uint8_t *buf, size_t len,
                                                          sock_udp_ep_t *remote);
@@ -121,19 +121,20 @@ static void *_event_loop(void *arg)
     }
 
     event_queue_init(&_queue);
-    sock_udp_event_init(&_sock, &_queue, _on_sock_evt);
+    sock_udp_event_init(&_sock, &_queue, _on_sock_evt, NULL);
     event_loop(&_queue);
 
     return 0;
 }
 
 /* Handles sock events from the event queue. */
-static void _on_sock_evt(sock_udp_t *sock, sock_async_flags_t type)
+static void _on_sock_evt(sock_udp_t *sock, sock_async_flags_t type, void *arg)
 {
     coap_pkt_t pdu;
     sock_udp_ep_t remote;
     gcoap_request_memo_t *memo = NULL;
 
+    (void)arg;
     if (type & SOCK_ASYNC_MSG_RECV) {
         ssize_t res = sock_udp_recv(sock, _listen_buf, sizeof(_listen_buf),
                                     0, &remote);

sys/net/gnrc/sock/gnrc_sock.c

@@ -58,7 +58,7 @@ static void _netapi_cb(uint16_t cmd, gnrc_pktsnip_t *pkt, void *ctx)
                         (void *)&reg->mbox);
         }
         if (reg->async_cb.generic) {
-            reg->async_cb.generic(reg, SOCK_ASYNC_MSG_RECV);
+            reg->async_cb.generic(reg, SOCK_ASYNC_MSG_RECV, reg->async_cb_arg);
         }
     }
 }

sys/net/gnrc/sock/include/sock_types.h

@@ -55,7 +55,8 @@ typedef struct gnrc_sock_reg gnrc_sock_reg_t;
  * @internal
  */
 typedef void (*gnrc_sock_reg_cb_t)(gnrc_sock_reg_t *sock,
-                                   sock_async_flags_t flags);
+                                   sock_async_flags_t flags,
+                                   void *arg);
 #endif  /* SOCK_HAS_ASYNC */
 
 /**
@@ -86,6 +87,7 @@ struct gnrc_sock_reg {
         sock_udp_cb_t udp;              /**< UDP version */
 #endif
     } async_cb;
+    void *async_cb_arg;                 /**< asynchronous callback argument */
 #ifdef SOCK_HAS_ASYNC_CTX
     sock_async_ctx_t async_ctx;         /**< asynchronous event context */
 #endif

sys/net/gnrc/sock/ip/gnrc_sock_ip.c

@@ -197,15 +197,17 @@ ssize_t sock_ip_send(sock_ip_t *sock, const void *data, size_t len,
     }
 #ifdef SOCK_HAS_ASYNC
     if ((sock != NULL) && (sock->reg.async_cb.ip)) {
-        sock->reg.async_cb.ip(sock, SOCK_ASYNC_MSG_SENT);
+        sock->reg.async_cb.ip(sock, SOCK_ASYNC_MSG_SENT,
+                              sock->reg.async_cb_arg);
     }
 #endif  /* SOCK_HAS_ASYNC */
     return res;
 }
 
 #ifdef SOCK_HAS_ASYNC
-void sock_ip_set_cb(sock_ip_t *sock, sock_ip_cb_t cb)
+void sock_ip_set_cb(sock_ip_t *sock, sock_ip_cb_t cb, void *arg)
 {
+    sock->reg.async_cb_arg = arg;
     sock->reg.async_cb.ip = cb;
 }
 

sys/net/gnrc/sock/udp/gnrc_sock_udp.c

@@ -319,15 +319,17 @@ ssize_t sock_udp_send(sock_udp_t *sock, const void *data, size_t len,
     }
 #ifdef SOCK_HAS_ASYNC
     if ((sock != NULL) && (sock->reg.async_cb.udp)) {
-        sock->reg.async_cb.udp(sock, SOCK_ASYNC_MSG_SENT);
+        sock->reg.async_cb.udp(sock, SOCK_ASYNC_MSG_SENT,
+                               sock->reg.async_cb_arg);
     }
 #endif  /* SOCK_HAS_ASYNC */
     return res;
 }
 
 #ifdef SOCK_HAS_ASYNC
-void sock_udp_set_cb(sock_udp_t *sock, sock_udp_cb_t cb)
+void sock_udp_set_cb(sock_udp_t *sock, sock_udp_cb_t cb, void *arg)
 {
+    sock->reg.async_cb_arg = arg;
     sock->reg.async_cb.udp = cb;
 }
 

sys/net/sock/async/event/sock_async_ctx.h

@@ -28,7 +28,10 @@ extern "C" {
  * @brief   Generalized callback type
  */
 typedef union {
-    void (*generic)(void *, sock_async_flags_t);    /**< anything goes */
+    /**
+     * @brief   anything goes
+     */
+    void (*generic)(void *, sock_async_flags_t, void *);
 #ifdef MODULE_SOCK_DTLS
     sock_dtls_cb_t dtls;                            /**< DTLS callback */
 #endif
@@ -51,6 +54,7 @@ typedef struct {
     event_t super;              /**< event structure that gets extended */
     sock_event_cb_t cb;         /**< callback */
     void *sock;                 /**< generic pointer to a @ref net_sock object */
+    void *cb_arg;               /**< callback argument */
     sock_async_flags_t type;    /**< types of the event */
 } sock_event_t;
 

sys/net/sock/async/event/sock_async_event.c

@@ -25,14 +25,15 @@ static void _event_handler(event_t *ev)
     event->type = 0;
     irq_restore(state);
     if (_type) {
-        event->cb.generic(event->sock, _type);
+        event->cb.generic(event->sock, _type, event->cb_arg);
     }
 }
 
-static inline void _cb(void *sock, sock_async_flags_t type,
+static inline void _cb(void *sock, sock_async_flags_t type, void *arg,
                        sock_async_ctx_t *ctx)
 {
     ctx->event.sock = sock;
+    ctx->event.cb_arg = arg;
     ctx->event.type |= type;
     event_post(ctx->queue, &ctx->event.super);
 }
@@ -46,86 +47,86 @@ static void _set_ctx(sock_async_ctx_t *ctx, event_queue_t *ev_queue)
 }
 
 #ifdef MODULE_SOCK_DTLS
-static void _dtls_cb(sock_dtls_t *sock, sock_async_flags_t type)
+static void _dtls_cb(sock_dtls_t *sock, sock_async_flags_t type, void *arg)
 {
-    _cb(sock, type, sock_dtls_get_async_ctx(sock));
+    _cb(sock, type, arg, sock_dtls_get_async_ctx(sock));
 }
 
 void sock_dtls_event_init(sock_dtls_t *sock, event_queue_t *ev_queue,
-                         sock_dtls_cb_t handler)
+                         sock_dtls_cb_t handler, void *handler_arg)
 {
     sock_async_ctx_t *ctx = sock_dtls_get_async_ctx(sock);
 
     _set_ctx(ctx, ev_queue);
     ctx->event.cb.dtls = handler;
-    sock_dtls_set_cb(sock, _dtls_cb);
+    sock_dtls_set_cb(sock, _dtls_cb, handler_arg);
 }
 #endif /* MODULE_SOCK_DTLS */
 
 #ifdef MODULE_SOCK_IP
-static void _ip_cb(sock_ip_t *sock, sock_async_flags_t type)
+static void _ip_cb(sock_ip_t *sock, sock_async_flags_t type, void *arg)
 {
-    _cb(sock, type, sock_ip_get_async_ctx(sock));
+    _cb(sock, type, arg, sock_ip_get_async_ctx(sock));
 }
 
 void sock_ip_event_init(sock_ip_t *sock, event_queue_t *ev_queue,
-                        sock_ip_cb_t handler)
+                        sock_ip_cb_t handler, void *handler_arg)
 {
     sock_async_ctx_t *ctx = sock_ip_get_async_ctx(sock);
 
     _set_ctx(ctx, ev_queue);
     ctx->event.cb.ip = handler;
-    sock_ip_set_cb(sock, _ip_cb);
+    sock_ip_set_cb(sock, _ip_cb, handler_arg);
 }
 #endif  /* MODULE_SOCK_IP */
 
 #ifdef MODULE_SOCK_TCP
-static void _tcp_cb(sock_tcp_t *sock, sock_async_flags_t type)
+static void _tcp_cb(sock_tcp_t *sock, sock_async_flags_t type, void *arg)
 {
-    _cb(sock, type, sock_tcp_get_async_ctx(sock));
+    _cb(sock, type, arg, sock_tcp_get_async_ctx(sock));
 }
 
 void sock_tcp_event_init(sock_tcp_t *sock, event_queue_t *ev_queue,
-                         sock_tcp_cb_t handler)
+                         sock_tcp_cb_t handler, void *handler_arg)
 {
     sock_async_ctx_t *ctx = sock_tcp_get_async_ctx(sock);
 
     _set_ctx(ctx, ev_queue);
     ctx->event.cb.tcp = handler;
-    sock_tcp_set_cb(sock, _tcp_cb);
+    sock_tcp_set_cb(sock, _tcp_cb, handler_arg);
 }
 
-static void _tcp_queue_cb(sock_tcp_queue_t *queue, sock_async_flags_t type)
+static void _tcp_queue_cb(sock_tcp_queue_t *queue, sock_async_flags_t type,
+                          void *arg)
 {
-    _cb(queue, type, sock_tcp_queue_get_async_ctx(queue));
+    _cb(queue, type, arg, sock_tcp_queue_get_async_ctx(queue));
 }
 
-void sock_tcp_queue_event_init(sock_tcp_queue_t *queue,
+void sock_tcp_queue_event_init(sock_tcp_queue_t *queue, event_queue_t *ev_queue,
-                               event_queue_t *ev_queue,
+                               sock_tcp_queue_cb_t handler, void *handler_arg)
-                               sock_tcp_queue_cb_t handler)
 {
     sock_async_ctx_t *ctx = sock_tcp_queue_get_async_ctx(queue);
 
     _set_ctx(ctx, ev_queue);
     ctx->event.cb.tcp_queue = handler;
-    sock_tcp_queue_set_cb(queue, _tcp_queue_cb);
+    sock_tcp_queue_set_cb(queue, _tcp_queue_cb, handler_arg);
 }
 #endif /* MODULE_SOCK_TCP */
 
 #ifdef MODULE_SOCK_UDP
-static void _udp_cb(sock_udp_t *sock, sock_async_flags_t type)
+static void _udp_cb(sock_udp_t *sock, sock_async_flags_t type, void *arg)
 {
-    _cb(sock, type, sock_udp_get_async_ctx(sock));
+    _cb(sock, type, arg, sock_udp_get_async_ctx(sock));
 }
 
 void sock_udp_event_init(sock_udp_t *sock, event_queue_t *ev_queue,
-                         sock_udp_cb_t handler)
+                         sock_udp_cb_t handler, void *handler_arg)
 {
     sock_async_ctx_t *ctx = sock_udp_get_async_ctx(sock);
 
     _set_ctx(ctx, ev_queue);
     ctx->event.cb.udp = handler;
-    sock_udp_set_cb(sock, _udp_cb);
+    sock_udp_set_cb(sock, _udp_cb, handler_arg);
 }
 #endif /* MODULE_SOCK_UDP */
 

tests/gnrc_sock_async_event/main.c

@@ -69,8 +69,9 @@ ipv6_hdr_t *gnrc_ipv6_get_header(gnrc_pktsnip_t *pkt)
     return ((ipv6_hdr_t*) tmp->data);
 }
 
-static void _recv_udp(sock_udp_t *sock, sock_async_flags_t flags)
+static void _recv_udp(sock_udp_t *sock, sock_async_flags_t flags, void *arg)
 {
+    assert(strcmp(arg, "test") == 0);
     printf("UDP event triggered: %04X\n", flags);
     if (flags & SOCK_ASYNC_MSG_RECV) {
         sock_udp_ep_t remote;
@@ -90,8 +91,9 @@ static void _recv_udp(sock_udp_t *sock, sock_async_flags_t flags)
     }
 }
 
-static void _recv_ip(sock_ip_t *sock, sock_async_flags_t flags)
+static void _recv_ip(sock_ip_t *sock, sock_async_flags_t flags, void *arg)
 {
+    assert(strcmp(arg, "test") == 0);
     printf("IP event triggered: %04X\n", flags);
     if (flags & SOCK_ASYNC_MSG_RECV) {
         sock_ip_ep_t remote;
@@ -126,8 +128,8 @@ int main(void)
     sock_udp_create(&_udp_sock, &local, NULL, 0);
     sock_ip_create(&_ip_sock, (sock_ip_ep_t *)&local, NULL, PROTNUM_UDP, 0);
 
-    sock_udp_event_init(&_udp_sock, &_ev_queue, _recv_udp);
+    sock_udp_event_init(&_udp_sock, &_ev_queue, _recv_udp, "test");
-    sock_ip_event_init(&_ip_sock, &_ev_queue, _recv_ip);
+    sock_ip_event_init(&_ip_sock, &_ev_queue, _recv_ip, "test");
     memcpy(remote.addr.ipv6, _test_remote, sizeof(_test_remote));
     remote.port = TEST_PORT - 1;
 

tests/lwip/ip.c

@@ -44,8 +44,9 @@ static sock_ip_t server_sock;
 static char server_stack[THREAD_STACKSIZE_DEFAULT];
 static msg_t server_msg_queue[SERVER_MSG_QUEUE_SIZE];
 
-static void _ip_recv(sock_ip_t *sock, sock_async_flags_t flags)
+static void _ip_recv(sock_ip_t *sock, sock_async_flags_t flags, void *arg)
 {
+    assert(strcmp(arg, "test") == 0);
     if (flags & SOCK_ASYNC_MSG_RECV) {
         sock_ip_ep_t src;
         int res;
@@ -89,7 +90,7 @@ static void *_server_thread(void *args)
     server_running = true;
     printf("Success: started IP server on protocol %u\n", protocol);
     event_queue_init(&queue);
-    sock_ip_event_init(&server_sock, &queue, _ip_recv);
+    sock_ip_event_init(&server_sock, &queue, _ip_recv, "test");
     event_loop(&queue);
     return NULL;
 }

tests/lwip/tcp.c

@@ -47,10 +47,11 @@ static msg_t server_msg_queue[SERVER_MSG_QUEUE_SIZE];
 static char _addr_str[IPV6_ADDR_MAX_STR_LEN];
 static event_queue_t _ev_queue;
 
-static void _tcp_recv(sock_tcp_t *sock, sock_async_flags_t flags)
+static void _tcp_recv(sock_tcp_t *sock, sock_async_flags_t flags, void *arg)
 {
     sock_tcp_ep_t client;
 
+    assert(strcmp(arg, "test") == 0);
     if (sock_tcp_get_remote(sock, &client) < 0) {
         /* socket was disconnected between event firing and this handler */
         return;
@@ -85,8 +86,10 @@ static void _tcp_recv(sock_tcp_t *sock, sock_async_flags_t flags)
     }
 }
 
-static void _tcp_accept(sock_tcp_queue_t *queue, sock_async_flags_t flags)
+static void _tcp_accept(sock_tcp_queue_t *queue, sock_async_flags_t flags,
+                        void *arg)
 {
+    assert(strcmp(arg, "test") == 0);
     if (flags & SOCK_ASYNC_CONN_RECV) {
         sock_tcp_t *sock = NULL;
         int res;
@@ -97,7 +100,7 @@ static void _tcp_accept(sock_tcp_queue_t *queue, sock_async_flags_t flags)
         else {
             sock_tcp_ep_t client;
 
-            sock_tcp_event_init(sock, &_ev_queue, _tcp_recv);
+            sock_tcp_event_init(sock, &_ev_queue, _tcp_recv, "test");
             sock_tcp_get_remote(sock, &client);
 #ifdef MODULE_LWIP_IPV6
             ipv6_addr_to_str(_addr_str, (ipv6_addr_t *)&client.addr.ipv6,
@@ -129,7 +132,7 @@ static void *_server_thread(void *args)
     printf("Success: started TCP server on port %" PRIu16 "\n",
            server_addr.port);
     event_queue_init(&_ev_queue);
-    sock_tcp_queue_event_init(&server_queue, &_ev_queue, _tcp_accept);
+    sock_tcp_queue_event_init(&server_queue, &_ev_queue, _tcp_accept, "test");
     event_loop(&_ev_queue);
     return NULL;
 }

tests/lwip/udp.c

@@ -44,8 +44,9 @@ static sock_udp_t server_sock;
 static char server_stack[THREAD_STACKSIZE_DEFAULT];
 static msg_t server_msg_queue[SERVER_MSG_QUEUE_SIZE];
 
-static void _udp_recv(sock_udp_t *sock, sock_async_flags_t flags)
+static void _udp_recv(sock_udp_t *sock, sock_async_flags_t flags, void *arg)
 {
+    assert(strcmp(arg, "test") == 0);
     if (flags & SOCK_ASYNC_MSG_RECV) {
         sock_udp_ep_t src;
         int res;
@@ -92,7 +93,7 @@ static void *_server_thread(void *args)
     printf("Success: started UDP server on port %" PRIu16 "\n",
            server_addr.port);
     event_queue_init(&queue);
-    sock_udp_event_init(&server_sock, &queue, _udp_recv);
+    sock_udp_event_init(&server_sock, &queue, _udp_recv, "test");
     event_loop(&queue);
     return NULL;
 }