nrf_modem_lib: add support for SO_SENDCB

Added support for SO_SENDCB in the socket offloading layer. This socket
option supported by the modem firmware mfw_nrf9151-ntn allows the user
to set a callback function that will be called when a send operation is
done sending data on air.
In order to map the nRF socket descriptor received from the modem to the
appropriate ZVFS descriptor, the latter is now also stored in the offload
socket context.

Signed-off-by: Kacper Radoszewski <[email protected]>

Author: kacperradoszewski

lib/nrf_modem_lib/nrf9x_sockets.c

@@ -48,9 +48,11 @@
 
 /* Offloading context related to nRF socket. */
 static struct nrf_sock_ctx {
-	int nrf_fd; /* nRF socket descriptior. */
+	int nrf_fd; /* nRF socket descriptor. */
+	int zvfs_fd; /* ZVFS socket descriptor. */
 	struct k_mutex *lock; /* Mutex associated with the socket. */
 	struct k_poll_signal poll; /* poll() signal. */
+	struct socket_ncs_sendcb sendcb; /* Send callback. */
 } offload_ctx[NRF_MODEM_MAX_SOCKET_COUNT];
 
 static K_MUTEX_DEFINE(ctx_lock);
@@ -62,7 +64,7 @@ static bool offload_disabled;
 /* TLS offloading disabled only. */
 static bool tls_offload_disabled;
 
-static struct nrf_sock_ctx *allocate_ctx(int nrf_fd)
+static struct nrf_sock_ctx *allocate_ctx(int nrf_fd, int zvfs_fd)
 {
 	struct nrf_sock_ctx *ctx = NULL;
 
@@ -72,6 +74,7 @@ static struct nrf_sock_ctx *allocate_ctx(int nrf_fd)
 		if (offload_ctx[i].nrf_fd == -1) {
 			ctx = &offload_ctx[i];
 			ctx->nrf_fd = nrf_fd;
+			ctx->zvfs_fd = zvfs_fd;
 			break;
 		}
 	}
@@ -87,10 +90,23 @@ static void release_ctx(struct nrf_sock_ctx *ctx)
 
 	ctx->nrf_fd = -1;
 	ctx->lock = NULL;
+	ctx->zvfs_fd = -1;
+	memset(&ctx->sendcb, 0, sizeof(ctx->sendcb));
 
 	k_mutex_unlock(&ctx_lock);
 }
 
