OrgApache/incubator-nuttx
OrgApache
/
incubator-nuttx
mirror of https://github.com/apache/incubator-nuttx.git
1
0
Fork 0
Code Issues Releases Wiki Activity
incubator-nuttx/drivers/usrsock/usrsock_rpmsg_server.c

1307 lines
40 KiB
C
Raw Blame History

/****************************************************************************
* drivers/usrsock/usrsock_rpmsg_server.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <debug.h>
#include <errno.h>
#include <inttypes.h>
#include <poll.h>
#include <string.h>
#include <sys/ioctl.h>
#include <nuttx/kmalloc.h>
#include <nuttx/mutex.h>
#include <nuttx/net/dns.h>
#include <nuttx/net/net.h>
#include <nuttx/queue.h>
#include <nuttx/rptun/openamp.h>
#include <nuttx/usrsock/usrsock_rpmsg.h>
#ifdef CONFIG_NETDEV_WIRELESS_IOCTL
#include <nuttx/wireless/wireless.h>
#endif
/****************************************************************************
* Private Types
****************************************************************************/
struct usrsock_rpmsg_s
{
rmutex_t mutex;
struct socket socks[CONFIG_NET_USRSOCK_RPMSG_SERVER_NSOCKS];
FAR struct rpmsg_endpoint *epts[CONFIG_NET_USRSOCK_RPMSG_SERVER_NSOCKS];
struct pollfd pfds[CONFIG_NET_USRSOCK_RPMSG_SERVER_NSOCKS];
};
/* Saving rpmsg requests to keep message order. */
struct usrsock_rpmsg_req_s
{
sq_entry_t flink;
FAR void *data;
size_t len;
uint32_t src;
};
struct usrsock_rpmsg_ept_s
{
struct rpmsg_endpoint ept;
/* For sendto/recvfrom */
struct iovec iov[CONFIG_NET_USRSOCK_RPMSG_SERVER_NIOVEC];
ssize_t remain;
/* For keeping msg order, normally nIOVec is the max request we can get */
bool inuse;
sq_queue_t req_free;
sq_queue_t req_pending;
struct usrsock_rpmsg_req_s reqs[CONFIG_NET_USRSOCK_RPMSG_SERVER_NIOVEC];
};
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
static bool usrsock_rpmsg_available(FAR struct socket *psock, int cmd);
static int usrsock_rpmsg_send_ack(FAR struct rpmsg_endpoint *ept,
uint16_t events,
uint32_t xid, int32_t result);
static int usrsock_rpmsg_send_data_ack(FAR struct rpmsg_endpoint *ept,
FAR struct usrsock_message_datareq_ack_s *ack,
uint16_t events,
uint32_t xid, int32_t result,
uint16_t valuelen,
uint16_t valuelen_nontrunc,
int32_t datalen);
static int usrsock_rpmsg_send_event(FAR struct rpmsg_endpoint *ept,
int16_t usockid, uint16_t events);
static int usrsock_rpmsg_socket_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv_);
static int usrsock_rpmsg_close_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv_);
static int usrsock_rpmsg_connect_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv_);
static int usrsock_rpmsg_sendto_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv_);
static int usrsock_rpmsg_recvfrom_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv_);
static int usrsock_rpmsg_setsockopt_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv_);
static int usrsock_rpmsg_getsockopt_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv_);
static int usrsock_rpmsg_getsockname_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv_);
static int usrsock_rpmsg_getpeername_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv_);
static int usrsock_rpmsg_bind_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv_);
static int usrsock_rpmsg_listen_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv_);
static int usrsock_rpmsg_accept_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv_);
static int usrsock_rpmsg_ioctl_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv_);
static int usrsock_rpmsg_shutdown_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv_);
static int usrsock_rpmsg_dns_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv_);
static bool usrsock_rpmsg_ns_match(FAR struct rpmsg_device *rdev,
FAR void *priv_, FAR const char *name,
uint32_t dest);
static void usrsock_rpmsg_ns_bind(FAR struct rpmsg_device *rdev,
FAR void *priv_, FAR const char *name,
uint32_t dest);
static void usrsock_rpmsg_ns_unbind(FAR struct rpmsg_endpoint *ept);
static int usrsock_rpmsg_ept_cb(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len, uint32_t src,
FAR void *priv);
static void usrsock_rpmsg_poll_cb(FAR struct pollfd *pfds);
static void usrsock_rpmsg_poll_setup(FAR struct pollfd *pfds,
pollevent_t events);
/****************************************************************************
* Private Data
****************************************************************************/
static const rpmsg_ept_cb g_usrsock_rpmsg_handler[] =
{
usrsock_rpmsg_socket_handler,
usrsock_rpmsg_close_handler,
usrsock_rpmsg_connect_handler,
usrsock_rpmsg_sendto_handler,
usrsock_rpmsg_recvfrom_handler,
usrsock_rpmsg_setsockopt_handler,
usrsock_rpmsg_getsockopt_handler,
usrsock_rpmsg_getsockname_handler,
usrsock_rpmsg_getpeername_handler,
usrsock_rpmsg_bind_handler,
usrsock_rpmsg_listen_handler,
usrsock_rpmsg_accept_handler,
usrsock_rpmsg_ioctl_handler,
usrsock_rpmsg_shutdown_handler,
usrsock_rpmsg_dns_handler,
};
/****************************************************************************
* Private Functions
****************************************************************************/
static bool usrsock_rpmsg_available(FAR struct socket *psock, int cmd)
{
int len;
if (psock_ioctl(psock, cmd, &len, sizeof(len)) == 0)
{
if (len > 0)
{
return true;
}
}
return false;
}
static int usrsock_rpmsg_send_ack(FAR struct rpmsg_endpoint *ept,
uint16_t events,
uint32_t xid, int32_t result)
{
struct usrsock_message_req_ack_s ack;
ack.head.msgid = USRSOCK_MESSAGE_RESPONSE_ACK;
ack.head.flags = (result == -EINPROGRESS);
ack.head.events = events;
ack.xid = xid;
ack.result = result == -EINPROGRESS ? 0 : result;
return rpmsg_send(ept, &ack, sizeof(ack));
}
static int usrsock_rpmsg_send_data_ack(FAR struct rpmsg_endpoint *ept,
FAR struct usrsock_message_datareq_ack_s *ack,
uint16_t events,
uint32_t xid, int32_t result,
uint16_t valuelen,
uint16_t valuelen_nontrunc,
int32_t datalen)
{
ack->reqack.head.msgid = USRSOCK_MESSAGE_RESPONSE_DATA_ACK;
ack->reqack.head.flags = 0;
ack->reqack.head.events = events;
ack->reqack.xid = xid;
ack->reqack.result = result;
if (result < 0)
{
valuelen = 0;
valuelen_nontrunc = 0;
datalen = 0;
}
else if (valuelen > valuelen_nontrunc)
{
valuelen = valuelen_nontrunc;
}
ack->valuelen = valuelen;
ack->valuelen_nontrunc = valuelen_nontrunc;
return rpmsg_send_nocopy(ept, ack, sizeof(*ack) + valuelen + datalen);
}
static int usrsock_rpmsg_send_frag_ack(FAR struct rpmsg_endpoint *ept,
FAR struct usrsock_message_frag_ack_s *ack,
uint16_t events,
uint32_t xid, int32_t result,
uint32_t datalen)
{
ack->reqack.head.msgid = USRSOCK_RPMSG_FRAG_RESPONSE;
ack->reqack.head.flags = 0;
ack->reqack.head.events = events;
ack->reqack.xid = xid;
ack->reqack.result = result;
ack->datalen = datalen;
return rpmsg_send_nocopy(ept, ack, sizeof(*ack) + datalen);
}
static int usrsock_rpmsg_send_event(FAR struct rpmsg_endpoint *ept,
int16_t usockid, uint16_t events)
{
struct usrsock_message_socket_event_s event;
event.head.msgid = USRSOCK_MESSAGE_SOCKET_EVENT;
event.head.flags = USRSOCK_MESSAGE_FLAG_EVENT;
event.head.events = events;
event.usockid = usockid;
return rpmsg_send(ept, &event, sizeof(event));
}
static int usrsock_rpmsg_socket_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv_)
{
FAR struct usrsock_request_socket_s *req = data;
FAR struct usrsock_rpmsg_s *priv = priv_;
uint16_t events = 0;
int ret = -ENFILE;
int retr;
int i;
nxrmutex_lock(&priv->mutex);
for (i = 0; i < CONFIG_NET_USRSOCK_RPMSG_SERVER_NSOCKS; i++)
{
if (priv->epts[i] == NULL)
{
priv->epts[i] = ept;
nxrmutex_unlock(&priv->mutex);
ret = psock_socket(req->domain, req->type | SOCK_NONBLOCK,
req->protocol, &priv->socks[i]);
if (ret >= 0)
{
ret = i; /* Return index as the usockid */
if (req->type != SOCK_STREAM && req->type != SOCK_SEQPACKET)
{
events = USRSOCK_EVENT_SENDTO_READY;
}
}
else
{
priv->epts[i] = NULL;
}
break;
}
}
if (i == CONFIG_NET_USRSOCK_RPMSG_SERVER_NSOCKS)
{
nxrmutex_unlock(&priv->mutex);
}
retr = usrsock_rpmsg_send_ack(ept, events, req->head.xid, ret);
if (retr >= 0 && ret >= 0 &&
req->type != SOCK_STREAM && req->type != SOCK_SEQPACKET)
{
usrsock_rpmsg_poll_setup(&priv->pfds[ret], POLLIN);
}
return retr;
}
static int usrsock_rpmsg_close_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv_)
{
FAR struct usrsock_request_close_s *req = data;
FAR struct usrsock_rpmsg_s *priv = priv_;
int ret = -EBADF;
if (req->usockid >= 0 &&
req->usockid < CONFIG_NET_USRSOCK_RPMSG_SERVER_NSOCKS)
{
usrsock_rpmsg_poll_setup(&priv->pfds[req->usockid], 0);
/* It's safe to close sock here */
ret = psock_close(&priv->socks[req->usockid]);
nxrmutex_lock(&priv->mutex);
priv->epts[req->usockid] = NULL;
nxrmutex_unlock(&priv->mutex);
}
return usrsock_rpmsg_send_ack(ept, 0, req->head.xid, ret);
}
static int usrsock_rpmsg_connect_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv_)
{
FAR struct usrsock_request_connect_s *req = data;
FAR struct usrsock_rpmsg_s *priv = priv_;
bool inprogress = false;
int ret = -EBADF;
int retr;
if (req->usockid >= 0 &&
req->usockid < CONFIG_NET_USRSOCK_RPMSG_SERVER_NSOCKS)
{
ret = psock_connect(&priv->socks[req->usockid],
(FAR const struct sockaddr *)(req + 1), req->addrlen);
}
retr = usrsock_rpmsg_send_ack(ept, 0, req->head.xid, ret);
if (ret == -EINPROGRESS)
{
inprogress = true;
ret = 0;
}
if (retr >= 0 && ret >= 0)
{
pollevent_t events = POLLIN;
if (inprogress)
{
events |= POLLOUT;
}
usrsock_rpmsg_poll_setup(&priv->pfds[req->usockid], events);
if (!inprogress)
{
retr = usrsock_rpmsg_send_event(ept, req->usockid,
USRSOCK_EVENT_SENDTO_READY);
}
}
return retr;
}
static int usrsock_rpmsg_sendto_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv_)
{
FAR struct usrsock_request_sendto_s *req;
FAR struct usrsock_rpmsg_ept_s *uept =
(FAR struct usrsock_rpmsg_ept_s *)ept;
FAR struct usrsock_rpmsg_s *priv = priv_;
uint16_t events = 0;
ssize_t ret = -EBADF;
int retr;
int i;
if (uept->remain > 0)
{
size_t hlen;
struct msghdr msg =
{
};
uept->remain -= len;
if (!uept->iov[0].iov_base)
{
/* Maybe error occurred previously, skip processing. */
return 0;
}
req = uept->iov[0].iov_base;
hlen = sizeof(*req) + req->addrlen;
for (i = 0; i < CONFIG_NET_USRSOCK_RPMSG_SERVER_NIOVEC; i++)
{
if (!uept->iov[i].iov_base)
{
uept->iov[i].iov_base = data;
uept->iov[i].iov_len = len;
rpmsg_hold_rx_buffer(ept, data);
break;
}
}
/* Partial packet ? continue to fetch */
if (uept->remain > 0)
{
/* We've used the last I/O vector, cannot continue. */
if (i == CONFIG_NET_USRSOCK_RPMSG_SERVER_NIOVEC - 1)
{
nerr("ERROR: Request %d too large!\n", req->usockid);
ret = -ENOMEM;
goto out;
}
return 0;
}
else if (uept->remain < 0)
{
ret = -EINVAL;
goto out;
}
/* Skip the sendto header from I/O vector */
uept->iov[0].iov_base = (FAR char *)uept->iov[0].iov_base + hlen;
uept->iov[0].iov_len -= hlen;
msg.msg_name = req->addrlen ? (FAR void *)(req + 1) : NULL;
msg.msg_namelen = req->addrlen;
msg.msg_iov = uept->iov;
msg.msg_iovlen = i + 1;
ret = psock_sendmsg(&priv->socks[req->usockid], &msg, req->flags);
/* Recover the I/O vector */
uept->iov[0].iov_base = (FAR char *)uept->iov[0].iov_base - hlen;
uept->iov[0].iov_len += hlen;
}
else
{
req = data;
if (req->usockid >= 0 &&
req->usockid < CONFIG_NET_USRSOCK_RPMSG_SERVER_NSOCKS)
{
uept->remain = sizeof(*req) + req->addrlen + req->buflen - len;
if (uept->remain > 0)
{
#if CONFIG_NET_USRSOCK_RPMSG_SERVER_NIOVEC >= 2
uept->iov[0].iov_base = data;
uept->iov[0].iov_len = len;
rpmsg_hold_rx_buffer(ept, data);
return 0;
#else
ret = -ENOMEM;
#endif
}
else
{
ret = psock_sendto(&priv->socks[req->usockid],
(FAR const void *)(req + 1) + req->addrlen, req->buflen,
req->flags,
req->addrlen ?
(FAR const struct sockaddr *)(req + 1) : NULL,
req->addrlen);
}
}
}
out:
if (ret > 0 &&
usrsock_rpmsg_available(&priv->socks[req->usockid], FIONSPACE))
{
events |= USRSOCK_EVENT_SENDTO_READY;
}
retr = usrsock_rpmsg_send_ack(ept, events, req->head.xid, ret);
if (retr >= 0 && (ret > 0 || ret == -EAGAIN) && events == 0)
{
usrsock_rpmsg_poll_setup(&priv->pfds[req->usockid],
priv->pfds[req->usockid].events | POLLOUT);
}
if (uept->iov[0].iov_base)
{
for (i = 0; i < CONFIG_NET_USRSOCK_RPMSG_SERVER_NIOVEC; i++)
{
if (uept->iov[i].iov_base == NULL)
{
break;
}
rpmsg_release_rx_buffer(ept, uept->iov[i].iov_base);
uept->iov[i].iov_base = NULL;
uept->iov[i].iov_len = 0;
}
}
return retr;
}
static int usrsock_rpmsg_recvfrom_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len_,
uint32_t src, FAR void *priv_)
{
struct iovec iov[CONFIG_NET_USRSOCK_RPMSG_SERVER_NIOVEC];
FAR struct usrsock_request_recvfrom_s *req = data;
FAR struct usrsock_message_datareq_ack_s *ack;
FAR struct usrsock_rpmsg_s *priv = priv_;
socklen_t outaddrlen = req->max_addrlen;
socklen_t inaddrlen = req->max_addrlen;
size_t buflen = req->max_buflen;
size_t totlen = 0;
ssize_t ret = -EBADF;
uint32_t len = buflen;
uint16_t events = 0;
uint8_t i = 0;
int retr;
ack = rpmsg_get_tx_payload_buffer(ept, &len, true);
if (sizeof(*ack) + inaddrlen + buflen < len)
{
len = sizeof(*ack) + inaddrlen + buflen;
}
memset(iov, 0, sizeof(iov));
if (req->usockid >= 0 &&
req->usockid < CONFIG_NET_USRSOCK_RPMSG_SERVER_NSOCKS)
{
ret = psock_recvfrom(&priv->socks[req->usockid],
(FAR void *)(ack + 1) + inaddrlen,
len - sizeof(*ack) - inaddrlen,
req->flags,
outaddrlen ? (FAR struct sockaddr *)(ack + 1) : NULL,
outaddrlen ? &outaddrlen : NULL);
totlen = ret;
if (ret > 0 && (priv->socks[req->usockid].s_type & SOCK_TYPE_MASK) ==
SOCK_STREAM)
{
if (outaddrlen < inaddrlen)
{
memcpy((FAR void *)(ack + 1) + outaddrlen,
(FAR void *)(ack + 1) + inaddrlen, ret);
}
/* Hold net_lock to combine get_tx_payload and recvfrom together.
* Otherwise we may keep holding tx buffer when waiting net_lock in
* recvfrom, which may block rpmsg and may cause dead lock if
* another thread tries to get tx buffer with net_lock held.
*/
net_lock();
while (totlen < buflen &&
i < CONFIG_NET_USRSOCK_RPMSG_SERVER_NIOVEC)
{
uint32_t offset = sizeof(struct usrsock_message_frag_ack_s);
if (!usrsock_rpmsg_available(&priv->socks[req->usockid],
FIONREAD))
{
break;
}
iov[i].iov_base = rpmsg_get_tx_payload_buffer(ept,
&len,
false);
if (!iov[i].iov_base)
{
break;
}
DEBUGASSERT(len > offset);
if (buflen - totlen < len - offset)
{
len = buflen - totlen + offset;
}
/* Should never wait */
iov[i].iov_len =
psock_recvfrom(&priv->socks[req->usockid],
(FAR char *)iov[i].iov_base + offset,
len - offset,
req->flags | MSG_DONTWAIT,
NULL, NULL);
if ((ssize_t)iov[i].iov_len > 0)
{
totlen += iov[i].iov_len;
if (iov[i].iov_len < len - offset)
{
break;
}
}
else
{
iov[i].iov_len = 0;
break;
}
i++;
}
if (usrsock_rpmsg_available(&priv->socks[req->usockid], FIONREAD))
{
events |= USRSOCK_EVENT_RECVFROM_AVAIL;
}
net_unlock();
}
}
retr = usrsock_rpmsg_send_data_ack(ept,
ack, events, req->head.xid,
totlen, inaddrlen, outaddrlen,
ret);
for (i = 0; i < CONFIG_NET_USRSOCK_RPMSG_SERVER_NIOVEC; i++)
{
if (!iov[i].iov_base)
{
break;
}
if (!iov[i].iov_len || retr <= 0)
{
rpmsg_release_tx_buffer(ept, iov[i].iov_base);
iov[i].iov_base = NULL;
continue;
}
usrsock_rpmsg_send_frag_ack(ept,
(FAR struct usrsock_message_frag_ack_s *)iov[i].iov_base,
events, req->head.xid, totlen, iov[i].iov_len);
}
if (retr >= 0 && (ret > 0 || ret == -EAGAIN) && events == 0)
{
usrsock_rpmsg_poll_setup(&priv->pfds[req->usockid],
priv->pfds[req->usockid].events | POLLIN);
}
return retr;
}
static int usrsock_rpmsg_setsockopt_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv_)
{
FAR struct usrsock_request_setsockopt_s *req = data;
FAR struct usrsock_rpmsg_s *priv = priv_;
int ret = -EBADF;
if (req->usockid >= 0 &&
req->usockid < CONFIG_NET_USRSOCK_RPMSG_SERVER_NSOCKS)
{
ret = psock_setsockopt(&priv->socks[req->usockid],
req->level, req->option, req + 1, req->valuelen);
}
return usrsock_rpmsg_send_ack(ept, 0, req->head.xid, ret);
}
static int usrsock_rpmsg_getsockopt_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len_,
uint32_t src, FAR void *priv_)
{
FAR struct usrsock_request_getsockopt_s *req = data;
FAR struct usrsock_message_datareq_ack_s *ack;
FAR struct usrsock_rpmsg_s *priv = priv_;
socklen_t optlen = req->max_valuelen;
int ret = -EBADF;
uint32_t len;
ack = rpmsg_get_tx_payload_buffer(ept, &len, true);
if (req->usockid >= 0 &&
req->usockid < CONFIG_NET_USRSOCK_RPMSG_SERVER_NSOCKS)
{
ret = psock_getsockopt(&priv->socks[req->usockid],
req->level, req->option, ack + 1, &optlen);
}
return usrsock_rpmsg_send_data_ack(ept,
ack, 0, req->head.xid, ret, optlen, optlen, ret);
}
static int usrsock_rpmsg_getsockname_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len_,
uint32_t src, FAR void *priv_)
{
FAR struct usrsock_request_getsockname_s *req = data;
FAR struct usrsock_message_datareq_ack_s *ack;
FAR struct usrsock_rpmsg_s *priv = priv_;
socklen_t outaddrlen = req->max_addrlen;
socklen_t inaddrlen = req->max_addrlen;
int ret = -EBADF;
uint32_t len;
ack = rpmsg_get_tx_payload_buffer(ept, &len, true);
if (req->usockid >= 0 &&
req->usockid < CONFIG_NET_USRSOCK_RPMSG_SERVER_NSOCKS)
{
ret = psock_getsockname(&priv->socks[req->usockid],
(FAR struct sockaddr *)(ack + 1), &outaddrlen);
}
return usrsock_rpmsg_send_data_ack(ept,
ack, 0, req->head.xid, ret, inaddrlen, outaddrlen, ret);
}
static int usrsock_rpmsg_getpeername_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len_,
uint32_t src, FAR void *priv_)
{
FAR struct usrsock_request_getpeername_s *req = data;
FAR struct usrsock_message_datareq_ack_s *ack;
FAR struct usrsock_rpmsg_s *priv = priv_;
socklen_t outaddrlen = req->max_addrlen;
socklen_t inaddrlen = req->max_addrlen;
int ret = -EBADF;
uint32_t len;
ack = rpmsg_get_tx_payload_buffer(ept, &len, true);
if (req->usockid >= 0 &&
req->usockid < CONFIG_NET_USRSOCK_RPMSG_SERVER_NSOCKS)
{
ret = psock_getpeername(&priv->socks[req->usockid],
(FAR struct sockaddr *)(ack + 1), &outaddrlen);
}
return usrsock_rpmsg_send_data_ack(ept,
ack, 0, req->head.xid, ret, inaddrlen, outaddrlen, ret);
}
static int usrsock_rpmsg_bind_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv_)
{
FAR struct usrsock_request_bind_s *req = data;
FAR struct usrsock_rpmsg_s *priv = priv_;
int ret = -EBADF;
if (req->usockid >= 0 &&
req->usockid < CONFIG_NET_USRSOCK_RPMSG_SERVER_NSOCKS)
{
ret = psock_bind(&priv->socks[req->usockid],
(FAR const struct sockaddr *)(req + 1), req->addrlen);
}
return usrsock_rpmsg_send_ack(ept, 0, req->head.xid, ret);
}
static int usrsock_rpmsg_listen_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv_)
{
FAR struct usrsock_request_listen_s *req = data;
FAR struct usrsock_rpmsg_s *priv = priv_;
int ret = -EBADF;
int retr;
if (req->usockid >= 0 &&
req->usockid < CONFIG_NET_USRSOCK_RPMSG_SERVER_NSOCKS)
{
ret = psock_listen(&priv->socks[req->usockid], req->backlog);
}
retr = usrsock_rpmsg_send_ack(ept, 0, req->head.xid, ret);
if (retr >= 0 && ret >= 0)
{
usrsock_rpmsg_poll_setup(&priv->pfds[req->usockid], POLLIN);
}
return retr;
}
static int usrsock_rpmsg_accept_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len_,
uint32_t src, FAR void *priv_)
{
FAR struct usrsock_request_accept_s *req = data;
FAR struct usrsock_message_datareq_ack_s *ack;
FAR struct usrsock_rpmsg_s *priv = priv_;
socklen_t outaddrlen = req->max_addrlen;
socklen_t inaddrlen = req->max_addrlen;
uint32_t len;
int ret = -EBADF;
int i = 0;
int retr;
ack = rpmsg_get_tx_payload_buffer(ept, &len, true);
if (req->usockid >= 0 &&
req->usockid < CONFIG_NET_USRSOCK_RPMSG_SERVER_NSOCKS)
{
ret = -ENFILE; /* Assume no free socket handler */
nxrmutex_lock(&priv->mutex);
for (i = 0; i < CONFIG_NET_USRSOCK_RPMSG_SERVER_NSOCKS; i++)
{
if (priv->epts[i] == NULL)
{
priv->epts[i] = ept;
nxrmutex_unlock(&priv->mutex);
ret = psock_accept(&priv->socks[req->usockid],
outaddrlen ? (FAR struct sockaddr *)(ack + 1) : NULL,
outaddrlen ? &outaddrlen : NULL, &priv->socks[i],
SOCK_NONBLOCK);
if (ret >= 0)
{
/* Append index as usockid to the payload */
if (outaddrlen <= inaddrlen)
{
*(FAR int16_t *)
((FAR void *)(ack + 1) + outaddrlen) = i;
}
else
{
*(FAR int16_t *)
((FAR void *)(ack + 1) + inaddrlen) = i;
}
ret = sizeof(int16_t); /* Return usockid size */
}
else
{
priv->epts[i] = NULL;
}
break;
}
}
if (i == CONFIG_NET_USRSOCK_RPMSG_SERVER_NSOCKS)
{
nxrmutex_unlock(&priv->mutex);
}
}
retr = usrsock_rpmsg_send_data_ack(ept,
ack, 0, req->head.xid, ret, inaddrlen, outaddrlen, ret);
if (retr >= 0 && ret >= 0)
{
usrsock_rpmsg_poll_setup(&priv->pfds[req->usockid], POLLIN);
usrsock_rpmsg_poll_setup(&priv->pfds[i], POLLIN);
usrsock_rpmsg_send_event(ept, i, USRSOCK_EVENT_SENDTO_READY);
}
return retr;
}
static int usrsock_rpmsg_ioctl_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len_,
uint32_t src, FAR void *priv_)
{
FAR struct usrsock_request_ioctl_s *req = data;
FAR struct usrsock_message_datareq_ack_s *ack;
FAR struct usrsock_rpmsg_s *priv = priv_;
#ifdef CONFIG_NETDEV_WIRELESS_IOCTL
FAR struct iwreq *wlreq;
FAR struct iwreq *wlack;
#endif
int ret = -EBADF;
uint32_t len;
ack = rpmsg_get_tx_payload_buffer(ept, &len, true);
if (req->usockid >= 0 &&
req->usockid < CONFIG_NET_USRSOCK_RPMSG_SERVER_NSOCKS)
{
memcpy(ack + 1, req + 1, len_ - sizeof(*req));
#ifdef CONFIG_NETDEV_WIRELESS_IOCTL
wlreq = (FAR struct iwreq *)(req + 1);
wlack = (FAR struct iwreq *)(ack + 1);
if (WL_IS80211POINTERCMD(req->cmd) && wlreq->u.data.pointer)
{
wlack->u.data.pointer = wlack + 1;
}
#endif
ret = psock_ioctl(&priv->socks[req->usockid],
req->cmd, (unsigned long)(ack + 1));
#ifdef CONFIG_NETDEV_WIRELESS_IOCTL
if (WL_IS80211POINTERCMD(req->cmd) && wlreq->u.data.pointer)
{
if (ret >= 0)
{
ret = wlreq->u.data.length;
}
wlack->u.data.pointer = wlreq->u.data.pointer;
}
#endif
}
return usrsock_rpmsg_send_data_ack(ept,
ack, 0, req->head.xid, ret, req->arglen, req->arglen, ret);
}
static int usrsock_rpmsg_shutdown_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv_)
{
FAR struct usrsock_request_shutdown_s *req = data;
FAR struct usrsock_rpmsg_s *priv = priv_;
int ret = -EBADF;
if (req->usockid >= 0 &&
req->usockid < CONFIG_NET_USRSOCK_RPMSG_SERVER_NSOCKS)
{
ret = psock_shutdown(&priv->socks[req->usockid], req->how);
}
return usrsock_rpmsg_send_ack(ept, 0, req->head.xid, ret);
}
static int usrsock_rpmsg_dns_handler(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len,
uint32_t src, FAR void *priv_)
{
#ifdef CONFIG_NETDB_DNSCLIENT
FAR struct usrsock_rpmsg_dns_request_s *dns = data;
dns_add_nameserver((FAR struct sockaddr *)(dns + 1), dns->addrlen);
#endif
return 0;
}
#ifdef CONFIG_NETDB_DNSCLIENT
static int usrsock_rpmsg_send_dns_event(FAR void *arg,
FAR struct sockaddr *addr,
socklen_t addrlen)
{
FAR struct rpmsg_endpoint *ept = arg;
FAR struct usrsock_rpmsg_dns_event_s *dns;
uint32_t len;
dns = rpmsg_get_tx_payload_buffer(ept, &len, true);
if (dns == NULL)
{
return -ENOMEM;
}
dns->head.msgid = USRSOCK_RPMSG_DNS_EVENT;
dns->head.flags = USRSOCK_MESSAGE_FLAG_EVENT;
dns->addrlen = addrlen;
memcpy(dns + 1, addr, addrlen);
return rpmsg_send_nocopy(ept, dns, sizeof(*dns) + addrlen);
}
#endif
static bool usrsock_rpmsg_ns_match(FAR struct rpmsg_device *rdev,
FAR void *priv_, FAR const char *name,
uint32_t dest)
{
return !strcmp(name, USRSOCK_RPMSG_EPT_NAME);
}
static void usrsock_rpmsg_ns_bind(FAR struct rpmsg_device *rdev,
FAR void *priv_, FAR const char *name,
uint32_t dest)
{
FAR struct usrsock_rpmsg_s *priv = priv_;
FAR struct usrsock_rpmsg_ept_s *uept;
int ret;
int i;
uept = kmm_zalloc(sizeof(*uept));
if (!uept)
{
return;
}
uept->ept.priv = priv;
for (i = 0; i < CONFIG_NET_USRSOCK_RPMSG_SERVER_NIOVEC; i++)
{
sq_addlast(&uept->reqs[i].flink, &uept->req_free);
}
ret = rpmsg_create_ept(&uept->ept, rdev, USRSOCK_RPMSG_EPT_NAME,
RPMSG_ADDR_ANY, dest,
usrsock_rpmsg_ept_cb, usrsock_rpmsg_ns_unbind);
if (ret < 0)
{
kmm_free(uept);
return;
}
#ifdef CONFIG_NETDB_DNSCLIENT
dns_register_notify(usrsock_rpmsg_send_dns_event, &uept->ept);
#endif
}
static void usrsock_rpmsg_ns_unbind(FAR struct rpmsg_endpoint *ept)
{
FAR struct usrsock_rpmsg_s *priv = ept->priv;
int i;
#ifdef CONFIG_NETDB_DNSCLIENT
dns_unregister_notify(usrsock_rpmsg_send_dns_event, ept);
#endif
/* Collect all socks belong to the dead client */
for (i = 0; i < CONFIG_NET_USRSOCK_RPMSG_SERVER_NSOCKS; i++)
{
if (priv->epts[i] == ept)
{
usrsock_rpmsg_poll_setup(&priv->pfds[i], 0);
/* It's safe to close socks here */
psock_close(&priv->socks[i]);
nxrmutex_lock(&priv->mutex);
priv->epts[i] = NULL;
nxrmutex_unlock(&priv->mutex);
}
}
rpmsg_destroy_ept(ept);
kmm_free(ept);
}
static int usrsock_rpmsg_ept_do_cb(FAR struct usrsock_rpmsg_ept_s *uept,
FAR void *data, size_t len, uint32_t src,
FAR struct usrsock_rpmsg_s *priv)
{
FAR struct usrsock_request_common_s *common = data;
if (uept->remain > 0)
{
return usrsock_rpmsg_sendto_handler(&uept->ept, data, len, src, priv);
}
else if (common->reqid >= 0 && common->reqid <= USRSOCK_REQUEST__MAX)
{
return g_usrsock_rpmsg_handler[common->reqid](&uept->ept, data, len,
src, priv);
}
return -EINVAL;
}
static int usrsock_rpmsg_ept_cb(FAR struct rpmsg_endpoint *ept,
FAR void *data, size_t len, uint32_t src,
FAR void *priv_)
{
FAR struct usrsock_rpmsg_s *priv = priv_;
FAR struct usrsock_rpmsg_ept_s *uept =
(FAR struct usrsock_rpmsg_ept_s *)ept;
FAR struct usrsock_rpmsg_req_s *req;
int ret;
/* This callback is called from only one thread per ept, so don't need any
* lock for `inuse` state.
*/
if (uept->inuse)
{
/* Avoid recursive call. */
req = (FAR struct usrsock_rpmsg_req_s *)sq_remfirst(&uept->req_free);
if (req == NULL)
{
return -ENOMEM;
}
req->data = data;
req->len = len;
req->src = src;
sq_addlast(&req->flink, &uept->req_pending);
rpmsg_hold_rx_buffer(ept, data);
return OK;
}
uept->inuse = true;
ret = usrsock_rpmsg_ept_do_cb(uept, data, len, src, priv);
/* Pop pending requests to proceed. */
while ((req = (FAR struct usrsock_rpmsg_req_s *)
sq_remfirst(&uept->req_pending)) != NULL)
{
data = req->data;
len = req->len;
src = req->src;
sq_addlast(&req->flink, &uept->req_free);
ret = usrsock_rpmsg_ept_do_cb(uept, data, len, src, priv);
if (ret < 0)
{
nerr("ERROR: usrsock got error %d!", ret);
}
rpmsg_release_rx_buffer(ept, data);
}
uept->inuse = false;
return ret;
}
static void usrsock_rpmsg_poll_setup(FAR struct pollfd *pfds,
pollevent_t events)
{
FAR struct usrsock_rpmsg_s *priv = (FAR struct usrsock_rpmsg_s *)pfds->arg;
FAR struct socket *psock = &priv->socks[pfds->fd];
int ret = 0;
/* No poll for SOCK_CTRL. */
if (psock->s_type == SOCK_CTRL)
{
return;
}
net_lock();
if (events)
{
if (pfds->events)
{
ret = psock_poll(psock, pfds, false);
}
if (ret >= 0)
{
/* The protocol stack monitor flag is different when the events is
* POLLIN or POLLOUT, so we have to call poll_setup again.
*/
pfds->revents = 0;
pfds->events = events;
ret = psock_poll(psock, pfds, true);
}
}
else
{
pfds->revents = 0;
pfds->events = 0;
ret = psock_poll(psock, pfds, false);
}
if (ret < 0)
{
nerr("psock_poll failed. ret %d domain %u type %u pfds->fd %d"
", pfds->events %08" PRIx32 ", pfds->revents %08" PRIx32,
ret, psock->s_domain, psock->s_type, pfds->fd,
pfds->events, pfds->revents);
}
net_unlock();
}
static void usrsock_rpmsg_poll_cb(FAR struct pollfd *pfds)
{
FAR struct usrsock_rpmsg_s *priv = (FAR struct usrsock_rpmsg_s *)pfds->arg;
int oldevents;
int events = 0;
nxrmutex_lock(&priv->mutex);
if (!priv->epts[pfds->fd])
{
nxrmutex_unlock(&priv->mutex);
return;
}
oldevents = pfds->events;
if (pfds->revents & POLLIN)
{
events |= USRSOCK_EVENT_RECVFROM_AVAIL;
/* Stop poll in until recv get called */
pfds->events &= ~POLLIN;
pfds->revents &= ~POLLIN;
}
if (pfds->revents & POLLOUT)
{
events |= USRSOCK_EVENT_SENDTO_READY;
/* Stop poll out until send get called */
pfds->events &= ~POLLOUT;
pfds->revents &= ~POLLOUT;
}
if (pfds->revents & (POLLHUP | POLLERR))
{
events |= USRSOCK_EVENT_REMOTE_CLOSED;
/* Check data that has not been recv */
if (usrsock_rpmsg_available(&priv->socks[pfds->fd], FIONREAD))
{
events |= USRSOCK_EVENT_RECVFROM_AVAIL;
}
/* Clear revents */
pfds->revents &= ~(POLLHUP | POLLERR);
}
if (oldevents != pfds->events)
{
usrsock_rpmsg_poll_setup(pfds, pfds->events);
}
if (events != 0)
{
usrsock_rpmsg_send_event(priv->epts[pfds->fd], pfds->fd, events);
}
nxrmutex_unlock(&priv->mutex);
}
/****************************************************************************
* Public Functions
****************************************************************************/
int usrsock_rpmsg_server_initialize(void)
{
FAR struct usrsock_rpmsg_s *priv;
int ret;
int i;
priv = kmm_calloc(1, sizeof(*priv));
if (priv == NULL)
{
return -ENOMEM;
}
nxrmutex_init(&priv->mutex);
/* Setup poll callback settings */
for (i = 0; i < CONFIG_NET_USRSOCK_RPMSG_SERVER_NSOCKS; i++)
{
priv->pfds[i].fd = i;
priv->pfds[i].arg = priv;
priv->pfds[i].cb = usrsock_rpmsg_poll_cb;
}
ret = rpmsg_register_callback(priv,
NULL,
NULL,
usrsock_rpmsg_ns_match,
usrsock_rpmsg_ns_bind);
if (ret >= 0)
{
return ret;
}
nxrmutex_destroy(&priv->mutex);
kmm_free(priv);
return ret;
}
Reference in New Issue View Git Blame Copy Permalink