+static struct nrf_sock_ctx *find_ctx(int fd)
+{
+	for (size_t i = 0; i < ARRAY_SIZE(offload_ctx); i++) {
+		if (offload_ctx[i].nrf_fd == fd) {
+			return &offload_ctx[i];
+		}
+	}
+
+	return NULL;
+}
+
 static void z_to_nrf_ipv4(const struct sockaddr *z_in,
 			  struct nrf_sockaddr_in *nrf_out)
 {
@@ -219,6 +235,9 @@ static int z_to_nrf_optname(int z_in_level, int z_in_optname,
 		case SO_RAI:
 			*nrf_out_optname = NRF_SO_RAI;
 			break;
+		case SO_SENDCB:
+			*nrf_out_optname = NRF_SO_SENDCB;
+			break;
 		default:
 			retval = -1;
 			break;
@@ -377,7 +396,7 @@ static int nrf9x_socket_offload_accept(void *obj, struct sockaddr *addr,
 		goto error;
 	}
 
-	ctx = allocate_ctx(new_sd);
+	ctx = allocate_ctx(new_sd, fd);
 	if (ctx == NULL) {
 		errno = ENOMEM;
 		goto error;
@@ -475,16 +494,40 @@ static int nrf9x_socket_offload_connect(void *obj, const struct sockaddr *addr,
 	return retval;
 }
 
+static void sendcb(const struct nrf_modem_sendcb_params *nrf_params)
+{
+	struct nrf_sock_ctx *ctx;
+	struct socket_ncs_sendcb_params params;
+
+	ctx = find_ctx(nrf_params->fd);
+	if (!ctx || !ctx->sendcb.callback) {
+		return;
+	}
+
+	/* The user is interested in the zvfs_fd, not nrf_fd. */
+	params.fd = ctx->zvfs_fd;
+	params.bytes_sent = nrf_params->bytes_sent;
+	params.status = (nrf_params->status == 0) ? 0 : EAGAIN;
+
+	/* User callback. */
+	ctx->sendcb.callback(&params);
+}
+
 static int nrf9x_socket_offload_setsockopt(void *obj, int level, int optname,
 					   const void *optval, socklen_t optlen)
 {
-	int sd = OBJ_TO_SD(obj);
+
+	struct nrf_sock_ctx *ctx = OBJ_TO_CTX(obj);
+	int sd = ctx->nrf_fd;
 	int retval;
 	int nrf_level = level;
 	int nrf_optname;
 	struct nrf_timeval nrf_timeo = { 0 };
 	void *nrf_optval = (void *)optval;
 	nrf_socklen_t nrf_optlen = optlen;
+	static struct nrf_modem_sendcb offload_sendcb = {
+		.callback = sendcb,
+	};
 
 	if ((level == SOL_SOCKET) && (optname == SO_BINDTODEVICE)) {
 		if (IS_ENABLED(CONFIG_NET_SOCKETS_OFFLOAD_DISPATCHER)) {
@@ -513,6 +556,15 @@ static int nrf9x_socket_offload_setsockopt(void *obj, int level, int optname,
 		}
 	} else if ((level == SOL_TLS) && (optname == TLS_SESSION_CACHE)) {
 		nrf_optlen = sizeof(int);
+	} else if ((level == SOL_SOCKET) && (optname == SO_SENDCB)) {
+		/* Register the user callback in the socket context. */
+		if (optval != NULL) {
+			ctx->sendcb = *(struct socket_ncs_sendcb *)optval;
+			nrf_optval = &offload_sendcb;
+			nrf_optlen = sizeof(struct socket_ncs_sendcb);
+		} else {
+			memset(&ctx->sendcb, 0, sizeof(ctx->sendcb));
+		}
 	}
 
 	retval = nrf_setsockopt(sd, nrf_level, nrf_optname, nrf_optval,
@@ -857,17 +909,6 @@ static int nrf9x_socket_offload_fcntl(int fd, int cmd, va_list args)
 	return retval;
 }
 
-static struct nrf_sock_ctx *find_ctx(int fd)
-{
-	for (size_t i = 0; i < ARRAY_SIZE(offload_ctx); i++) {
-		if (offload_ctx[i].nrf_fd == fd) {
-			return &offload_ctx[i];
-		}
-	}
-
-	return NULL;
-}
-
 static void pollcb(struct nrf_pollfd *pollfd)
 {
 	struct nrf_sock_ctx *ctx;
@@ -1095,7 +1136,7 @@ static int nrf9x_socket_create(int family, int type, int proto)
 		return -1;
 	}
 
-	ctx = allocate_ctx(sd);
+	ctx = allocate_ctx(sd, fd);
 	if (ctx == NULL) {
 		errno = ENOMEM;
 		nrf_close(sd);

tests/lib/nrf_modem_lib/nrf9x_sockets/src/nrf9x_sockets_test.c

@@ -1781,6 +1781,93 @@ void test_nrf9x_socket_offload_poll(void)
 	TEST_ASSERT_EQUAL(ret, 0);
 }
 
+static struct nrf_modem_sendcb *nrf_sendcb;
+static int sendcb_calls;
+static struct nrf_modem_sendcb_params nrf_sendcb_params = { .fd = NRF_FD };
+
+static void sendcb(const struct socket_ncs_sendcb_params *params)
+{
+	sendcb_calls++;
+}
+
+static int stub_nrf_setsockopt_sendcb(int fd, int level, int opt, const void *val, size_t len,
+				      int cmock_calls)
+{
+	TEST_ASSERT_EQUAL(NRF_FD, fd);
+	TEST_ASSERT_EQUAL(NRF_SOL_SOCKET, level);
+	TEST_ASSERT_EQUAL(NRF_SO_SENDCB, opt);
+	if (len > 0) {
+		TEST_ASSERT_EQUAL(sizeof(struct nrf_modem_sendcb), len);
+	} else {
+		TEST_ASSERT_EQUAL(0, len);
+	}
+	/* Store the nRF send callback (which wraps the user callback) */
+	nrf_sendcb = (struct nrf_modem_sendcb *)val;
+	return 0;
+}
+
+static int stub_nrf_sendto_sendcb(int socket, const void *message, size_t length, int flags,
+				  const struct nrf_sockaddr *dest_addr, nrf_socklen_t dest_len,
+				  int cmock_calls)
+{
+	/* No need to verify parameters, simply call the nRF send callback, if there is one. */
+	if (nrf_sendcb && nrf_sendcb->callback) {
+		nrf_sendcb->callback(&nrf_sendcb_params);
+	}
+
+	return length;
+}
+
+void test_nrf9x_socket_offload_sendcb(void)
+{
+	int ret;
+	int fd;
+	int nrf_fd = NRF_FD;
+	int family = AF_INET6;
+	int type = SOCK_STREAM;
+	int proto = IPPROTO_TCP;
+	struct socket_ncs_sendcb sendcb_opt_val = { .callback = sendcb };
+	uint8_t data[8] = { 1 };
+	size_t data_len = sizeof(data);
+	int flags = ZSOCK_MSG_DONTWAIT;
+	struct sockaddr to = { .sa_family = family };
+
+	__cmock_nrf_socket_ExpectAndReturn(NRF_AF_INET6, NRF_SOCK_STREAM, NRF_IPPROTO_TCP, nrf_fd);
+
+	fd = zsock_socket(family, type, proto);
+	TEST_ASSERT_EQUAL(0, fd);
+
+	__cmock_nrf_setsockopt_Stub(stub_nrf_setsockopt_sendcb);
+
+	/* Set a send callback. */
+
+	ret = zsock_setsockopt(fd, SOL_SOCKET, SO_SENDCB, &sendcb_opt_val, sizeof(sendcb_opt_val));
+	TEST_ASSERT_EQUAL(0, ret);
+
+	/* Skip zsock_connect, etc. since for testing we just need a working zsock_socket */
+
+	__cmock_nrf_sendto_Stub(stub_nrf_sendto_sendcb);
+
+	/* Send and confirm that the registered callback is called. */
+
+	ret = zsock_sendto(fd, data, data_len, flags, &to, 42);
+	TEST_ASSERT_EQUAL(8, ret);
+	TEST_ASSERT_EQUAL(1, sendcb_calls);
+
+	__cmock_nrf_setsockopt_Stub(stub_nrf_setsockopt_sendcb);
+
+	/* Unset the send callback. */
+
+	ret = zsock_setsockopt(fd, SOL_SOCKET, SO_SENDCB, NULL, 0);
+	TEST_ASSERT_EQUAL(0, ret);
+
+	/* Send and confirm that the callback is no longer called. */
+
+	ret = zsock_sendto(fd, data, data_len, flags, &to, 42);
+	TEST_ASSERT_EQUAL(8, ret);
+	TEST_ASSERT_EQUAL(1, sendcb_calls);
+}
+
 /* It is required to be added to each test. That is because unity's
  * main may return nonzero, while zephyr's main currently must
  * return 0 in all cases (other values are reserved).