diff --git a/include/nuttx/net/net.h b/include/nuttx/net/net.h index 92d09a2623..6d343cfd5f 100644 --- a/include/nuttx/net/net.h +++ b/include/nuttx/net/net.h @@ -102,12 +102,15 @@ struct socket; /* Forward reference */ struct sock_intf_s { - CODE int (*si_setup)(FAR struct socket *psock, int protocol); + CODE int (*si_setup)(FAR struct socket *psock, int protocol); CODE ssize_t (*si_send)(FAR struct socket *psock, FAR const void *buf, - size_t len, int flags); + size_t len, int flags); CODE ssize_t (*si_sendto)(FAR struct socket *psock, FAR const void *buf, - size_t len, int flags, FAR const struct sockaddr *to, - socklen_t tolen); + size_t len, int flags, FAR const struct sockaddr *to, + socklen_t tolen); + CODE ssize_t (*si_recvfrom)(FAR struct socket *psock, FAR void *buf, + size_t len, int flags, FAR struct sockaddr *from, + FAR socklen_t *fromlen); }; /* This is the internal representation of a socket reference by a file diff --git a/net/local/local.h b/net/local/local.h index 222d846cc0..2233b2c8df 100644 --- a/net/local/local.h +++ b/net/local/local.h @@ -428,7 +428,7 @@ ssize_t psock_local_sendto(FAR struct socket *psock, FAR const void *buf, int local_send_packet(int fd, FAR const uint8_t *buf, size_t len); /**************************************************************************** - * Name: psock_recvfrom + * Name: local_recvfrom * * Description: * recvfrom() receives messages from a local socket, and may be used to @@ -455,9 +455,9 @@ int local_send_packet(int fd, FAR const uint8_t *buf, size_t len); * ****************************************************************************/ -ssize_t psock_local_recvfrom(FAR struct socket *psock, FAR void *buf, - size_t len, int flags, FAR struct sockaddr *from, - FAR socklen_t *fromlen); +ssize_t local_recvfrom(FAR struct socket *psock, FAR void *buf, + size_t len, int flags, FAR struct sockaddr *from, + FAR socklen_t *fromlen); /**************************************************************************** * Name: local_fifo_read diff --git a/net/local/local_recvfrom.c b/net/local/local_recvfrom.c index a19d5323b3..f9de54d6d1 100644 --- a/net/local/local_recvfrom.c +++ b/net/local/local_recvfrom.c @@ -387,11 +387,11 @@ errout_with_halfduplex: ****************************************************************************/ /**************************************************************************** - * Name: psock_local_recvfrom + * Name: local_recvfrom * * Description: - * psock_local_recvfrom() receives messages from a local socket and may be - * used to receive data on a socket whether or not it is connection-oriented. + * local_recvfrom() receives messages from a local socket and may be used + * to receive data on a socket whether or not it is connection-oriented. * * If from is not NULL, and the underlying protocol provides the source * address, this source address is filled in. The argument fromlen @@ -409,14 +409,15 @@ errout_with_halfduplex: * Returned Value: * On success, returns the number of characters received. If no data is * available to be received and the peer has performed an orderly shutdown, - * recv() will return 0. Otherwise, on errors, -1 is returned, and errno - * is set appropriately (see receive from for the complete list). + * recv() will return 0. Otherwise, on errors, a negated errno value is + * returned (see recv_from() for the complete list of appropriate error + * values). * ****************************************************************************/ -ssize_t psock_local_recvfrom(FAR struct socket *psock, FAR void *buf, - size_t len, int flags, FAR struct sockaddr *from, - FAR socklen_t *fromlen) +ssize_t local_recvfrom(FAR struct socket *psock, FAR void *buf, + size_t len, int flags, FAR struct sockaddr *from, + FAR socklen_t *fromlen) { DEBUGASSERT(psock && psock->s_conn && buf); diff --git a/net/local/local_sockif.c b/net/local/local_sockif.c index c7e9c1ba54..0baeab57e2 100644 --- a/net/local/local_sockif.c +++ b/net/local/local_sockif.c @@ -70,9 +70,10 @@ static ssize_t local_sendto(FAR struct socket *psock, FAR const void *buf, const struct sock_intf_s g_local_sockif = { - local_setup, /* si_setup */ - local_send, /* si_send */ - local_sendto, /* si_sendto */ + local_setup, /* si_setup */ + local_send, /* si_send */ + local_sendto, /* si_sendto */ + local_recvfrom /* si_recvfrom */ }; /**************************************************************************** @@ -183,9 +184,9 @@ static int local_setup(FAR struct socket *psock, int protocol) * flags Send flags * * Returned Value: - * On success, returns the number of characters sent. On error, -1 is - * returned, and errno is set appropriately (see send() for the list of - * appropriate errors values. + * On success, returns the number of characters sent. On error, a negated + * errno value is returned (see send() for the list of appropriate error + * values. * ****************************************************************************/ @@ -245,9 +246,9 @@ static ssize_t local_send(FAR struct socket *psock, FAR const void *buf, * tolen The length of the address structure * * Returned Value: - * On success, returns the number of characters sent. On error, -1 is - * returned, and errno is set appropriately (see send_to() for the list of - * appropriate errors values. + * On success, returns the number of characters sent. On error, a negated + * errno value is returned (see send_to() for the list of appropriate error + * values. * ****************************************************************************/ diff --git a/net/pkt/Make.defs b/net/pkt/Make.defs index f3e97740ba..1258385334 100644 --- a/net/pkt/Make.defs +++ b/net/pkt/Make.defs @@ -41,6 +41,7 @@ ifeq ($(CONFIG_NET_PKT),y) SOCK_CSRCS += pkt_sockif.c SOCK_CSRCS += pkt_send.c +SOCK_CSRCS += pkt_recvfrom.c # Transport layer diff --git a/net/pkt/pkt.h b/net/pkt/pkt.h index 041246b2fc..61dee0929a 100644 --- a/net/pkt/pkt.h +++ b/net/pkt/pkt.h @@ -101,6 +101,7 @@ EXTERN const struct sock_intf_s g_pkt_sockif; struct net_driver_s; /* Forward reference */ struct eth_hdr_s; /* Forward reference */ +struct socket; /* Forward reference */ /**************************************************************************** * Name: pkt_initialize() @@ -201,6 +202,41 @@ uint16_t pkt_callback(FAR struct net_driver_s *dev, /* pkt_input() is prototyped in include/nuttx/net/pkt.h */ +/**************************************************************************** + * Name: pkt_recvfrom + * + * Description: + * Implements the socket recvfrom interface for the case of the AF_INET + * and AF_INET6 address families. pkt_recvfrom() receives messages from + * a socket, and may be used to receive data on a socket whether or not it + * is connection-oriented. + * + * If 'from' is not NULL, and the underlying protocol provides the source + * address, this source address is filled in. The argument 'fromlen' is + * initialized to the size of the buffer associated with from, and + * modified on return to indicate the actual size of the address stored + * there. + * + * Parameters: + * psock A pointer to a NuttX-specific, internal socket structure + * buf Buffer to receive data + * len Length of buffer + * flags Receive flags + * from Address of source (may be NULL) + * fromlen The length of the address structure + * + * Returned Value: + * On success, returns the number of characters received. If no data is + * available to be received and the peer has performed an orderly shutdown, + * recv() will return 0. Otherwise, on errors, a negated errno value is + * returned (see recvfrom() for the list of appropriate error values). + * + ****************************************************************************/ + +ssize_t pkt_recvfrom(FAR struct socket *psock, FAR void *buf, size_t len, + int flags, FAR struct sockaddr *from, + FAR socklen_t *fromlen); + /**************************************************************************** * Name: pkt_find_device * diff --git a/net/pkt/pkt_recvfrom.c b/net/pkt/pkt_recvfrom.c new file mode 100644 index 0000000000..d4348f31b4 --- /dev/null +++ b/net/pkt/pkt_recvfrom.c @@ -0,0 +1,485 @@ +/**************************************************************************** + * net/socket/pkt_recvfrom.c + * + * Copyright (C) 2007-2009, 2011-2017 Gregory Nutt. All rights reserved. + * Author: Gregory Nutt + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * 3. Neither the name NuttX nor the names of its contributors may be + * used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + ****************************************************************************/ + +/**************************************************************************** + * Included Files + ****************************************************************************/ + +#include + +#ifdef CONFIG_NET + +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include +#include + +#include "netdev/netdev.h" +#include "devif/devif.h" +#include "pkt/pkt.h" +#include "socket/socket.h" +#include + +/**************************************************************************** + * Private Types + ****************************************************************************/ + +struct pkt_recvfrom_s +{ + FAR struct devif_callback_s *pr_cb; /* Reference to callback instance */ + sem_t pr_sem; /* Semaphore signals recv completion */ + size_t pr_buflen; /* Length of receive buffer */ + uint8_t *pr_buffer; /* Pointer to receive buffer */ + ssize_t pr_recvlen; /* The received length */ + int pr_result; /* Success:OK, failure:negated errno */ +}; + +/**************************************************************************** + * Private Functions + ****************************************************************************/ + +/**************************************************************************** + * Name: pkt_add_recvlen + * + * Description: + * Update information about space available for new data and update size + * of data in buffer, This logic accounts for the case where + * recvfrom_udpreadahead() sets state.pr_recvlen == -1 . + * + * Parameters: + * pstate recvfrom state structure + * recvlen size of new data appended to buffer + * + * Returned Value: + * None + * + ****************************************************************************/ + +static inline void pkt_add_recvlen(FAR struct pkt_recvfrom_s *pstate, + size_t recvlen) +{ + if (pstate->pr_recvlen < 0) + { + pstate->pr_recvlen = 0; + } + + pstate->pr_recvlen += recvlen; + pstate->pr_buffer += recvlen; + pstate->pr_buflen -= recvlen; +} + +/**************************************************************************** + * Name: pkt_recvfrom_newdata + * + * Description: + * Copy the read data from the packet + * + * Parameters: + * dev The structure of the network driver that caused the interrupt + * pstate recvfrom state structure + * + * Returned Value: + * None. + * + * Assumptions: + * The network is locked. + * + ****************************************************************************/ + +static void pkt_recvfrom_newdata(FAR struct net_driver_s *dev, + FAR struct pkt_recvfrom_s *pstate) +{ + size_t recvlen; + + if (dev->d_len > pstate->pr_buflen) + { + recvlen = pstate->pr_buflen; + } + else + { + recvlen = dev->d_len; + } + + /* Copy the new packet data into the user buffer */ + + memcpy(pstate->pr_buffer, dev->d_buf, recvlen); + ninfo("Received %d bytes (of %d)\n", (int)recvlen, (int)dev->d_len); + + /* Update the accumulated size of the data read */ + + pkt_add_recvlen(pstate, recvlen); +} + +/**************************************************************************** + * Name: pkt_recvfrom_sender + * + * Description: + * + * Parameters: + * + * Returned Values: + * + * Assumptions: + * + ****************************************************************************/ + +static inline void pkt_recvfrom_sender(FAR struct net_driver_s *dev, + FAR struct pkt_recvfrom_s *pstate) +{ +} + +/**************************************************************************** + * Name: pkt_recvfrom_interrupt + * + * Description: + * + * Parameters: + * + * Returned Values: + * + * Assumptions: + * + ****************************************************************************/ + +static uint16_t pkt_recvfrom_interrupt(FAR struct net_driver_s *dev, + FAR void *pvconn, FAR void *pvpriv, + uint16_t flags) +{ + struct pkt_recvfrom_s *pstate = (struct pkt_recvfrom_s *)pvpriv; + + ninfo("flags: %04x\n", flags); + + /* 'priv' might be null in some race conditions (?) */ + + if (pstate) + { + /* If a new packet is available, then complete the read action. */ + + if ((flags & PKT_NEWDATA) != 0) + { + /* Copy the packet */ + + pkt_recvfrom_newdata(dev, pstate); + + /* We are finished. */ + + ninfo("PKT done\n"); + + /* Don't allow any further call backs. */ + + pstate->pr_cb->flags = 0; + pstate->pr_cb->priv = NULL; + pstate->pr_cb->event = NULL; +#if 0 + /* Save the sender's address in the caller's 'from' location */ + + pkt_recvfrom_sender(dev, pstate); +#endif + /* indicate that the data has been consumed */ + + flags &= ~PKT_NEWDATA; + + /* Wake up the waiting thread, returning the number of bytes + * actually read. + */ + + sem_post(&pstate->pr_sem); + } + } + + return flags; +} + +/**************************************************************************** + * Name: pkt_recvfrom_initialize + * + * Description: + * Initialize the state structure + * + * Parameters: + * psock Pointer to the socket structure for the socket + * buf Buffer to receive data + * len Length of buffer + * pstate A pointer to the state structure to be initialized + * + * Returned Value: + * None + * + * Assumptions: + * + ****************************************************************************/ + +static void pkt_recvfrom_initialize(FAR struct socket *psock, FAR void *buf, + size_t len, FAR struct sockaddr *infrom, + FAR socklen_t *fromlen, + FAR struct pkt_recvfrom_s *pstate) +{ + /* Initialize the state structure. */ + + memset(pstate, 0, sizeof(struct pkt_recvfrom_s)); + + /* This semaphore is used for signaling and, hence, should not have + * priority inheritance enabled. + */ + + (void)sem_init(&pstate->pr_sem, 0, 0); /* Doesn't really fail */ + (void)sem_setprotocol(&pstate->pr_sem, SEM_PRIO_NONE); + + pstate->pr_buflen = len; + pstate->pr_buffer = buf; +} + +/* The only un-initialization that has to be performed is destroying the + * semaphore. + */ + +#define pkt_recvfrom_uninitialize(s) sem_destroy(&(s)->pr_sem) + +/**************************************************************************** + * Name: pkt_recvfrom_result + * + * Description: + * Evaluate the result of the recv operations + * + * Parameters: + * result The result of the net_lockedwait operation (may indicate EINTR) + * pstate A pointer to the state structure to be initialized + * + * Returned Value: + * The result of the recv operation with errno set appropriately + * + * Assumptions: + * + ****************************************************************************/ + +static ssize_t pkt_recvfrom_result(int result, struct pkt_recvfrom_s *pstate) +{ + int save_errno = get_errno(); /* In case something we do changes it */ + + /* Check for a error/timeout detected by the interrupt handler. Errors are + * signaled by negative errno values for the rcv length + */ + + if (pstate->pr_result < 0) + { + /* This might return EAGAIN on a timeout or ENOTCONN on loss of + * connection (TCP only) + */ + + return pstate->pr_result; + } + + /* If net_lockedwait failed, then we were probably reawakened by a signal. In + * this case, net_lockedwait will have set errno appropriately. + */ + + if (result < 0) + { + return -save_errno; + } + + return pstate->pr_recvlen; +} + +/**************************************************************************** + * Name: pkt_recvfrom_rxnotify + * + * Description: + * Notify the appropriate device driver that we are ready to receive a + * packet (PKT) + * + * Parameters: + * conn - The PKT connection structure + * + * Returned Value: + * None + * + ****************************************************************************/ + +#if 0 /* Not implemented */ +static void pkt_recvfrom_rxnotify(FAR struct pkt_conn_s *conn) +{ +# warning Missing logic +} +#endif + +/**************************************************************************** + * Public Functions + ****************************************************************************/ + +/**************************************************************************** + * Name: pkt_recvfrom + * + * Description: + * Implements the socket recvfrom interface for the case of the AF_INET + * and AF_INET6 address families. pkt_recvfrom() receives messages from + * a socket, and may be used to receive data on a socket whether or not it + * is connection-oriented. + * + * If 'from' is not NULL, and the underlying protocol provides the source + * address, this source address is filled in. The argument 'fromlen' is + * initialized to the size of the buffer associated with from, and + * modified on return to indicate the actual size of the address stored + * there. + * + * Parameters: + * psock A pointer to a NuttX-specific, internal socket structure + * buf Buffer to receive data + * len Length of buffer + * flags Receive flags + * from Address of source (may be NULL) + * fromlen The length of the address structure + * + * Returned Value: + * On success, returns the number of characters received. If no data is + * available to be received and the peer has performed an orderly shutdown, + * recv() will return 0. Otherwise, on errors, a negated errno value is + * returned (see recvfrom() for the list of appropriate error values). + * + ****************************************************************************/ + +ssize_t pkt_recvfrom(FAR struct socket *psock, FAR void *buf, size_t len, + int flags, FAR struct sockaddr *from, + FAR socklen_t *fromlen) +{ + FAR struct pkt_conn_s *conn = (FAR struct pkt_conn_s *)psock->s_conn; + FAR struct net_driver_s *dev; + struct pkt_recvfrom_s state; + ssize_t ret; + + /* If a 'from' address has been provided, verify that it is large + * enough to hold this address family. + */ + + if (from != NULL && *fromlen < sizeof(sa_family_t)) + { + return -EINVAL; + } + + if (psock->s_type != -SOCK_RAW) + { + nerr("ERROR: Unsupported socket type: %d\n", psock->s_type); + ret = -ENOSYS; + } + + /* Perform the packet recvfrom() operation */ + + /* Initialize the state structure. This is done with interrupts + * disabled because we don't want anything to happen until we + * are ready. + */ + + net_lock(); + pkt_recvfrom_initialize(psock, buf, len, from, fromlen, &state); + + /* Get the device driver that will service this transfer */ + + dev = pkt_find_device(conn); + if (dev == NULL) + { + ret = -ENODEV; + goto errout_with_state; + } + + /* TODO pkt_recvfrom_initialize() expects from to be of type sockaddr_in, but + * in our case is sockaddr_ll + */ + +#if 0 + ret = pkt_connect(conn, NULL); + if (ret < 0) + { + goto errout_with_state; + } +#endif + + /* Set the socket state to receiving */ + + psock->s_flags = _SS_SETSTATE(psock->s_flags, _SF_RECV); + + /* Set up the callback in the connection */ + + state.pr_cb = pkt_callback_alloc(dev, conn); + if (state.pr_cb) + { + state.pr_cb->flags = (PKT_NEWDATA | PKT_POLL); + state.pr_cb->priv = (FAR void *)&state; + state.pr_cb->event = pkt_recvfrom_interrupt; + + /* Notify the device driver of the receive call */ + +#if 0 /* Not implemented */ + pkt_recvfrom_rxnotify(conn); +#endif + + /* Wait for either the receive to complete or for an error/timeout to occur. + * NOTES: (1) net_lockedwait will also terminate if a signal is received, (2) + * interrupts are disabled! They will be re-enabled while the task sleeps + * and automatically re-enabled when the task restarts. + */ + + ret = net_lockedwait(&state.pr_sem); + + /* Make sure that no further interrupts are processed */ + + pkt_callback_free(dev, conn, state.pr_cb); + ret = pkt_recvfrom_result(ret, &state); + } + else + { + ret = -EBUSY; + } + + /* Set the socket state to idle */ + + psock->s_flags = _SS_SETSTATE(psock->s_flags, _SF_IDLE); + +errout_with_state: + net_unlock(); + pkt_recvfrom_uninitialize(&state); + return ret; +} + +#endif /* CONFIG_NET */ diff --git a/net/pkt/pkt_sockif.c b/net/pkt/pkt_sockif.c index 2f698de2b1..9e3f0f6758 100644 --- a/net/pkt/pkt_sockif.c +++ b/net/pkt/pkt_sockif.c @@ -43,6 +43,7 @@ #include #include #include +#include #include @@ -67,9 +68,10 @@ static ssize_t pkt_sendto(FAR struct socket *psock, FAR const void *buf, const struct sock_intf_s g_pkt_sockif = { - pkt_setup, /* si_setup */ - pkt_send, /* si_send */ - pkt_sendto, /* si_sendto */ + pkt_setup, /* si_setup */ + pkt_send, /* si_send */ + pkt_sendto, /* si_sendto */ + pkt_recvfrom /* si_recvfrom */ }; /**************************************************************************** @@ -162,9 +164,9 @@ static int pkt_setup(FAR struct socket *psock, int protocol) * flags Send flags * * Returned Value: - * On success, returns the number of characters sent. On error, -1 is - * returned, and errno is set appropriately (see send() for the list of - * appropriate errors values. + * On success, returns the number of characters sent. On error, a negated + * errno value is returned (see send() for the list of appropriate error + * values. * ****************************************************************************/ @@ -208,9 +210,9 @@ static ssize_t pkt_send(FAR struct socket *psock, FAR const void *buf, * tolen The length of the address structure * * Returned Value: - * On success, returns the number of characters sent. On error, -1 is - * returned, and errno is set appropriately (see send_to() for the list of - * appropriate errors values. + * On success, returns the number of characters sent. On error, a negated + * errno value is returned (see send_to() for the list of appropriate error + * values. * ****************************************************************************/ diff --git a/net/socket/Make.defs b/net/socket/Make.defs index 93a3d1b8c5..105f70a636 100644 --- a/net/socket/Make.defs +++ b/net/socket/Make.defs @@ -44,9 +44,9 @@ SOCK_CSRCS += net_dupsd2.c net_clone.c net_poll.c net_vfcntl.c SOCK_CSRCS += net_sockif.c ifeq ($(CONFIG_NET_IPv4),y) -SOCK_CSRCS += inet_sockif.c +SOCK_CSRCS += inet_sockif.c inet_recvfrom.c else ifeq ($(CONFIG_NET_IPv6),y) -SOCK_CSRCS += inet_sockif.c +SOCK_CSRCS += inet_sockif.c inet_recvfrom.c endif # TCP/IP support diff --git a/net/socket/inet_recvfrom.c b/net/socket/inet_recvfrom.c new file mode 100644 index 0000000000..b38c15e82d --- /dev/null +++ b/net/socket/inet_recvfrom.c @@ -0,0 +1,1664 @@ +/**************************************************************************** + * net/socket/inet_recvfrom.c + * + * Copyright (C) 2007-2009, 2011-2017 Gregory Nutt. All rights reserved. + * Author: Gregory Nutt + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * 3. Neither the name NuttX nor the names of its contributors may be + * used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + ****************************************************************************/ + +/**************************************************************************** + * Included Files + ****************************************************************************/ + +#include + +#ifdef CONFIG_NET + +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "netdev/netdev.h" +#include "devif/devif.h" +#include "tcp/tcp.h" +#include "udp/udp.h" +#include "pkt/pkt.h" +#include "local/local.h" +#include "socket/socket.h" +#include "usrsock/usrsock.h" + +/**************************************************************************** + * Pre-processor Definitions + ****************************************************************************/ + +#define IPv4BUF ((struct ipv4_hdr_s *)&dev->d_buf[NET_LL_HDRLEN(dev)]) +#define IPv6BUF ((struct ipv6_hdr_s *)&dev->d_buf[NET_LL_HDRLEN(dev)]) + +#define UDPIPv4BUF ((struct udp_hdr_s *)&dev->d_buf[NET_LL_HDRLEN(dev) + IPv4_HDRLEN]) +#define UDPIPv6BUF ((struct udp_hdr_s *)&dev->d_buf[NET_LL_HDRLEN(dev) + IPv6_HDRLEN]) + +#define TCPIPv4BUF ((struct tcp_hdr_s *)&dev->d_buf[NET_LL_HDRLEN(dev) + IPv4_HDRLEN]) +#define TCPIPv6BUF ((struct tcp_hdr_s *)&dev->d_buf[NET_LL_HDRLEN(dev) + IPv6_HDRLEN]) + +/**************************************************************************** + * Private Types + ****************************************************************************/ + +#if defined(NET_UDP_HAVE_STACK) || defined(NET_TCP_HAVE_STACK) +struct inet_recvfrom_s +{ + FAR struct socket *ir_sock; /* The parent socket structure */ +#ifdef CONFIG_NET_SOCKOPTS + systime_t ir_starttime; /* rcv start time for determining timeout */ +#endif + FAR struct devif_callback_s *ir_cb; /* Reference to callback instance */ + sem_t ir_sem; /* Semaphore signals recv completion */ + size_t ir_buflen; /* Length of receive buffer */ + uint8_t *ir_buffer; /* Pointer to receive buffer */ + FAR struct sockaddr *ir_from; /* Address of sender */ + FAR socklen_t *ir_fromlen; /* Number of bytes allocated for address of sender */ + ssize_t ir_recvlen; /* The received length */ + int ir_result; /* Success:OK, failure:negated errno */ +}; +#endif /* NET_UDP_HAVE_STACK || NET_TCP_HAVE_STACK */ + +/**************************************************************************** + * Private Functions + ****************************************************************************/ + +/**************************************************************************** + * Name: inet_update_recvlen + * + * Description: + * Update information about space available for new data and update size + * of data in buffer, This logic accounts for the case where + * inet_udp_readahead() sets state.ir_recvlen == -1 . + * + * Parameters: + * pstate recvfrom state structure + * recvlen size of new data appended to buffer + * + * Returned Value: + * None + * + ****************************************************************************/ + +#if defined(NET_UDP_HAVE_STACK) || defined(NET_TCP_HAVE_STACK) + +static inline void inet_update_recvlen(FAR struct inet_recvfrom_s *pstate, + size_t recvlen) +{ + if (pstate->ir_recvlen < 0) + { + pstate->ir_recvlen = 0; + } + + pstate->ir_recvlen += recvlen; + pstate->ir_buffer += recvlen; + pstate->ir_buflen -= recvlen; +} +#endif /* NET_UDP_HAVE_STACK || NET_TCP_HAVE_STACK */ + +/**************************************************************************** + * Name: inet_recvfrom_newdata + * + * Description: + * Copy the read data from the packet + * + * Parameters: + * dev The structure of the network driver that caused the interrupt + * pstate recvfrom state structure + * + * Returned Value: + * The number of bytes taken from the packet. + * + * Assumptions: + * The network is locked. + * + ****************************************************************************/ + +#if defined(NET_UDP_HAVE_STACK) || defined(NET_TCP_HAVE_STACK) +static size_t inet_recvfrom_newdata(FAR struct net_driver_s *dev, + FAR struct inet_recvfrom_s *pstate) +{ + size_t recvlen; + + /* Get the length of the data to return */ + + if (dev->d_len > pstate->ir_buflen) + { + recvlen = pstate->ir_buflen; + } + else + { + recvlen = dev->d_len; + } + + /* Copy the new appdata into the user buffer */ + + memcpy(pstate->ir_buffer, dev->d_appdata, recvlen); + ninfo("Received %d bytes (of %d)\n", (int)recvlen, (int)dev->d_len); + + /* Update the accumulated size of the data read */ + + inet_update_recvlen(pstate, recvlen); + + return recvlen; +} +#endif /* NET_UDP_HAVE_STACK || NET_TCP_HAVE_STACK */ + +/**************************************************************************** + * Name: inet_tcp_newdata + * + * Description: + * Copy the read data from the packet + * + * Parameters: + * dev The structure of the network driver that caused the interrupt + * pstate recvfrom state structure + * + * Returned Value: + * None. + * + * Assumptions: + * The network is locked. + * + ****************************************************************************/ + +#ifdef NET_TCP_HAVE_STACK +static inline void inet_tcp_newdata(FAR struct net_driver_s *dev, + FAR struct inet_recvfrom_s *pstate) +{ + /* Take as much data from the packet as we can */ + + size_t recvlen = inet_recvfrom_newdata(dev, pstate); + + /* If there is more data left in the packet that we could not buffer, then + * add it to the read-ahead buffers. + */ + + if (recvlen < dev->d_len) + { +#ifdef CONFIG_NET_TCP_READAHEAD + FAR struct tcp_conn_s *conn = (FAR struct tcp_conn_s *)pstate->ir_sock->s_conn; + FAR uint8_t *buffer = (FAR uint8_t *)dev->d_appdata + recvlen; + uint16_t buflen = dev->d_len - recvlen; +#ifdef CONFIG_DEBUG_NET + uint16_t nsaved; + + nsaved = tcp_datahandler(conn, buffer, buflen); +#else + (void)tcp_datahandler(conn, buffer, buflen); +#endif + + /* There are complicated buffering issues that are not addressed fully + * here. For example, what if up_datahandler() cannot buffer the + * remainder of the packet? In that case, the data will be dropped but + * still ACKed. Therefore it would not be resent. + * + * This is probably not an issue here because we only get here if the + * read-ahead buffers are empty and there would have to be something + * serioulsy wrong with the configuration not to be able to buffer a + * partial packet in this context. + */ + +#ifdef CONFIG_DEBUG_NET + if (nsaved < buflen) + { + nerr("ERROR: packet data not saved (%d bytes)\n", buflen - nsaved); + } +#endif +#else + nerr("ERROR: packet data lost (%d bytes)\n", dev->d_len - recvlen); +#endif + } + + /* Indicate no data in the buffer */ + + dev->d_len = 0; +} +#endif /* NET_TCP_HAVE_STACK */ + +/**************************************************************************** + * Name: inet_udp_newdata + * + * Description: + * Copy the read data from the packet + * + * Parameters: + * dev The sructure of the network driver that caused the interrupt + * pstate recvfrom state structure + * + * Returned Value: + * None. + * + * Assumptions: + * The network is locked. + * + ****************************************************************************/ + +#ifdef NET_UDP_HAVE_STACK +static inline void inet_udp_newdata(FAR struct net_driver_s *dev, + FAR struct inet_recvfrom_s *pstate) +{ + /* Take as much data from the packet as we can */ + + (void)inet_recvfrom_newdata(dev, pstate); + + /* Indicate no data in the buffer */ + + dev->d_len = 0; +} +#endif /* NET_UDP_HAVE_STACK */ + +/**************************************************************************** + * Name: inet_tcp_readahead + * + * Description: + * Copy the read data from the packet + * + * Parameters: + * dev The structure of the network driver that caused the interrupt + * pstate recvfrom state structure + * + * Returned Value: + * None + * + * Assumptions: + * The network is locked. + * + ****************************************************************************/ + +#if defined(NET_TCP_HAVE_STACK) && defined(CONFIG_NET_TCP_READAHEAD) +static inline void inet_tcp_readahead(struct inet_recvfrom_s *pstate) +{ + FAR struct tcp_conn_s *conn = (FAR struct tcp_conn_s *)pstate->ir_sock->s_conn; + FAR struct iob_s *iob; + int recvlen; + + /* Check there is any TCP data already buffered in a read-ahead + * buffer. + */ + + while ((iob = iob_peek_queue(&conn->readahead)) != NULL && + pstate->ir_buflen > 0) + { + DEBUGASSERT(iob->io_pktlen > 0); + + /* Transfer that buffered data from the I/O buffer chain into + * the user buffer. + */ + + recvlen = iob_copyout(pstate->ir_buffer, iob, pstate->ir_buflen, 0); + ninfo("Received %d bytes (of %d)\n", recvlen, iob->io_pktlen); + + /* Update the accumulated size of the data read */ + + inet_update_recvlen(pstate, recvlen); + + /* If we took all of the ata from the I/O buffer chain is empty, then + * release it. If there is still data available in the I/O buffer + * chain, then just trim the data that we have taken from the + * beginning of the I/O buffer chain. + */ + + if (recvlen >= iob->io_pktlen) + { + FAR struct iob_s *tmp; + + /* Remove the I/O buffer chain from the head of the read-ahead + * buffer queue. + */ + + tmp = iob_remove_queue(&conn->readahead); + DEBUGASSERT(tmp == iob); + UNUSED(tmp); + + /* And free the I/O buffer chain */ + + (void)iob_free_chain(iob); + } + else + { + /* The bytes that we have received from the head of the I/O + * buffer chain (probably changing the head of the I/O + * buffer queue). + */ + + (void)iob_trimhead_queue(&conn->readahead, recvlen); + } + } +} +#endif /* NET_TCP_HAVE_STACK && CONFIG_NET_TCP_READAHEAD */ + +#if defined(NET_UDP_HAVE_STACK) && defined(CONFIG_NET_UDP_READAHEAD) + +static inline void inet_udp_readahead(struct inet_recvfrom_s *pstate) +{ + FAR struct udp_conn_s *conn = (FAR struct udp_conn_s *)pstate->ir_sock->s_conn; + FAR struct iob_s *iob; + int recvlen; + + /* Check there is any UDP datagram already buffered in a read-ahead + * buffer. + */ + + pstate->ir_recvlen = -1; + + if ((iob = iob_peek_queue(&conn->readahead)) != NULL) + { + FAR struct iob_s *tmp; + uint8_t src_addr_size; + + DEBUGASSERT(iob->io_pktlen > 0); + + /* Transfer that buffered data from the I/O buffer chain into + * the user buffer. + */ + + recvlen = iob_copyout(&src_addr_size, iob, sizeof(uint8_t), 0); + if (recvlen != sizeof(uint8_t)) + { + goto out; + } + + if (0 +#ifdef CONFIG_NET_IPv6 + || src_addr_size == sizeof(struct sockaddr_in6) +#endif +#ifdef CONFIG_NET_IPv4 + || src_addr_size == sizeof(struct sockaddr_in) +#endif + ) + { + if (pstate->ir_from) + { + socklen_t len = *pstate->ir_fromlen; + len = (socklen_t)src_addr_size > len ? len : (socklen_t)src_addr_size; + + recvlen = iob_copyout((FAR uint8_t *)pstate->ir_from, iob, + len, sizeof(uint8_t)); + if (recvlen != len) + { + goto out; + } + } + } + + if (pstate->ir_buflen > 0) + { + recvlen = iob_copyout(pstate->ir_buffer, iob, pstate->ir_buflen, + src_addr_size + sizeof(uint8_t)); + + ninfo("Received %d bytes (of %d)\n", recvlen, iob->io_pktlen); + + /* Update the accumulated size of the data read */ + + pstate->ir_recvlen = recvlen; + pstate->ir_buffer += recvlen; + pstate->ir_buflen -= recvlen; + } + else + { + pstate->ir_recvlen = 0; + } + +out: + /* Remove the I/O buffer chain from the head of the read-ahead + * buffer queue. + */ + + tmp = iob_remove_queue(&conn->readahead); + DEBUGASSERT(tmp == iob); + UNUSED(tmp); + + /* And free the I/O buffer chain */ + + (void)iob_free_chain(iob); + } +} +#endif + +/**************************************************************************** + * Name: inet_recvfrom_timeout + * + * Description: + * Check for recvfrom timeout. + * + * Parameters: + * pstate recvfrom state structure + * + * Returned Value: + * TRUE:timeout FALSE:no timeout + * + * Assumptions: + * The network is locked. + * + ****************************************************************************/ + +#if defined(NET_UDP_HAVE_STACK) || defined(NET_TCP_HAVE_STACK) +#ifdef CONFIG_NET_SOCKOPTS +static int inet_recvfrom_timeout(struct inet_recvfrom_s *pstate) +{ + FAR struct socket *psock = 0; + socktimeo_t timeo = 0; + + /* Check for a timeout configured via setsockopts(SO_RCVTIMEO). If none... + * we well let the read hang forever (except for the special case below). + */ + + /* Get the socket reference from the private data */ + + psock = pstate->ir_sock; + if (psock) + { + /* Recover the timeout value (zero if no timeout) */ + + timeo = psock->s_rcvtimeo; + } + + /* Use a fixed, configurable delay under the following circumstances: + * + * 1) This delay function has been enabled with CONFIG_NET_TCP_RECVDELAY > 0 + * 2) Some data has already been received from the socket. Since this can + * only be true for a TCP/IP socket, this logic applies only to TCP/IP + * sockets. And either + * 3) There is no configured receive timeout, or + * 4) The configured receive timeout is greater than than the delay + */ + +#if CONFIG_NET_TCP_RECVDELAY > 0 + if ((timeo == 0 || timeo > CONFIG_NET_TCP_RECVDELAY) && + pstate->ir_recvlen > 0) + { + /* Use the configured timeout */ + + timeo = CONFIG_NET_TCP_RECVDELAY; + } +#endif + + /* Is there an effective timeout? */ + + if (timeo) + { + /* Yes.. Check if the timeout has elapsed */ + + return net_timeo(pstate->ir_starttime, timeo); + } + + /* No timeout -- hang forever waiting for data. */ + + return FALSE; +} +#endif /* CONFIG_NET_SOCKOPTS */ +#endif /* NET_UDP_HAVE_STACK || NET_TCP_HAVE_STACK */ + +/**************************************************************************** + * Name: inet_tcp_sender + * + * Description: + * Getting the sender's address from the UDP packet + * + * Parameters: + * dev - The device driver data structure + * pstate - the recvfrom state structure + * + * Returned Value: + * None + * + * Assumptions: + * Running at the interrupt level + * + ****************************************************************************/ + +#ifdef NET_TCP_HAVE_STACK +static inline void inet_tcp_sender(FAR struct net_driver_s *dev, + FAR struct inet_recvfrom_s *pstate) +{ + /* Get the family from the packet type, IP address from the IP header, and + * the port number from the TCP header. + */ + +#ifdef CONFIG_NET_IPv6 +#ifdef CONFIG_NET_IPv4 + if (IFF_IS_IPv6(dev->d_flags)) +#endif + { + FAR struct sockaddr_in6 *infrom = + (FAR struct sockaddr_in6 *)pstate->ir_from; + + if (infrom) + { + FAR struct tcp_hdr_s *tcp = TCPIPv6BUF; + FAR struct ipv6_hdr_s *ipv6 = IPv6BUF; + + infrom->sin6_family = AF_INET6; + infrom->sin6_port = tcp->srcport; + + net_ipv6addr_copy(infrom->sin6_addr.s6_addr, ipv6->srcipaddr); + } + } +#endif /* CONFIG_NET_IPv6 */ + +#ifdef CONFIG_NET_IPv4 +#ifdef CONFIG_NET_IPv6 + else +#endif + { + FAR struct sockaddr_in *infrom = + (FAR struct sockaddr_in *)pstate->ir_from; + + if (infrom) + { + FAR struct tcp_hdr_s *tcp = TCPIPv4BUF; + FAR struct ipv4_hdr_s *ipv4 = IPv4BUF; + + infrom->sin_family = AF_INET; + infrom->sin_port = tcp->srcport; + + net_ipv4addr_copy(infrom->sin_addr.s_addr, + net_ip4addr_conv32(ipv4->srcipaddr)); + } + } +#endif /* CONFIG_NET_IPv4 */ +} +#endif /* NET_TCP_HAVE_STACK */ + +/**************************************************************************** + * Name: inet_tcp_interrupt + * + * Description: + * This function is called from the interrupt level to perform the actual + * TCP receive operation via by the lower, device interfacing layer. + * + * Parameters: + * dev The structure of the network driver that caused the interrupt + * pvconn The connection structure associated with the socket + * flags Set of events describing why the callback was invoked + * + * Returned Value: + * None + * + * Assumptions: + * The network is locked. + * + ****************************************************************************/ + +#ifdef NET_TCP_HAVE_STACK +static uint16_t inet_tcp_interrupt(FAR struct net_driver_s *dev, + FAR void *pvconn, FAR void *pvpriv, + uint16_t flags) +{ + FAR struct inet_recvfrom_s *pstate = (struct inet_recvfrom_s *)pvpriv; + +#if 0 /* REVISIT: The assertion fires. Why? */ +#ifdef CONFIG_NETDEV_MULTINIC + FAR struct tcp_conn_s *conn = (FAR struct tcp_conn_s *)pvconn; + + /* The TCP socket is connected and, hence, should be bound to a device. + * Make sure that the polling device is the own that we are bound to. + */ + + DEBUGASSERT(conn->dev == NULL || conn->dev == dev); + if (conn->dev != NULL && conn->dev != dev) + { + return flags; + } +#endif +#endif + + ninfo("flags: %04x\n", flags); + + /* 'priv' might be null in some race conditions (?) */ + + if (pstate) + { + /* If new data is available, then complete the read action. */ + + if ((flags & TCP_NEWDATA) != 0) + { + /* Copy the data from the packet (saving any unused bytes from the + * packet in the read-ahead buffer). + */ + + inet_tcp_newdata(dev, pstate); + + /* Save the sender's address in the caller's 'from' location */ + + inet_tcp_sender(dev, pstate); + + /* Indicate that the data has been consumed and that an ACK + * should be sent. + */ + + flags = (flags & ~TCP_NEWDATA) | TCP_SNDACK; + + /* Check for transfer complete. We will consider the transfer + * complete in own of two different ways, depending on the setting + * of CONFIG_NET_TCP_RECVDELAY. + * + * 1) If CONFIG_NET_TCP_RECVDELAY == 0 then we will consider the + * TCP/IP transfer complete as soon as any data has been received. + * This is safe because if any additional data is received, it + * will be retained in the TCP/IP read-ahead buffer until the + * next receive is performed. + * 2) CONFIG_NET_TCP_RECVDELAY > 0 may be set to wait a little + * bit to determine if more data will be received. You might + * do this if read-ahead buffering is disabled and we want to + * minimize the loss of back-to-back packets. In this case, + * the transfer is complete when either a) the entire user buffer + * is full or 2) when the receive timeout occurs (below). + */ + +#if CONFIG_NET_TCP_RECVDELAY > 0 + if (pstate->ir_buflen == 0) +#else + if (pstate->ir_recvlen > 0) +#endif + { + ninfo("TCP resume\n"); + + /* The TCP receive buffer is non-empty. Return now and don't + * allow any further TCP call backs. + */ + + pstate->ir_cb->flags = 0; + pstate->ir_cb->priv = NULL; + pstate->ir_cb->event = NULL; + + /* Wake up the waiting thread, returning the number of bytes + * actually read. + */ + + sem_post(&pstate->ir_sem); + } + +#ifdef CONFIG_NET_SOCKOPTS + /* Reset the timeout. We will want a short timeout to terminate + * the TCP receive. + */ + + pstate->ir_starttime = clock_systimer(); +#endif + } + + /* Check for a loss of connection. + * + * TCP_DISCONN_EVENTS: + * TCP_CLOSE: The remote host has closed the connection + * TCP_ABORT: The remote host has aborted the connection + * TCP_TIMEDOUT: Connection aborted due to too many retransmissions. + * NETDEV_DOWN: The network device went down + */ + + else if ((flags & TCP_DISCONN_EVENTS) != 0) + { + ninfo("Lost connection\n"); + + /* Stop further callbacks */ + + pstate->ir_cb->flags = 0; + pstate->ir_cb->priv = NULL; + pstate->ir_cb->event = NULL; + + /* Handle loss-of-connection event */ + + net_lostconnection(pstate->ir_sock, flags); + + /* Check if the peer gracefully closed the connection. */ + + if ((flags & TCP_CLOSE) != 0) + { + /* This case should always return success (zero)! The value of + * ir_recvlen, if zero, will indicate that the connection was + * gracefully closed. + */ + + pstate->ir_result = 0; + } + else + { + /* If no data has been received, then return ENOTCONN. + * Otherwise, let this return success. The failure will + * be reported the next time that recv[from]() is called. + */ + +#if CONFIG_NET_TCP_RECVDELAY > 0 + if (pstate->ir_recvlen > 0) + { + pstate->ir_result = 0; + } + else + { + pstate->ir_result = -ENOTCONN; + } +#else + pstate->ir_result = -ENOTCONN; +#endif + } + + /* Wake up the waiting thread */ + + sem_post(&pstate->ir_sem); + } + +#ifdef CONFIG_NET_SOCKOPTS + /* No data has been received -- this is some other event... probably a + * poll -- check for a timeout. + */ + + else if (inet_recvfrom_timeout(pstate)) + { + /* Yes.. the timeout has elapsed... do not allow any further + * callbacks + */ + + ninfo("TCP timeout\n"); + + pstate->ir_cb->flags = 0; + pstate->ir_cb->priv = NULL; + pstate->ir_cb->event = NULL; + + /* Report an error only if no data has been received. (If + * CONFIG_NET_TCP_RECVDELAY then ir_recvlen should always be + * less than or equal to zero). + */ + +#if CONFIG_NET_TCP_RECVDELAY > 0 + if (pstate->ir_recvlen <= 0) +#endif + { + /* Report the timeout error */ + + pstate->ir_result = -EAGAIN; + } + + /* Wake up the waiting thread, returning either the error -EAGAIN + * that signals the timeout event or the data received up to + * the point that the timeout occurred (no error). + */ + + sem_post(&pstate->ir_sem); + } +#endif /* CONFIG_NET_SOCKOPTS */ + } + + return flags; +} +#endif /* NET_TCP_HAVE_STACK */ + +/**************************************************************************** + * Name: inet_udp_sender + * + * Description: + * Getting the sender's address from the UDP packet + * + * Parameters: + * dev - The device driver data structure + * pstate - the recvfrom state structure + * + * Returned Value: + * None + * + * Assumptions: + * The network is locked. + * + ****************************************************************************/ + +#ifdef NET_UDP_HAVE_STACK +static inline void inet_udp_sender(struct net_driver_s *dev, struct inet_recvfrom_s *pstate) +{ + /* Get the family from the packet type, IP address from the IP header, and + * the port number from the UDP header. + */ + +#ifdef CONFIG_NET_IPv6 +#ifdef CONFIG_NET_IPv4 + if (IFF_IS_IPv6(dev->d_flags)) +#endif + { + FAR struct sockaddr_in6 *infrom = + (FAR struct sockaddr_in6 *)pstate->ir_from; + FAR socklen_t *fromlen = pstate->ir_fromlen; + + if (infrom) + { + FAR struct udp_hdr_s *udp = UDPIPv6BUF; + FAR struct ipv6_hdr_s *ipv6 = IPv6BUF; + + infrom->sin6_family = AF_INET6; + infrom->sin6_port = udp->srcport; + *fromlen = sizeof(struct sockaddr_in6); + + net_ipv6addr_copy(infrom->sin6_addr.s6_addr, ipv6->srcipaddr); + } + } +#endif /* CONFIG_NET_IPv6 */ + +#ifdef CONFIG_NET_IPv4 +#ifdef CONFIG_NET_IPv6 + else +#endif + { + FAR struct sockaddr_in *infrom = + (FAR struct sockaddr_in *)pstate->ir_from; + + if (infrom) + { +#ifdef CONFIG_NET_IPv6 + FAR struct udp_conn_s *conn = + (FAR struct udp_conn_s *)pstate->ir_sock->s_conn; + + /* Hybrid dual-stack IPv6/IPv4 implementations recognize a special + * class of addresses, the IPv4-mapped IPv6 addresses. + */ + + if (conn->domain == PF_INET6) + { + FAR struct sockaddr_in6 *infrom6 = (FAR struct sockaddr_in6 *)infrom; + FAR socklen_t *fromlen = pstate->ir_fromlen; + FAR struct udp_hdr_s *udp = UDPIPv6BUF; + FAR struct ipv6_hdr_s *ipv6 = IPv6BUF; + in_addr_t ipv4addr; + + /* Encode the IPv4 address as an IPv4-mapped IPv6 address */ + + infrom6->sin6_family = AF_INET6; + infrom6->sin6_port = udp->srcport; + *fromlen = sizeof(struct sockaddr_in6); + + ipv4addr = net_ip4addr_conv32(ipv6->srcipaddr); + ip6_map_ipv4addr(ipv4addr, infrom6->sin6_addr.s6_addr16); + } + else +#endif + { + FAR struct udp_hdr_s *udp = UDPIPv4BUF; + FAR struct ipv4_hdr_s *ipv4 = IPv4BUF; + + infrom->sin_family = AF_INET; + infrom->sin_port = udp->srcport; + + net_ipv4addr_copy(infrom->sin_addr.s_addr, + net_ip4addr_conv32(ipv4->srcipaddr)); + } + } + } +#endif /* CONFIG_NET_IPv4 */ +} +#endif /* NET_UDP_HAVE_STACK */ + +/**************************************************************************** + * Name: inet_udp_terminate + * + * Description: + * Terminate the UDP transfer. + * + * Parameters: + * pstate - The recvfrom state structure + * result - The result of the operation + * + * Returned Value: + * None + * + ****************************************************************************/ + +#ifdef NET_UDP_HAVE_STACK +static void inet_udp_terminate(FAR struct inet_recvfrom_s *pstate, int result) +{ + /* Don't allow any further UDP call backs. */ + + pstate->ir_cb->flags = 0; + pstate->ir_cb->priv = NULL; + pstate->ir_cb->event = NULL; + + /* Save the result of the transfer */ + + pstate->ir_result = result; + + /* Wake up the waiting thread, returning the number of bytes + * actually read. + */ + + sem_post(&pstate->ir_sem); +} +#endif /* NET_UDP_HAVE_STACK */ + +/**************************************************************************** + * Name: inet_udp_interrupt + * + * Description: + * This function is called from the interrupt level to perform the actual + * UDP receive operation via by the lower, device interfacing layer. + * + * Parameters: + * dev The structure of the network driver that caused the interrupt + * pvconn The connection structure associated with the socket + * flags Set of events describing why the callback was invoked + * + * Returned Value: + * None + * + * Assumptions: + * The network is locked. + * + ****************************************************************************/ + +#ifdef NET_UDP_HAVE_STACK +static uint16_t inet_udp_interrupt(FAR struct net_driver_s *dev, + FAR void *pvconn, FAR void *pvpriv, + uint16_t flags) +{ + FAR struct inet_recvfrom_s *pstate = (FAR struct inet_recvfrom_s *)pvpriv; + + ninfo("flags: %04x\n", flags); + + /* 'priv' might be null in some race conditions (?) */ + + if (pstate) + { + /* If the network device has gone down, then we will have terminate + * the wait now with an error. + */ + + if ((flags & NETDEV_DOWN) != 0) + { + /* Terminate the transfer with an error. */ + + nerr("ERROR: Network is down\n"); + inet_udp_terminate(pstate, -ENETUNREACH); + } + + /* If new data is available, then complete the read action. */ + + else if ((flags & UDP_NEWDATA) != 0) + { + /* Copy the data from the packet */ + + inet_udp_newdata(dev, pstate); + + /* We are finished. */ + + ninfo("UDP done\n"); + + /* Save the sender's address in the caller's 'from' location */ + + inet_udp_sender(dev, pstate); + + /* Don't allow any further UDP call backs. */ + + inet_udp_terminate(pstate, OK); + + /* Indicate that the data has been consumed */ + + flags &= ~UDP_NEWDATA; + } + +#ifdef CONFIG_NET_SOCKOPTS + /* No data has been received -- this is some other event... probably a + * poll -- check for a timeout. + */ + + else if (inet_recvfrom_timeout(pstate)) + { + /* Yes.. the timeout has elapsed... do not allow any further + * callbacks + */ + + nerr("ERROR: UDP timeout\n"); + + /* Terminate the transfer with an -EAGAIN error */ + + inet_udp_terminate(pstate, -EAGAIN); + } +#endif /* CONFIG_NET_SOCKOPTS */ + } + + return flags; +} +#endif /* NET_UDP_HAVE_STACK */ + +/**************************************************************************** + * Name: inet_recvfrom_initialize + * + * Description: + * Initialize the state structure + * + * Parameters: + * psock Pointer to the socket structure for the socket + * buf Buffer to receive data + * len Length of buffer + * pstate A pointer to the state structure to be initialized + * + * Returned Value: + * None + * + * Assumptions: + * + ****************************************************************************/ + +#if defined(NET_UDP_HAVE_STACK) || defined(NET_TCP_HAVE_STACK) +static void inet_recvfrom_initialize(FAR struct socket *psock, FAR void *buf, + size_t len, FAR struct sockaddr *infrom, + FAR socklen_t *fromlen, + FAR struct inet_recvfrom_s *pstate) +{ + /* Initialize the state structure. */ + + memset(pstate, 0, sizeof(struct inet_recvfrom_s)); + + /* This semaphore is used for signaling and, hence, should not have + * priority inheritance enabled. + */ + + (void)sem_init(&pstate->ir_sem, 0, 0); /* Doesn't really fail */ + (void)sem_setprotocol(&pstate->ir_sem, SEM_PRIO_NONE); + + pstate->ir_buflen = len; + pstate->ir_buffer = buf; + pstate->ir_from = infrom; + pstate->ir_fromlen = fromlen; + + /* Set up the start time for the timeout */ + + pstate->ir_sock = psock; +#ifdef CONFIG_NET_SOCKOPTS + pstate->ir_starttime = clock_systimer(); +#endif +} + +/* The only un-initialization that has to be performed is destroying the + * semaphore. + */ + +#define inet_recvfrom_uninitialize(s) sem_destroy(&(s)->ir_sem) + +#endif /* NET_UDP_HAVE_STACK || NET_TCP_HAVE_STACK */ + +/**************************************************************************** + * Name: inet_recvfrom_result + * + * Description: + * Evaluate the result of the recv operations + * + * Parameters: + * result The result of the net_lockedwait operation (may indicate EINTR) + * pstate A pointer to the state structure to be initialized + * + * Returned Value: + * The result of the recv operation with errno set appropriately + * + * Assumptions: + * + ****************************************************************************/ + +#if defined(NET_UDP_HAVE_STACK) || defined(NET_TCP_HAVE_STACK) +static ssize_t inet_recvfrom_result(int result, struct inet_recvfrom_s *pstate) +{ + int save_errno = get_errno(); /* In case something we do changes it */ + + /* Check for a error/timeout detected by the interrupt handler. Errors are + * signaled by negative errno values for the rcv length + */ + + if (pstate->ir_result < 0) + { + /* This might return EAGAIN on a timeout or ENOTCONN on loss of + * connection (TCP only) + */ + + return pstate->ir_result; + } + + /* If net_lockedwait failed, then we were probably reawakened by a signal. In + * this case, net_lockedwait will have set errno appropriately. + */ + + if (result < 0) + { + return -save_errno; + } + + return pstate->ir_recvlen; +} +#endif /* NET_UDP_HAVE_STACK || NET_TCP_HAVE_STACK */ + +/**************************************************************************** + * Name: inet_udp_rxnotify + * + * Description: + * Notify the appropriate device driver that we are ready to receive a + * packet (UDP) + * + * Parameters: + * psock - Socket state structure + * conn - The UDP connection structure + * + * Returned Value: + * None + * + ****************************************************************************/ + +#ifdef NET_UDP_HAVE_STACK +static inline void inet_udp_rxnotify(FAR struct socket *psock, + FAR struct udp_conn_s *conn) +{ +#ifdef CONFIG_NET_IPv4 +#ifdef CONFIG_NET_IPv6 + /* If both IPv4 and IPv6 support are enabled, then we will need to select + * the device driver using the appropriate IP domain. + */ + + if (psock->s_domain == PF_INET) +#endif + { + /* Notify the device driver of the receive ready */ + +#ifdef CONFIG_NETDEV_MULTINIC + netdev_ipv4_rxnotify(conn->u.ipv4.laddr, conn->u.ipv4.raddr); +#else + netdev_ipv4_rxnotify(conn->u.ipv4.raddr); +#endif + } +#endif /* CONFIG_NET_IPv4 */ + +#ifdef CONFIG_NET_IPv6 +#ifdef CONFIG_NET_IPv4 + else /* if (psock->s_domain == PF_INET6) */ +#endif /* CONFIG_NET_IPv4 */ + { + /* Notify the device driver of the receive ready */ + + DEBUGASSERT(psock->s_domain == PF_INET6); +#ifdef CONFIG_NETDEV_MULTINIC + netdev_ipv6_rxnotify(conn->u.ipv6.laddr, conn->u.ipv6.raddr); +#else + netdev_ipv6_rxnotify(conn->u.ipv6.raddr); +#endif + } +#endif /* CONFIG_NET_IPv6 */ +} +#endif /* NET_UDP_HAVE_STACK */ + +/**************************************************************************** + * Name: inet_udp_recvfrom + * + * Description: + * Perform the recvfrom operation for a UDP SOCK_DGRAM + * + * Parameters: + * psock Pointer to the socket structure for the SOCK_DRAM socket + * buf Buffer to receive data + * len Length of buffer + * from INET address of source (may be NULL) + * + * Returned Value: + * On success, returns the number of characters received. On error, + * -errno is returned (see recvfrom for list of errnos). + * + * Assumptions: + * + ****************************************************************************/ + +#ifdef NET_UDP_HAVE_STACK +static ssize_t inet_udp_recvfrom(FAR struct socket *psock, FAR void *buf, size_t len, + FAR struct sockaddr *from, FAR socklen_t *fromlen) +{ + FAR struct udp_conn_s *conn = (FAR struct udp_conn_s *)psock->s_conn; + FAR struct net_driver_s *dev; + struct inet_recvfrom_s state; + int ret; + + /* Perform the UDP recvfrom() operation */ + + /* Initialize the state structure. This is done with interrupts + * disabled because we don't want anything to happen until we + * are ready. + */ + + net_lock(); + inet_recvfrom_initialize(psock, buf, len, from, fromlen, &state); + + /* Setup the UDP remote connection */ + + ret = udp_connect(conn, NULL); + if (ret < 0) + { + goto errout_with_state; + } + +#ifdef CONFIG_NET_UDP_READAHEAD + inet_udp_readahead(&state); + + /* The default return value is the number of bytes that we just copied + * into the user buffer. We will return this if the socket has become + * disconnected or if the user request was completely satisfied with + * data from the readahead buffers. + */ + + ret = state.ir_recvlen; + +#else + /* Otherwise, the default return value of zero is used (only for the case + * where len == state.ir_buflen is zero). + */ + + ret = 0; +#endif + +#ifdef CONFIG_NET_UDP_READAHEAD + if (_SS_ISNONBLOCK(psock->s_flags)) + { + /* Return the number of bytes read from the read-ahead buffer if + * something was received (already in 'ret'); EAGAIN if not. + */ + + if (ret < 0) + { + /* Nothing was received */ + + ret = -EAGAIN; + } + } + + /* It is okay to block if we need to. If there is space to receive anything + * more, then we will wait to receive the data. Otherwise return the number + * of bytes read from the read-ahead buffer (already in 'ret'). + * + * NOTE: that inet_udp_readahead() may set state.ir_recvlen == -1. + */ + + else if (state.ir_recvlen <= 0) +#endif + { + /* Get the device that will handle the packet transfers. This may be + * NULL if the UDP socket is bound to INADDR_ANY. In that case, no + * NETDEV_DOWN notifications will be received. + */ + + dev = udp_find_laddr_device(conn); + + /* Set up the callback in the connection */ + + state.ir_cb = udp_callback_alloc(dev, conn); + if (state.ir_cb) + { + /* Set up the callback in the connection */ + + state.ir_cb->flags = (UDP_NEWDATA | UDP_POLL | NETDEV_DOWN); + state.ir_cb->priv = (FAR void *)&state; + state.ir_cb->event = inet_udp_interrupt; + + /* Notify the device driver of the receive call */ + + inet_udp_rxnotify(psock, conn); + + /* Wait for either the receive to complete or for an error/timeout + * to occur. NOTES: (1) net_lockedwait will also terminate if a + * signal is received, (2) interrupts are disabled! They will be + * re-enabled while the task sleeps and automatically re-enabled + * when the task restarts. + */ + + ret = net_lockedwait(&state. ir_sem); + + /* Make sure that no further interrupts are processed */ + + udp_callback_free(dev, conn, state.ir_cb); + ret = inet_recvfrom_result(ret, &state); + } + else + { + ret = -EBUSY; + } + } + +errout_with_state: + net_unlock(); + inet_recvfrom_uninitialize(&state); + return ret; +} +#endif /* NET_UDP_HAVE_STACK */ + +/**************************************************************************** + * Name: inet_tcp_recvfrom + * + * Description: + * Perform the recvfrom operation for a TCP/IP SOCK_STREAM + * + * Parameters: + * psock Pointer to the socket structure for the SOCK_DRAM socket + * buf Buffer to receive data + * len Length of buffer + * from INET address of source (may be NULL) + * + * Returned Value: + * On success, returns the number of characters received. On error, + * -errno is returned (see recvfrom for list of errnos). + * + * Assumptions: + * + ****************************************************************************/ + +#ifdef NET_TCP_HAVE_STACK +static ssize_t inet_tcp_recvfrom(FAR struct socket *psock, FAR void *buf, size_t len, + FAR struct sockaddr *from, FAR socklen_t *fromlen) +{ + struct inet_recvfrom_s state; + int ret; + + /* Initialize the state structure. This is done with interrupts + * disabled because we don't want anything to happen until we + * are ready. + */ + + net_lock(); + inet_recvfrom_initialize(psock, buf, len, from, fromlen, &state); + + /* Handle any any TCP data already buffered in a read-ahead buffer. NOTE + * that there may be read-ahead data to be retrieved even after the + * socket has been disconnected. + */ + +#ifdef CONFIG_NET_TCP_READAHEAD + inet_tcp_readahead(&state); + + /* The default return value is the number of bytes that we just copied + * into the user buffer. We will return this if the socket has become + * disconnected or if the user request was completely satisfied with + * data from the readahead buffers. + */ + + ret = state.ir_recvlen; + +#else + /* Otherwise, the default return value of zero is used (only for the case + * where len == state.ir_buflen is zero). + */ + + ret = 0; +#endif + + /* Verify that the SOCK_STREAM has been and still is connected */ + + if (!_SS_ISCONNECTED(psock->s_flags)) + { + /* Was any data transferred from the readahead buffer after we were + * disconnected? If so, then return the number of bytes received. We + * will wait to return end disconnection indications the next time that + * recvfrom() is called. + * + * If no data was received (i.e., ret == 0 -- it will not be negative) + * and the connection was gracefully closed by the remote peer, then return + * success. If ir_recvlen is zero, the caller of recvfrom() will get an + * end-of-file indication. + */ + +#ifdef CONFIG_NET_TCP_READAHEAD + if (ret <= 0 && !_SS_ISCLOSED(psock->s_flags)) +#else + if (!_SS_ISCLOSED(psock->s_flags)) +#endif + { + /* Nothing was previously received from the readahead buffers. + * The SOCK_STREAM must be (re-)connected in order to receive any + * additional data. + */ + + ret = -ENOTCONN; + } + } + + /* In general, this implementation will not support non-blocking socket + * operations... except in a few cases: Here for TCP receive with read-ahead + * enabled. If this socket is configured as non-blocking then return EAGAIN + * if no data was obtained from the read-ahead buffers. + */ + + else +#ifdef CONFIG_NET_TCP_READAHEAD + if (_SS_ISNONBLOCK(psock->s_flags)) + { + /* Return the number of bytes read from the read-ahead buffer if + * something was received (already in 'ret'); EAGAIN if not. + */ + + if (ret <= 0) + { + /* Nothing was received */ + + ret = -EAGAIN; + } + } + + /* It is okay to block if we need to. If there is space to receive anything + * more, then we will wait to receive the data. Otherwise return the number + * of bytes read from the read-ahead buffer (already in 'ret'). + */ + + else +#endif + + /* We get here when we we decide that we need to setup the wait for incoming + * TCP/IP data. Just a few more conditions to check: + * + * 1) Make sure thet there is buffer space to receive additional data + * (state.ir_buflen > 0). This could be zero, for example, if read-ahead + * buffering was enabled and we filled the user buffer with data from + * the read-ahead buffers. And + * 2) if read-ahead buffering is enabled (CONFIG_NET_TCP_READAHEAD) + * and delay logic is disabled (CONFIG_NET_TCP_RECVDELAY == 0), then we + * not want to wait if we already obtained some data from the read-ahead + * buffer. In that case, return now with what we have (don't want for more + * because there may be no timeout). + */ + +#if CONFIG_NET_TCP_RECVDELAY == 0 && defined(CONFIG_NET_TCP_READAHEAD) + if (state.ir_recvlen == 0 && state.ir_buflen > 0) +#else + if (state.ir_buflen > 0) +#endif + { + FAR struct tcp_conn_s *conn = (FAR struct tcp_conn_s *)psock->s_conn; + + /* Set up the callback in the connection */ + + state.ir_cb = tcp_callback_alloc(conn); + if (state.ir_cb) + { + state.ir_cb->flags = (TCP_NEWDATA | TCP_POLL | TCP_DISCONN_EVENTS); + state.ir_cb->priv = (FAR void *)&state; + state.ir_cb->event = inet_tcp_interrupt; + + /* Wait for either the receive to complete or for an error/timeout + * to occur. + * + * NOTES: (1) net_lockedwait will also terminate if a signal is + * received, (2) interrupts may be disabled! They will be re- + * enabled while the task sleeps and automatically re-enabled when + * the task restarts. + */ + + ret = net_lockedwait(&state.ir_sem); + + /* Make sure that no further interrupts are processed */ + + tcp_callback_free(conn, state.ir_cb); + ret = inet_recvfrom_result(ret, &state); + } + else + { + ret = -EBUSY; + } + } + + net_unlock(); + inet_recvfrom_uninitialize(&state); + return (ssize_t)ret; +} +#endif /* NET_TCP_HAVE_STACK */ + +/**************************************************************************** + * Public Functions + ****************************************************************************/ + +/**************************************************************************** + * Name: inet_recvfrom + * + * Description: + * Implements the socket recvfrom interface for the case of the AF_INET + * and AF_INET6 address families. inet_recvfrom() receives messages from + * a socket, and may be used to receive data on a socket whether or not it + * is connection-oriented. + * + * If 'from' is not NULL, and the underlying protocol provides the source + * address, this source address is filled in. The argument 'fromlen' is + * initialized to the size of the buffer associated with from, and + * modified on return to indicate the actual size of the address stored + * there. + * + * Parameters: + * psock A pointer to a NuttX-specific, internal socket structure + * buf Buffer to receive data + * len Length of buffer + * flags Receive flags + * from Address of source (may be NULL) + * fromlen The length of the address structure + * + * Returned Value: + * On success, returns the number of characters received. If no data is + * available to be received and the peer has performed an orderly shutdown, + * recv() will return 0. Otherwise, on errors, a negated errno value is + * returned (see recvfrom() for the list of appropriate error values). + * + ****************************************************************************/ + +ssize_t inet_recvfrom(FAR struct socket *psock, FAR void *buf, size_t len, + int flags, FAR struct sockaddr *from, + FAR socklen_t *fromlen) +{ + ssize_t ret; + + /* If a 'from' address has been provided, verify that it is large + * enough to hold this address family. + */ + + if (from) + { + socklen_t minlen; + + /* Get the minimum socket length */ + + switch (psock->s_domain) + { +#ifdef CONFIG_NET_IPv4 + case PF_INET: + { + minlen = sizeof(struct sockaddr_in); + } + break; +#endif + +#ifdef CONFIG_NET_IPv6 + case PF_INET6: + { + minlen = sizeof(struct sockaddr_in6); + } + break; +#endif + + default: + DEBUGPANIC(); + return -EINVAL; + } + + if (*fromlen < minlen) + { + return -EINVAL; + } + } + + /* Read from the network interface driver buffer */ + /* Or perform the TCP/IP or UDP recv() operation */ + + switch (psock->s_type) + { +#ifdef CONFIG_NET_TCP + case SOCK_STREAM: + { +#ifdef NET_TCP_HAVE_STACK + ret = inet_tcp_recvfrom(psock, buf, len, from, fromlen); +#else + ret = -ENOSYS; +#endif + } + break; +#endif /* CONFIG_NET_TCP */ + +#ifdef CONFIG_NET_UDP + case SOCK_DGRAM: + { +#ifdef NET_UDP_HAVE_STACK + ret = inet_udp_recvfrom(psock, buf, len, from, fromlen); +#else + ret = -ENOSYS; +#endif + } + break; +#endif /* CONFIG_NET_UDP || CONFIG_NET_LOCAL_DGRAM */ + + default: + { + nerr("ERROR: Unsupported socket type: %d\n", psock->s_type); + ret = -ENOSYS; + } + break; + } + + return ret; +} + +#endif /* CONFIG_NET */ diff --git a/net/socket/inet_sockif.c b/net/socket/inet_sockif.c index 62f8de0eb5..4866afd695 100644 --- a/net/socket/inet_sockif.c +++ b/net/socket/inet_sockif.c @@ -70,9 +70,10 @@ static ssize_t inet_sendto(FAR struct socket *psock, FAR const void *buf, const struct sock_intf_s g_inet_sockif = { - inet_setup, /* si_setup */ - inet_send, /* si_send */ - inet_sendto, /* si_sendto */ + inet_setup, /* si_setup */ + inet_send, /* si_send */ + inet_sendto, /* si_sendto */ + inet_recvfrom /* si_recvfrom */ }; /**************************************************************************** @@ -237,9 +238,9 @@ static int inet_setup(FAR struct socket *psock, int protocol) * flags Send flags * * Returned Value: - * On success, returns the number of characters sent. On error, -1 is - * returned, and errno is set appropriately (see send() for the list of - * appropriate errors values. + * On success, returns the number of characters sent. On error, a negated + * errno value is returned (see send() for the list of appropriate error + * values. * ****************************************************************************/ @@ -333,9 +334,9 @@ static ssize_t inet_send(FAR struct socket *psock, FAR const void *buf, * tolen The length of the address structure * * Returned Value: - * On success, returns the number of characters sent. On error, -1 is - * returned, and errno is set appropriately (see send_to() for the list of - * appropriate errors values. + * On success, returns the number of characters sent. On error, a negated + * errno value is returned (see send_to() for the list of appropriate error + * values. * ****************************************************************************/ diff --git a/net/socket/recvfrom.c b/net/socket/recvfrom.c index ab16ee9c66..9b576cbcb8 100644 --- a/net/socket/recvfrom.c +++ b/net/socket/recvfrom.c @@ -1,7 +1,7 @@ /**************************************************************************** * net/socket/recvfrom.c * - * Copyright (C) 2007-2009, 2011-2016 Gregory Nutt. All rights reserved. + * Copyright (C) 2007-2009, 2011-2017 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without @@ -39,1758 +39,16 @@ #include -#ifdef CONFIG_NET - -#include -#include -#include -#include -#include -#include #include +#include -#ifdef CONFIG_NET_PKT -# include -#endif - -#include - -#include -#include #include #include -#include -#include -#include -#include -#include -#include "netdev/netdev.h" -#include "devif/devif.h" -#include "tcp/tcp.h" -#include "udp/udp.h" -#include "pkt/pkt.h" -#include "local/local.h" #include "socket/socket.h" #include "usrsock/usrsock.h" -/**************************************************************************** - * Pre-processor Definitions - ****************************************************************************/ - -#define IPv4BUF ((struct ipv4_hdr_s *)&dev->d_buf[NET_LL_HDRLEN(dev)]) -#define IPv6BUF ((struct ipv6_hdr_s *)&dev->d_buf[NET_LL_HDRLEN(dev)]) - -#define UDPIPv4BUF ((struct udp_hdr_s *)&dev->d_buf[NET_LL_HDRLEN(dev) + IPv4_HDRLEN]) -#define UDPIPv6BUF ((struct udp_hdr_s *)&dev->d_buf[NET_LL_HDRLEN(dev) + IPv6_HDRLEN]) - -#define TCPIPv4BUF ((struct tcp_hdr_s *)&dev->d_buf[NET_LL_HDRLEN(dev) + IPv4_HDRLEN]) -#define TCPIPv6BUF ((struct tcp_hdr_s *)&dev->d_buf[NET_LL_HDRLEN(dev) + IPv6_HDRLEN]) - -/**************************************************************************** - * Private Types - ****************************************************************************/ - -#if defined(NET_UDP_HAVE_STACK) || defined(NET_TCP_HAVE_STACK) \ - || defined(CONFIG_NET_PKT) -struct recvfrom_s -{ - FAR struct socket *rf_sock; /* The parent socket structure */ -#ifdef CONFIG_NET_SOCKOPTS - systime_t rf_starttime; /* rcv start time for determining timeout */ -#endif - FAR struct devif_callback_s *rf_cb; /* Reference to callback instance */ - sem_t rf_sem; /* Semaphore signals recv completion */ - size_t rf_buflen; /* Length of receive buffer */ - uint8_t *rf_buffer; /* Pointer to receive buffer */ - FAR struct sockaddr *rf_from; /* Address of sender */ - FAR socklen_t *rf_fromlen; /* Number of bytes allocated for address of sender */ - ssize_t rf_recvlen; /* The received length */ - int rf_result; /* Success:OK, failure:negated errno */ -}; -#endif /* NET_UDP_HAVE_STACK || NET_TCP_HAVE_STACK */ - -/**************************************************************************** - * Private Functions - ****************************************************************************/ - -/**************************************************************************** - * Name: recvfrom_add_recvlen - * - * Description: - * Update information about space available for new data and update size - * of data in buffer, This logic accounts for the case where - * recvfrom_udpreadahead() sets state.rf_recvlen == -1 . - * - * Parameters: - * pstate recvfrom state structure - * recvlen size of new data appended to buffer - * - * Returned Value: - * None - * - ****************************************************************************/ - -#if defined(NET_UDP_HAVE_STACK) || defined(NET_TCP_HAVE_STACK) \ - || defined(CONFIG_NET_PKT) - -static inline void recvfrom_add_recvlen(FAR struct recvfrom_s *pstate, - size_t recvlen) -{ - if (pstate->rf_recvlen < 0) - { - pstate->rf_recvlen = 0; - } - - pstate->rf_recvlen += recvlen; - pstate->rf_buffer += recvlen; - pstate->rf_buflen -= recvlen; -} -#endif /* NET_UDP_HAVE_STACK || NET_TCP_HAVE_STACK || CONFIG_NET_PKT */ - -/**************************************************************************** - * Name: recvfrom_newdata - * - * Description: - * Copy the read data from the packet - * - * Parameters: - * dev The structure of the network driver that caused the interrupt - * pstate recvfrom state structure - * - * Returned Value: - * The number of bytes taken from the packet. - * - * Assumptions: - * The network is locked. - * - ****************************************************************************/ - -#if defined(NET_UDP_HAVE_STACK) || defined(NET_TCP_HAVE_STACK) -static size_t recvfrom_newdata(FAR struct net_driver_s *dev, - FAR struct recvfrom_s *pstate) -{ - size_t recvlen; - - /* Get the length of the data to return */ - - if (dev->d_len > pstate->rf_buflen) - { - recvlen = pstate->rf_buflen; - } - else - { - recvlen = dev->d_len; - } - - /* Copy the new appdata into the user buffer */ - - memcpy(pstate->rf_buffer, dev->d_appdata, recvlen); - ninfo("Received %d bytes (of %d)\n", (int)recvlen, (int)dev->d_len); - - /* Update the accumulated size of the data read */ - - recvfrom_add_recvlen(pstate, recvlen); - - return recvlen; -} -#endif /* NET_UDP_HAVE_STACK || NET_TCP_HAVE_STACK */ - -/**************************************************************************** - * Name: recvfrom_newpktdata - * - * Description: - * Copy the read data from the packet - * - * Parameters: - * dev The structure of the network driver that caused the interrupt - * pstate recvfrom state structure - * - * Returned Value: - * None. - * - * Assumptions: - * The network is locked. - * - ****************************************************************************/ - -#ifdef CONFIG_NET_PKT -static void recvfrom_newpktdata(FAR struct net_driver_s *dev, - FAR struct recvfrom_s *pstate) -{ - size_t recvlen; - - if (dev->d_len > pstate->rf_buflen) - { - recvlen = pstate->rf_buflen; - } - else - { - recvlen = dev->d_len; - } - - /* Copy the new packet data into the user buffer */ - - memcpy(pstate->rf_buffer, dev->d_buf, recvlen); - ninfo("Received %d bytes (of %d)\n", (int)recvlen, (int)dev->d_len); - - /* Update the accumulated size of the data read */ - - recvfrom_add_recvlen(pstate, recvlen); -} -#endif /* CONFIG_NET_PKT */ - -/**************************************************************************** - * Name: recvfrom_newtcpdata - * - * Description: - * Copy the read data from the packet - * - * Parameters: - * dev The structure of the network driver that caused the interrupt - * pstate recvfrom state structure - * - * Returned Value: - * None. - * - * Assumptions: - * The network is locked. - * - ****************************************************************************/ - -#ifdef NET_TCP_HAVE_STACK -static inline void recvfrom_newtcpdata(FAR struct net_driver_s *dev, - FAR struct recvfrom_s *pstate) -{ - /* Take as much data from the packet as we can */ - - size_t recvlen = recvfrom_newdata(dev, pstate); - - /* If there is more data left in the packet that we could not buffer, then - * add it to the read-ahead buffers. - */ - - if (recvlen < dev->d_len) - { -#ifdef CONFIG_NET_TCP_READAHEAD - FAR struct tcp_conn_s *conn = (FAR struct tcp_conn_s *)pstate->rf_sock->s_conn; - FAR uint8_t *buffer = (FAR uint8_t *)dev->d_appdata + recvlen; - uint16_t buflen = dev->d_len - recvlen; -#ifdef CONFIG_DEBUG_NET - uint16_t nsaved; - - nsaved = tcp_datahandler(conn, buffer, buflen); -#else - (void)tcp_datahandler(conn, buffer, buflen); -#endif - - /* There are complicated buffering issues that are not addressed fully - * here. For example, what if up_datahandler() cannot buffer the - * remainder of the packet? In that case, the data will be dropped but - * still ACKed. Therefore it would not be resent. - * - * This is probably not an issue here because we only get here if the - * read-ahead buffers are empty and there would have to be something - * serioulsy wrong with the configuration not to be able to buffer a - * partial packet in this context. - */ - -#ifdef CONFIG_DEBUG_NET - if (nsaved < buflen) - { - nerr("ERROR: packet data not saved (%d bytes)\n", buflen - nsaved); - } -#endif -#else - nerr("ERROR: packet data lost (%d bytes)\n", dev->d_len - recvlen); -#endif - } - - /* Indicate no data in the buffer */ - - dev->d_len = 0; -} -#endif /* NET_TCP_HAVE_STACK */ - -/**************************************************************************** - * Name: recvfrom_newudpdata - * - * Description: - * Copy the read data from the packet - * - * Parameters: - * dev The sructure of the network driver that caused the interrupt - * pstate recvfrom state structure - * - * Returned Value: - * None. - * - * Assumptions: - * The network is locked. - * - ****************************************************************************/ - -#ifdef NET_UDP_HAVE_STACK -static inline void recvfrom_newudpdata(FAR struct net_driver_s *dev, - FAR struct recvfrom_s *pstate) -{ - /* Take as much data from the packet as we can */ - - (void)recvfrom_newdata(dev, pstate); - - /* Indicate no data in the buffer */ - - dev->d_len = 0; -} -#endif /* NET_UDP_HAVE_STACK */ - -/**************************************************************************** - * Name: recvfrom_tcpreadahead - * - * Description: - * Copy the read data from the packet - * - * Parameters: - * dev The structure of the network driver that caused the interrupt - * pstate recvfrom state structure - * - * Returned Value: - * None - * - * Assumptions: - * The network is locked. - * - ****************************************************************************/ - -#if defined(NET_TCP_HAVE_STACK) && defined(CONFIG_NET_TCP_READAHEAD) -static inline void recvfrom_tcpreadahead(struct recvfrom_s *pstate) -{ - FAR struct tcp_conn_s *conn = (FAR struct tcp_conn_s *)pstate->rf_sock->s_conn; - FAR struct iob_s *iob; - int recvlen; - - /* Check there is any TCP data already buffered in a read-ahead - * buffer. - */ - - while ((iob = iob_peek_queue(&conn->readahead)) != NULL && - pstate->rf_buflen > 0) - { - DEBUGASSERT(iob->io_pktlen > 0); - - /* Transfer that buffered data from the I/O buffer chain into - * the user buffer. - */ - - recvlen = iob_copyout(pstate->rf_buffer, iob, pstate->rf_buflen, 0); - ninfo("Received %d bytes (of %d)\n", recvlen, iob->io_pktlen); - - /* Update the accumulated size of the data read */ - - recvfrom_add_recvlen(pstate, recvlen); - - /* If we took all of the ata from the I/O buffer chain is empty, then - * release it. If there is still data available in the I/O buffer - * chain, then just trim the data that we have taken from the - * beginning of the I/O buffer chain. - */ - - if (recvlen >= iob->io_pktlen) - { - FAR struct iob_s *tmp; - - /* Remove the I/O buffer chain from the head of the read-ahead - * buffer queue. - */ - - tmp = iob_remove_queue(&conn->readahead); - DEBUGASSERT(tmp == iob); - UNUSED(tmp); - - /* And free the I/O buffer chain */ - - (void)iob_free_chain(iob); - } - else - { - /* The bytes that we have received from the head of the I/O - * buffer chain (probably changing the head of the I/O - * buffer queue). - */ - - (void)iob_trimhead_queue(&conn->readahead, recvlen); - } - } -} -#endif /* NET_TCP_HAVE_STACK && CONFIG_NET_TCP_READAHEAD */ - -#if defined(NET_UDP_HAVE_STACK) && defined(CONFIG_NET_UDP_READAHEAD) - -static inline void recvfrom_udpreadahead(struct recvfrom_s *pstate) -{ - FAR struct udp_conn_s *conn = (FAR struct udp_conn_s *)pstate->rf_sock->s_conn; - FAR struct iob_s *iob; - int recvlen; - - /* Check there is any UDP datagram already buffered in a read-ahead - * buffer. - */ - - pstate->rf_recvlen = -1; - - if ((iob = iob_peek_queue(&conn->readahead)) != NULL) - { - FAR struct iob_s *tmp; - uint8_t src_addr_size; - - DEBUGASSERT(iob->io_pktlen > 0); - - /* Transfer that buffered data from the I/O buffer chain into - * the user buffer. - */ - - recvlen = iob_copyout(&src_addr_size, iob, sizeof(uint8_t), 0); - if (recvlen != sizeof(uint8_t)) - { - goto out; - } - - if (0 -#ifdef CONFIG_NET_IPv6 - || src_addr_size == sizeof(struct sockaddr_in6) -#endif -#ifdef CONFIG_NET_IPv4 - || src_addr_size == sizeof(struct sockaddr_in) -#endif - ) - { - if (pstate->rf_from) - { - socklen_t len = *pstate->rf_fromlen; - len = (socklen_t)src_addr_size > len ? len : (socklen_t)src_addr_size; - - recvlen = iob_copyout((FAR uint8_t *)pstate->rf_from, iob, - len, sizeof(uint8_t)); - if (recvlen != len) - { - goto out; - } - } - } - - if (pstate->rf_buflen > 0) - { - recvlen = iob_copyout(pstate->rf_buffer, iob, pstate->rf_buflen, - src_addr_size + sizeof(uint8_t)); - - ninfo("Received %d bytes (of %d)\n", recvlen, iob->io_pktlen); - - /* Update the accumulated size of the data read */ - - pstate->rf_recvlen = recvlen; - pstate->rf_buffer += recvlen; - pstate->rf_buflen -= recvlen; - } - else - { - pstate->rf_recvlen = 0; - } - -out: - /* Remove the I/O buffer chain from the head of the read-ahead - * buffer queue. - */ - - tmp = iob_remove_queue(&conn->readahead); - DEBUGASSERT(tmp == iob); - UNUSED(tmp); - - /* And free the I/O buffer chain */ - - (void)iob_free_chain(iob); - } -} -#endif - -/**************************************************************************** - * Name: recvfrom_timeout - * - * Description: - * Check for recvfrom timeout. - * - * Parameters: - * pstate recvfrom state structure - * - * Returned Value: - * TRUE:timeout FALSE:no timeout - * - * Assumptions: - * The network is locked. - * - ****************************************************************************/ - -#if defined(NET_UDP_HAVE_STACK) || defined(NET_TCP_HAVE_STACK) -#ifdef CONFIG_NET_SOCKOPTS -static int recvfrom_timeout(struct recvfrom_s *pstate) -{ - FAR struct socket *psock = 0; - socktimeo_t timeo = 0; - - /* Check for a timeout configured via setsockopts(SO_RCVTIMEO). If none... - * we well let the read hang forever (except for the special case below). - */ - - /* Get the socket reference from the private data */ - - psock = pstate->rf_sock; - if (psock) - { - /* Recover the timeout value (zero if no timeout) */ - - timeo = psock->s_rcvtimeo; - } - - /* Use a fixed, configurable delay under the following circumstances: - * - * 1) This delay function has been enabled with CONFIG_NET_TCP_RECVDELAY > 0 - * 2) Some data has already been received from the socket. Since this can - * only be true for a TCP/IP socket, this logic applies only to TCP/IP - * sockets. And either - * 3) There is no configured receive timeout, or - * 4) The configured receive timeout is greater than than the delay - */ - -#if CONFIG_NET_TCP_RECVDELAY > 0 - if ((timeo == 0 || timeo > CONFIG_NET_TCP_RECVDELAY) && - pstate->rf_recvlen > 0) - { - /* Use the configured timeout */ - - timeo = CONFIG_NET_TCP_RECVDELAY; - } -#endif - - /* Is there an effective timeout? */ - - if (timeo) - { - /* Yes.. Check if the timeout has elapsed */ - - return net_timeo(pstate->rf_starttime, timeo); - } - - /* No timeout -- hang forever waiting for data. */ - - return FALSE; -} -#endif /* CONFIG_NET_SOCKOPTS */ -#endif /* NET_UDP_HAVE_STACK || NET_TCP_HAVE_STACK */ - -/**************************************************************************** - * Name: recvfrom_pktsender - * - * Description: - * - * Parameters: - * - * Returned Values: - * - * Assumptions: - * - ****************************************************************************/ - -#ifdef CONFIG_NET_PKT -static inline void recvfrom_pktsender(FAR struct net_driver_s *dev, - FAR struct recvfrom_s *pstate) -{ -} -#endif /* CONFIG_NET_PKT */ - -/**************************************************************************** - * Name: recvfrom_pktinterrupt - * - * Description: - * - * Parameters: - * - * Returned Values: - * - * Assumptions: - * - ****************************************************************************/ - -#ifdef CONFIG_NET_PKT -static uint16_t recvfrom_pktinterrupt(FAR struct net_driver_s *dev, - FAR void *pvconn, FAR void *pvpriv, - uint16_t flags) -{ - struct recvfrom_s *pstate = (struct recvfrom_s *)pvpriv; - - ninfo("flags: %04x\n", flags); - - /* 'priv' might be null in some race conditions (?) */ - - if (pstate) - { - /* If a new packet is available, then complete the read action. */ - - if ((flags & PKT_NEWDATA) != 0) - { - /* Copy the packet */ - recvfrom_newpktdata(dev, pstate); - - /* We are finished. */ - - ninfo("PKT done\n"); - - /* Don't allow any further call backs. */ - - pstate->rf_cb->flags = 0; - pstate->rf_cb->priv = NULL; - pstate->rf_cb->event = NULL; -#if 0 - /* Save the sender's address in the caller's 'from' location */ - - recvfrom_pktsender(dev, pstate); -#endif - /* indicate that the data has been consumed */ - - flags &= ~PKT_NEWDATA; - - /* Wake up the waiting thread, returning the number of bytes - * actually read. - */ - - sem_post(&pstate->rf_sem); - } - } - - return flags; -} -#endif /* CONFIG_NET_PKT */ - -/**************************************************************************** - * Name: recvfrom_tcpsender - * - * Description: - * Getting the sender's address from the UDP packet - * - * Parameters: - * dev - The device driver data structure - * pstate - the recvfrom state structure - * - * Returned Value: - * None - * - * Assumptions: - * Running at the interrupt level - * - ****************************************************************************/ - -#ifdef NET_TCP_HAVE_STACK -static inline void recvfrom_tcpsender(FAR struct net_driver_s *dev, - FAR struct recvfrom_s *pstate) -{ - /* Get the family from the packet type, IP address from the IP header, and - * the port number from the TCP header. - */ - -#ifdef CONFIG_NET_IPv6 -#ifdef CONFIG_NET_IPv4 - if (IFF_IS_IPv6(dev->d_flags)) -#endif - { - FAR struct sockaddr_in6 *infrom = - (FAR struct sockaddr_in6 *)pstate->rf_from; - - if (infrom) - { - FAR struct tcp_hdr_s *tcp = TCPIPv6BUF; - FAR struct ipv6_hdr_s *ipv6 = IPv6BUF; - - infrom->sin6_family = AF_INET6; - infrom->sin6_port = tcp->srcport; - - net_ipv6addr_copy(infrom->sin6_addr.s6_addr, ipv6->srcipaddr); - } - } -#endif /* CONFIG_NET_IPv6 */ - -#ifdef CONFIG_NET_IPv4 -#ifdef CONFIG_NET_IPv6 - else -#endif - { - FAR struct sockaddr_in *infrom = - (FAR struct sockaddr_in *)pstate->rf_from; - - if (infrom) - { - FAR struct tcp_hdr_s *tcp = TCPIPv4BUF; - FAR struct ipv4_hdr_s *ipv4 = IPv4BUF; - - infrom->sin_family = AF_INET; - infrom->sin_port = tcp->srcport; - - net_ipv4addr_copy(infrom->sin_addr.s_addr, - net_ip4addr_conv32(ipv4->srcipaddr)); - } - } -#endif /* CONFIG_NET_IPv4 */ -} -#endif /* NET_TCP_HAVE_STACK */ - -/**************************************************************************** - * Name: recvfrom_tcpinterrupt - * - * Description: - * This function is called from the interrupt level to perform the actual - * TCP receive operation via by the lower, device interfacing layer. - * - * Parameters: - * dev The structure of the network driver that caused the interrupt - * pvconn The connection structure associated with the socket - * flags Set of events describing why the callback was invoked - * - * Returned Value: - * None - * - * Assumptions: - * The network is locked. - * - ****************************************************************************/ - -#ifdef NET_TCP_HAVE_STACK -static uint16_t recvfrom_tcpinterrupt(FAR struct net_driver_s *dev, - FAR void *pvconn, FAR void *pvpriv, - uint16_t flags) -{ - FAR struct recvfrom_s *pstate = (struct recvfrom_s *)pvpriv; - -#if 0 /* REVISIT: The assertion fires. Why? */ -#ifdef CONFIG_NETDEV_MULTINIC - FAR struct tcp_conn_s *conn = (FAR struct tcp_conn_s *)pvconn; - - /* The TCP socket is connected and, hence, should be bound to a device. - * Make sure that the polling device is the own that we are bound to. - */ - - DEBUGASSERT(conn->dev == NULL || conn->dev == dev); - if (conn->dev != NULL && conn->dev != dev) - { - return flags; - } -#endif -#endif - - ninfo("flags: %04x\n", flags); - - /* 'priv' might be null in some race conditions (?) */ - - if (pstate) - { - /* If new data is available, then complete the read action. */ - - if ((flags & TCP_NEWDATA) != 0) - { - /* Copy the data from the packet (saving any unused bytes from the - * packet in the read-ahead buffer). - */ - - recvfrom_newtcpdata(dev, pstate); - - /* Save the sender's address in the caller's 'from' location */ - - recvfrom_tcpsender(dev, pstate); - - /* Indicate that the data has been consumed and that an ACK - * should be sent. - */ - - flags = (flags & ~TCP_NEWDATA) | TCP_SNDACK; - - /* Check for transfer complete. We will consider the transfer - * complete in own of two different ways, depending on the setting - * of CONFIG_NET_TCP_RECVDELAY. - * - * 1) If CONFIG_NET_TCP_RECVDELAY == 0 then we will consider the - * TCP/IP transfer complete as soon as any data has been received. - * This is safe because if any additional data is received, it - * will be retained in the TCP/IP read-ahead buffer until the - * next receive is performed. - * 2) CONFIG_NET_TCP_RECVDELAY > 0 may be set to wait a little - * bit to determine if more data will be received. You might - * do this if read-ahead buffering is disabled and we want to - * minimize the loss of back-to-back packets. In this case, - * the transfer is complete when either a) the entire user buffer - * is full or 2) when the receive timeout occurs (below). - */ - -#if CONFIG_NET_TCP_RECVDELAY > 0 - if (pstate->rf_buflen == 0) -#else - if (pstate->rf_recvlen > 0) -#endif - { - ninfo("TCP resume\n"); - - /* The TCP receive buffer is non-empty. Return now and don't - * allow any further TCP call backs. - */ - - pstate->rf_cb->flags = 0; - pstate->rf_cb->priv = NULL; - pstate->rf_cb->event = NULL; - - /* Wake up the waiting thread, returning the number of bytes - * actually read. - */ - - sem_post(&pstate->rf_sem); - } - -#ifdef CONFIG_NET_SOCKOPTS - /* Reset the timeout. We will want a short timeout to terminate - * the TCP receive. - */ - - pstate->rf_starttime = clock_systimer(); -#endif - } - - /* Check for a loss of connection. - * - * TCP_DISCONN_EVENTS: - * TCP_CLOSE: The remote host has closed the connection - * TCP_ABORT: The remote host has aborted the connection - * TCP_TIMEDOUT: Connection aborted due to too many retransmissions. - * NETDEV_DOWN: The network device went down - */ - - else if ((flags & TCP_DISCONN_EVENTS) != 0) - { - ninfo("Lost connection\n"); - - /* Stop further callbacks */ - - pstate->rf_cb->flags = 0; - pstate->rf_cb->priv = NULL; - pstate->rf_cb->event = NULL; - - /* Handle loss-of-connection event */ - - net_lostconnection(pstate->rf_sock, flags); - - /* Check if the peer gracefully closed the connection. */ - - if ((flags & TCP_CLOSE) != 0) - { - /* This case should always return success (zero)! The value of - * rf_recvlen, if zero, will indicate that the connection was - * gracefully closed. - */ - - pstate->rf_result = 0; - } - else - { - /* If no data has been received, then return ENOTCONN. - * Otherwise, let this return success. The failure will - * be reported the next time that recv[from]() is called. - */ - -#if CONFIG_NET_TCP_RECVDELAY > 0 - if (pstate->rf_recvlen > 0) - { - pstate->rf_result = 0; - } - else - { - pstate->rf_result = -ENOTCONN; - } -#else - pstate->rf_result = -ENOTCONN; -#endif - } - - /* Wake up the waiting thread */ - - sem_post(&pstate->rf_sem); - } - -#ifdef CONFIG_NET_SOCKOPTS - /* No data has been received -- this is some other event... probably a - * poll -- check for a timeout. - */ - - else if (recvfrom_timeout(pstate)) - { - /* Yes.. the timeout has elapsed... do not allow any further - * callbacks - */ - - ninfo("TCP timeout\n"); - - pstate->rf_cb->flags = 0; - pstate->rf_cb->priv = NULL; - pstate->rf_cb->event = NULL; - - /* Report an error only if no data has been received. (If - * CONFIG_NET_TCP_RECVDELAY then rf_recvlen should always be - * less than or equal to zero). - */ - -#if CONFIG_NET_TCP_RECVDELAY > 0 - if (pstate->rf_recvlen <= 0) -#endif - { - /* Report the timeout error */ - - pstate->rf_result = -EAGAIN; - } - - /* Wake up the waiting thread, returning either the error -EAGAIN - * that signals the timeout event or the data received up to - * the point that the timeout occurred (no error). - */ - - sem_post(&pstate->rf_sem); - } -#endif /* CONFIG_NET_SOCKOPTS */ - } - - return flags; -} -#endif /* NET_TCP_HAVE_STACK */ - -/**************************************************************************** - * Name: recvfrom_udpsender - * - * Description: - * Getting the sender's address from the UDP packet - * - * Parameters: - * dev - The device driver data structure - * pstate - the recvfrom state structure - * - * Returned Value: - * None - * - * Assumptions: - * The network is locked. - * - ****************************************************************************/ - -#ifdef NET_UDP_HAVE_STACK -static inline void recvfrom_udpsender(struct net_driver_s *dev, struct recvfrom_s *pstate) -{ - /* Get the family from the packet type, IP address from the IP header, and - * the port number from the UDP header. - */ - -#ifdef CONFIG_NET_IPv6 -#ifdef CONFIG_NET_IPv4 - if (IFF_IS_IPv6(dev->d_flags)) -#endif - { - FAR struct sockaddr_in6 *infrom = - (FAR struct sockaddr_in6 *)pstate->rf_from; - FAR socklen_t *fromlen = pstate->rf_fromlen; - - if (infrom) - { - FAR struct udp_hdr_s *udp = UDPIPv6BUF; - FAR struct ipv6_hdr_s *ipv6 = IPv6BUF; - - infrom->sin6_family = AF_INET6; - infrom->sin6_port = udp->srcport; - *fromlen = sizeof(struct sockaddr_in6); - - net_ipv6addr_copy(infrom->sin6_addr.s6_addr, ipv6->srcipaddr); - } - } -#endif /* CONFIG_NET_IPv6 */ - -#ifdef CONFIG_NET_IPv4 -#ifdef CONFIG_NET_IPv6 - else -#endif - { - FAR struct sockaddr_in *infrom = - (FAR struct sockaddr_in *)pstate->rf_from; - - if (infrom) - { -#ifdef CONFIG_NET_IPv6 - FAR struct udp_conn_s *conn = - (FAR struct udp_conn_s *)pstate->rf_sock->s_conn; - - /* Hybrid dual-stack IPv6/IPv4 implementations recognize a special - * class of addresses, the IPv4-mapped IPv6 addresses. - */ - - if (conn->domain == PF_INET6) - { - FAR struct sockaddr_in6 *infrom6 = (FAR struct sockaddr_in6 *)infrom; - FAR socklen_t *fromlen = pstate->rf_fromlen; - FAR struct udp_hdr_s *udp = UDPIPv6BUF; - FAR struct ipv6_hdr_s *ipv6 = IPv6BUF; - in_addr_t ipv4addr; - - /* Encode the IPv4 address as an IPv4-mapped IPv6 address */ - - infrom6->sin6_family = AF_INET6; - infrom6->sin6_port = udp->srcport; - *fromlen = sizeof(struct sockaddr_in6); - - ipv4addr = net_ip4addr_conv32(ipv6->srcipaddr); - ip6_map_ipv4addr(ipv4addr, infrom6->sin6_addr.s6_addr16); - } - else -#endif - { - FAR struct udp_hdr_s *udp = UDPIPv4BUF; - FAR struct ipv4_hdr_s *ipv4 = IPv4BUF; - - infrom->sin_family = AF_INET; - infrom->sin_port = udp->srcport; - - net_ipv4addr_copy(infrom->sin_addr.s_addr, - net_ip4addr_conv32(ipv4->srcipaddr)); - } - } - } -#endif /* CONFIG_NET_IPv4 */ -} -#endif /* NET_UDP_HAVE_STACK */ - -/**************************************************************************** - * Name: recvfrom_udp_terminate - * - * Description: - * Terminate the UDP transfer. - * - * Parameters: - * pstate - The recvfrom state structure - * result - The result of the operation - * - * Returned Value: - * None - * - ****************************************************************************/ - -#ifdef NET_UDP_HAVE_STACK -static void recvfrom_udp_terminate(FAR struct recvfrom_s *pstate, int result) -{ - /* Don't allow any further UDP call backs. */ - - pstate->rf_cb->flags = 0; - pstate->rf_cb->priv = NULL; - pstate->rf_cb->event = NULL; - - /* Save the result of the transfer */ - - pstate->rf_result = result; - - /* Wake up the waiting thread, returning the number of bytes - * actually read. - */ - - sem_post(&pstate->rf_sem); -} -#endif /* NET_UDP_HAVE_STACK */ - -/**************************************************************************** - * Name: recvfrom_udp_interrupt - * - * Description: - * This function is called from the interrupt level to perform the actual - * UDP receive operation via by the lower, device interfacing layer. - * - * Parameters: - * dev The structure of the network driver that caused the interrupt - * pvconn The connection structure associated with the socket - * flags Set of events describing why the callback was invoked - * - * Returned Value: - * None - * - * Assumptions: - * The network is locked. - * - ****************************************************************************/ - -#ifdef NET_UDP_HAVE_STACK -static uint16_t recvfrom_udp_interrupt(FAR struct net_driver_s *dev, - FAR void *pvconn, FAR void *pvpriv, - uint16_t flags) -{ - FAR struct recvfrom_s *pstate = (FAR struct recvfrom_s *)pvpriv; - - ninfo("flags: %04x\n", flags); - - /* 'priv' might be null in some race conditions (?) */ - - if (pstate) - { - /* If the network device has gone down, then we will have terminate - * the wait now with an error. - */ - - if ((flags & NETDEV_DOWN) != 0) - { - /* Terminate the transfer with an error. */ - - nerr("ERROR: Network is down\n"); - recvfrom_udp_terminate(pstate, -ENETUNREACH); - } - - /* If new data is available, then complete the read action. */ - - else if ((flags & UDP_NEWDATA) != 0) - { - /* Copy the data from the packet */ - - recvfrom_newudpdata(dev, pstate); - - /* We are finished. */ - - ninfo("UDP done\n"); - - /* Save the sender's address in the caller's 'from' location */ - - recvfrom_udpsender(dev, pstate); - - /* Don't allow any further UDP call backs. */ - - recvfrom_udp_terminate(pstate, OK); - - /* Indicate that the data has been consumed */ - - flags &= ~UDP_NEWDATA; - } - -#ifdef CONFIG_NET_SOCKOPTS - /* No data has been received -- this is some other event... probably a - * poll -- check for a timeout. - */ - - else if (recvfrom_timeout(pstate)) - { - /* Yes.. the timeout has elapsed... do not allow any further - * callbacks - */ - - nerr("ERROR: UDP timeout\n"); - - /* Terminate the transfer with an -EAGAIN error */ - - recvfrom_udp_terminate(pstate, -EAGAIN); - } -#endif /* CONFIG_NET_SOCKOPTS */ - } - - return flags; -} -#endif /* NET_UDP_HAVE_STACK */ - -/**************************************************************************** - * Name: recvfrom_init - * - * Description: - * Initialize the state structure - * - * Parameters: - * psock Pointer to the socket structure for the socket - * buf Buffer to receive data - * len Length of buffer - * pstate A pointer to the state structure to be initialized - * - * Returned Value: - * None - * - * Assumptions: - * - ****************************************************************************/ - -#if defined(NET_UDP_HAVE_STACK) || defined(NET_TCP_HAVE_STACK) \ - || defined(CONFIG_NET_PKT) -static void recvfrom_init(FAR struct socket *psock, FAR void *buf, - size_t len, FAR struct sockaddr *infrom, - FAR socklen_t *fromlen, - FAR struct recvfrom_s *pstate) -{ - /* Initialize the state structure. */ - - memset(pstate, 0, sizeof(struct recvfrom_s)); - - /* This semaphore is used for signaling and, hence, should not have - * priority inheritance enabled. - */ - - (void)sem_init(&pstate->rf_sem, 0, 0); /* Doesn't really fail */ - (void)sem_setprotocol(&pstate->rf_sem, SEM_PRIO_NONE); - - pstate->rf_buflen = len; - pstate->rf_buffer = buf; - pstate->rf_from = infrom; - pstate->rf_fromlen = fromlen; - - /* Set up the start time for the timeout */ - - pstate->rf_sock = psock; -#ifdef CONFIG_NET_SOCKOPTS - pstate->rf_starttime = clock_systimer(); -#endif -} - -/* The only un-initialization that has to be performed is destroying the - * semaphore. - */ - -#define recvfrom_uninit(s) sem_destroy(&(s)->rf_sem) - -#endif /* NET_UDP_HAVE_STACK || NET_TCP_HAVE_STACK */ - -/**************************************************************************** - * Name: recvfrom_result - * - * Description: - * Evaluate the result of the recv operations - * - * Parameters: - * result The result of the net_lockedwait operation (may indicate EINTR) - * pstate A pointer to the state structure to be initialized - * - * Returned Value: - * The result of the recv operation with errno set appropriately - * - * Assumptions: - * - ****************************************************************************/ - -#if defined(NET_UDP_HAVE_STACK) || defined(NET_TCP_HAVE_STACK) \ - || defined(CONFIG_NET_PKT) -static ssize_t recvfrom_result(int result, struct recvfrom_s *pstate) -{ - int save_errno = get_errno(); /* In case something we do changes it */ - - /* Check for a error/timeout detected by the interrupt handler. Errors are - * signaled by negative errno values for the rcv length - */ - - if (pstate->rf_result < 0) - { - /* This might return EAGAIN on a timeout or ENOTCONN on loss of - * connection (TCP only) - */ - - return pstate->rf_result; - } - - /* If net_lockedwait failed, then we were probably reawakened by a signal. In - * this case, net_lockedwait will have set errno appropriately. - */ - - if (result < 0) - { - return -save_errno; - } - - return pstate->rf_recvlen; -} -#endif /* NET_UDP_HAVE_STACK || NET_TCP_HAVE_STACK */ - -/**************************************************************************** - * Name: recvfromo_pkt_rxnotify - * - * Description: - * Notify the appropriate device driver that we are ready to receive a - * packet (PKT) - * - * Parameters: - * conn - The PKT connection structure - * - * Returned Value: - * None - * - ****************************************************************************/ - -#if 0 /* Not implemented */ -static void recvfromo_pkt_rxnotify(FAR struct pkt_conn_s *conn) -{ -# warning Missing logic -} -#endif - -/**************************************************************************** - * Name: recvfrom_udp_rxnotify - * - * Description: - * Notify the appropriate device driver that we are ready to receive a - * packet (UDP) - * - * Parameters: - * psock - Socket state structure - * conn - The UDP connection structure - * - * Returned Value: - * None - * - ****************************************************************************/ - -#ifdef NET_UDP_HAVE_STACK -static inline void recvfrom_udp_rxnotify(FAR struct socket *psock, - FAR struct udp_conn_s *conn) -{ -#ifdef CONFIG_NET_IPv4 -#ifdef CONFIG_NET_IPv6 - /* If both IPv4 and IPv6 support are enabled, then we will need to select - * the device driver using the appropriate IP domain. - */ - - if (psock->s_domain == PF_INET) -#endif - { - /* Notify the device driver of the receive ready */ - -#ifdef CONFIG_NETDEV_MULTINIC - netdev_ipv4_rxnotify(conn->u.ipv4.laddr, conn->u.ipv4.raddr); -#else - netdev_ipv4_rxnotify(conn->u.ipv4.raddr); -#endif - } -#endif /* CONFIG_NET_IPv4 */ - -#ifdef CONFIG_NET_IPv6 -#ifdef CONFIG_NET_IPv4 - else /* if (psock->s_domain == PF_INET6) */ -#endif /* CONFIG_NET_IPv4 */ - { - /* Notify the device driver of the receive ready */ - - DEBUGASSERT(psock->s_domain == PF_INET6); -#ifdef CONFIG_NETDEV_MULTINIC - netdev_ipv6_rxnotify(conn->u.ipv6.laddr, conn->u.ipv6.raddr); -#else - netdev_ipv6_rxnotify(conn->u.ipv6.raddr); -#endif - } -#endif /* CONFIG_NET_IPv6 */ -} -#endif /* NET_UDP_HAVE_STACK */ - -/**************************************************************************** - * Name: pkt_recvfrom - * - * Description: - * Perform the recvfrom operation for packet socket - * - * Parameters: - * - * Returned Value: - * - * Assumptions: - * - ****************************************************************************/ - -#ifdef CONFIG_NET_PKT -static ssize_t pkt_recvfrom(FAR struct socket *psock, FAR void *buf, size_t len, - FAR struct sockaddr *from, FAR socklen_t *fromlen) -{ - FAR struct pkt_conn_s *conn = (FAR struct pkt_conn_s *)psock->s_conn; - FAR struct net_driver_s *dev; - struct recvfrom_s state; - int ret; - - /* Perform the packet recvfrom() operation */ - - /* Initialize the state structure. This is done with interrupts - * disabled because we don't want anything to happen until we - * are ready. - */ - - net_lock(); - recvfrom_init(psock, buf, len, from, fromlen, &state); - - /* Get the device driver that will service this transfer */ - - dev = pkt_find_device(conn); - if (dev == NULL) - { - ret = -ENODEV; - goto errout_with_state; - } - - /* TODO recvfrom_init() expects from to be of type sockaddr_in, but - * in our case is sockaddr_ll - */ - -#if 0 - ret = pkt_connect(conn, NULL); - if (ret < 0) - { - goto errout_with_state; - } -#endif - - /* Set up the callback in the connection */ - - state.rf_cb = pkt_callback_alloc(dev, conn); - if (state.rf_cb) - { - state.rf_cb->flags = (PKT_NEWDATA | PKT_POLL); - state.rf_cb->priv = (FAR void *)&state; - state.rf_cb->event = recvfrom_pktinterrupt; - - /* Notify the device driver of the receive call */ - -#if 0 /* Not implemented */ - recvfromo_pkt_rxnotify(conn); -#endif - - /* Wait for either the receive to complete or for an error/timeout to occur. - * NOTES: (1) net_lockedwait will also terminate if a signal is received, (2) - * interrupts are disabled! They will be re-enabled while the task sleeps - * and automatically re-enabled when the task restarts. - */ - - ret = net_lockedwait(&state.rf_sem); - - /* Make sure that no further interrupts are processed */ - - pkt_callback_free(dev, conn, state.rf_cb); - ret = recvfrom_result(ret, &state); - } - else - { - ret = -EBUSY; - } - -errout_with_state: - net_unlock(); - recvfrom_uninit(&state); - return ret; -} -#endif /* CONFIG_NET_PKT */ - -/**************************************************************************** - * Name: udp_recvfrom - * - * Description: - * Perform the recvfrom operation for a UDP SOCK_DGRAM - * - * Parameters: - * psock Pointer to the socket structure for the SOCK_DRAM socket - * buf Buffer to receive data - * len Length of buffer - * from INET address of source (may be NULL) - * - * Returned Value: - * On success, returns the number of characters received. On error, - * -errno is returned (see recvfrom for list of errnos). - * - * Assumptions: - * - ****************************************************************************/ - -#ifdef NET_UDP_HAVE_STACK -static ssize_t udp_recvfrom(FAR struct socket *psock, FAR void *buf, size_t len, - FAR struct sockaddr *from, FAR socklen_t *fromlen) -{ - FAR struct udp_conn_s *conn = (FAR struct udp_conn_s *)psock->s_conn; - FAR struct net_driver_s *dev; - struct recvfrom_s state; - int ret; - - /* Perform the UDP recvfrom() operation */ - - /* Initialize the state structure. This is done with interrupts - * disabled because we don't want anything to happen until we - * are ready. - */ - - net_lock(); - recvfrom_init(psock, buf, len, from, fromlen, &state); - - /* Setup the UDP remote connection */ - - ret = udp_connect(conn, NULL); - if (ret < 0) - { - goto errout_with_state; - } - -#ifdef CONFIG_NET_UDP_READAHEAD - recvfrom_udpreadahead(&state); - - /* The default return value is the number of bytes that we just copied - * into the user buffer. We will return this if the socket has become - * disconnected or if the user request was completely satisfied with - * data from the readahead buffers. - */ - - ret = state.rf_recvlen; - -#else - /* Otherwise, the default return value of zero is used (only for the case - * where len == state.rf_buflen is zero). - */ - - ret = 0; -#endif - -#ifdef CONFIG_NET_UDP_READAHEAD - if (_SS_ISNONBLOCK(psock->s_flags)) - { - /* Return the number of bytes read from the read-ahead buffer if - * something was received (already in 'ret'); EAGAIN if not. - */ - - if (ret < 0) - { - /* Nothing was received */ - - ret = -EAGAIN; - } - } - - /* It is okay to block if we need to. If there is space to receive anything - * more, then we will wait to receive the data. Otherwise return the number - * of bytes read from the read-ahead buffer (already in 'ret'). - * - * NOTE: that recvfrom_udpreadahead() may set state.rf_recvlen == -1. - */ - - else if (state.rf_recvlen <= 0) -#endif - { - /* Get the device that will handle the packet transfers. This may be - * NULL if the UDP socket is bound to INADDR_ANY. In that case, no - * NETDEV_DOWN notifications will be received. - */ - - dev = udp_find_laddr_device(conn); - - /* Set up the callback in the connection */ - - state.rf_cb = udp_callback_alloc(dev, conn); - if (state.rf_cb) - { - /* Set up the callback in the connection */ - - state.rf_cb->flags = (UDP_NEWDATA | UDP_POLL | NETDEV_DOWN); - state.rf_cb->priv = (FAR void *)&state; - state.rf_cb->event = recvfrom_udp_interrupt; - - /* Notify the device driver of the receive call */ - - recvfrom_udp_rxnotify(psock, conn); - - /* Wait for either the receive to complete or for an error/timeout - * to occur. NOTES: (1) net_lockedwait will also terminate if a - * signal is received, (2) interrupts are disabled! They will be - * re-enabled while the task sleeps and automatically re-enabled - * when the task restarts. - */ - - ret = net_lockedwait(&state. rf_sem); - - /* Make sure that no further interrupts are processed */ - - udp_callback_free(dev, conn, state.rf_cb); - ret = recvfrom_result(ret, &state); - } - else - { - ret = -EBUSY; - } - } - -errout_with_state: - net_unlock(); - recvfrom_uninit(&state); - return ret; -} -#endif /* NET_UDP_HAVE_STACK */ - -/**************************************************************************** - * Name: tcp_recvfrom - * - * Description: - * Perform the recvfrom operation for a TCP/IP SOCK_STREAM - * - * Parameters: - * psock Pointer to the socket structure for the SOCK_DRAM socket - * buf Buffer to receive data - * len Length of buffer - * from INET address of source (may be NULL) - * - * Returned Value: - * On success, returns the number of characters received. On error, - * -errno is returned (see recvfrom for list of errnos). - * - * Assumptions: - * - ****************************************************************************/ - -#ifdef NET_TCP_HAVE_STACK -static ssize_t tcp_recvfrom(FAR struct socket *psock, FAR void *buf, size_t len, - FAR struct sockaddr *from, FAR socklen_t *fromlen) -{ - struct recvfrom_s state; - int ret; - - /* Initialize the state structure. This is done with interrupts - * disabled because we don't want anything to happen until we - * are ready. - */ - - net_lock(); - recvfrom_init(psock, buf, len, from, fromlen, &state); - - /* Handle any any TCP data already buffered in a read-ahead buffer. NOTE - * that there may be read-ahead data to be retrieved even after the - * socket has been disconnected. - */ - -#ifdef CONFIG_NET_TCP_READAHEAD - recvfrom_tcpreadahead(&state); - - /* The default return value is the number of bytes that we just copied - * into the user buffer. We will return this if the socket has become - * disconnected or if the user request was completely satisfied with - * data from the readahead buffers. - */ - - ret = state.rf_recvlen; - -#else - /* Otherwise, the default return value of zero is used (only for the case - * where len == state.rf_buflen is zero). - */ - - ret = 0; -#endif - - /* Verify that the SOCK_STREAM has been and still is connected */ - - if (!_SS_ISCONNECTED(psock->s_flags)) - { - /* Was any data transferred from the readahead buffer after we were - * disconnected? If so, then return the number of bytes received. We - * will wait to return end disconnection indications the next time that - * recvfrom() is called. - * - * If no data was received (i.e., ret == 0 -- it will not be negative) - * and the connection was gracefully closed by the remote peer, then return - * success. If rf_recvlen is zero, the caller of recvfrom() will get an - * end-of-file indication. - */ - -#ifdef CONFIG_NET_TCP_READAHEAD - if (ret <= 0 && !_SS_ISCLOSED(psock->s_flags)) -#else - if (!_SS_ISCLOSED(psock->s_flags)) -#endif - { - /* Nothing was previously received from the readahead buffers. - * The SOCK_STREAM must be (re-)connected in order to receive any - * additional data. - */ - - ret = -ENOTCONN; - } - } - - /* In general, this implementation will not support non-blocking socket - * operations... except in a few cases: Here for TCP receive with read-ahead - * enabled. If this socket is configured as non-blocking then return EAGAIN - * if no data was obtained from the read-ahead buffers. - */ - - else -#ifdef CONFIG_NET_TCP_READAHEAD - if (_SS_ISNONBLOCK(psock->s_flags)) - { - /* Return the number of bytes read from the read-ahead buffer if - * something was received (already in 'ret'); EAGAIN if not. - */ - - if (ret <= 0) - { - /* Nothing was received */ - - ret = -EAGAIN; - } - } - - /* It is okay to block if we need to. If there is space to receive anything - * more, then we will wait to receive the data. Otherwise return the number - * of bytes read from the read-ahead buffer (already in 'ret'). - */ - - else -#endif - - /* We get here when we we decide that we need to setup the wait for incoming - * TCP/IP data. Just a few more conditions to check: - * - * 1) Make sure thet there is buffer space to receive additional data - * (state.rf_buflen > 0). This could be zero, for example, if read-ahead - * buffering was enabled and we filled the user buffer with data from - * the read-ahead buffers. And - * 2) if read-ahead buffering is enabled (CONFIG_NET_TCP_READAHEAD) - * and delay logic is disabled (CONFIG_NET_TCP_RECVDELAY == 0), then we - * not want to wait if we already obtained some data from the read-ahead - * buffer. In that case, return now with what we have (don't want for more - * because there may be no timeout). - */ - -#if CONFIG_NET_TCP_RECVDELAY == 0 && defined(CONFIG_NET_TCP_READAHEAD) - if (state.rf_recvlen == 0 && state.rf_buflen > 0) -#else - if (state.rf_buflen > 0) -#endif - { - FAR struct tcp_conn_s *conn = (FAR struct tcp_conn_s *)psock->s_conn; - - /* Set up the callback in the connection */ - - state.rf_cb = tcp_callback_alloc(conn); - if (state.rf_cb) - { - state.rf_cb->flags = (TCP_NEWDATA | TCP_POLL | TCP_DISCONN_EVENTS); - state.rf_cb->priv = (FAR void *)&state; - state.rf_cb->event = recvfrom_tcpinterrupt; - - /* Wait for either the receive to complete or for an error/timeout - * to occur. - * - * NOTES: (1) net_lockedwait will also terminate if a signal is - * received, (2) interrupts may be disabled! They will be re- - * enabled while the task sleeps and automatically re-enabled when - * the task restarts. - */ - - ret = net_lockedwait(&state.rf_sem); - - /* Make sure that no further interrupts are processed */ - - tcp_callback_free(conn, state.rf_cb); - ret = recvfrom_result(ret, &state); - } - else - { - ret = -EBUSY; - } - } - - net_unlock(); - recvfrom_uninit(&state); - return (ssize_t)ret; -} -#endif /* NET_TCP_HAVE_STACK */ +#ifdef CONFIG_NET /**************************************************************************** * Public Functions @@ -1871,7 +129,7 @@ ssize_t psock_recvfrom(FAR struct socket *psock, FAR void *buf, size_t len, } #endif - if (from && !fromlen) + if (from != NULL && fromlen <= 0) { errcode = EINVAL; goto errout; @@ -1879,175 +137,55 @@ ssize_t psock_recvfrom(FAR struct socket *psock, FAR void *buf, size_t len, /* Verify that the sockfd corresponds to valid, allocated socket */ - if (!psock || psock->s_crefs <= 0) + if (psock == NULL || psock->s_crefs <= 0) { errcode = EBADF; goto errout; } + /* Set the socket state to receiving */ + + psock->s_flags = _SS_SETSTATE(psock->s_flags, _SF_RECV); + #ifdef CONFIG_NET_USRSOCK if (psock->s_type == SOCK_USRSOCK_TYPE) { /* Perform the usrsock recvfrom operation */ ret = usrsock_recvfrom(psock, buf, len, from, fromlen); - if (ret < 0) - { - errcode = -ret; - goto errout; - } - - return ret; } + else #endif + { + /* Let logic specific to this address family handle the recvfrom() + * operation. + */ - /* If a 'from' address has been provided, verify that it is large - * enough to hold this address family. - */ + DEBUGASSERT(psock->s_sockif != NULL && + psock->s_sockif->si_recvfrom != NULL); - if (from) - { - socklen_t minlen; - - /* Get the minimum socket length */ - - switch (psock->s_domain) - { -#ifdef CONFIG_NET_IPv4 - case PF_INET: - { - minlen = sizeof(struct sockaddr_in); - } - break; -#endif - -#ifdef CONFIG_NET_IPv6 - case PF_INET6: - { - minlen = sizeof(struct sockaddr_in6); - } - break; -#endif - -#ifdef CONFIG_NET_LOCAL - case PF_LOCAL: - { - minlen = sizeof(sa_family_t); - } - break; -#endif - - default: - DEBUGPANIC(); - errcode = EINVAL; - goto errout; - } - - if (*fromlen < minlen) - { - errcode = EINVAL; - goto errout; - } - } - - /* Set the socket state to receiving */ - - psock->s_flags = _SS_SETSTATE(psock->s_flags, _SF_RECV); - - /* Read from the network interface driver buffer */ - /* Or perform the TCP/IP or UDP recv() operation */ - - switch (psock->s_type) - { -#ifdef CONFIG_NET_PKT - case SOCK_RAW: + if (psock->s_sockif->si_recvfrom != NULL) { - ret = pkt_recvfrom(psock, buf, len, from, fromlen); + ret = psock->s_sockif->si_recvfrom(psock, buf, len, flags, + from, fromlen); } - break; -#endif /* CONFIG_NET_PKT */ - -#if defined(CONFIG_NET_TCP) || defined(CONFIG_NET_LOCAL_STREAM) - case SOCK_STREAM: + else { -#ifdef CONFIG_NET_LOCAL_STREAM -#ifdef CONFIG_NET_TCP - if (psock->s_domain == PF_LOCAL) -#endif - { - ret = psock_local_recvfrom(psock, buf, len, flags, - from, fromlen); - } -#endif /* CONFIG_NET_LOCAL_STREAM */ - -#ifdef CONFIG_NET_TCP -#ifdef CONFIG_NET_LOCAL_STREAM - else -#endif - { -#ifdef NET_TCP_HAVE_STACK - ret = tcp_recvfrom(psock, buf, len, from, fromlen); -#else - ret = -ENOSYS; -#endif - } -#endif /* CONFIG_NET_TCP */ - } - break; -#endif /* CONFIG_NET_TCP || CONFIG_NET_LOCAL_STREAM */ - -#if defined(CONFIG_NET_UDP) || defined(CONFIG_NET_LOCAL_DGRAM) - case SOCK_DGRAM: - { -#ifdef CONFIG_NET_LOCAL_DGRAM -#ifdef CONFIG_NET_UDP - if (psock->s_domain == PF_LOCAL) -#endif - { - ret = psock_local_recvfrom(psock, buf, len, flags, - from, fromlen); - } -#endif /* CONFIG_NET_LOCAL_DGRAM */ - -#ifdef CONFIG_NET_UDP -#ifdef CONFIG_NET_LOCAL_DGRAM - else -#endif - { -#ifdef NET_UDP_HAVE_STACK - ret = udp_recvfrom(psock, buf, len, from, fromlen); -#else - ret = -ENOSYS; -#endif - } -#endif /* CONFIG_NET_UDP */ - } - break; -#endif /* CONFIG_NET_UDP || CONFIG_NET_LOCAL_DGRAM */ - - default: - { - nerr("ERROR: Unsupported socket type: %d\n", psock->s_type); ret = -ENOSYS; } - break; - } + } /* Set the socket state to idle */ psock->s_flags = _SS_SETSTATE(psock->s_flags, _SF_IDLE); - /* Handle returned errors */ - + leave_cancellation_point(); if (ret < 0) { errcode = -ret; goto errout; } - /* Success return */ - - leave_cancellation_point(); return ret; errout: diff --git a/net/socket/socket.h b/net/socket/socket.h index 36788d465a..a7f43ce10e 100644 --- a/net/socket/socket.h +++ b/net/socket/socket.h @@ -431,13 +431,46 @@ int net_timeo(systime_t start_time, socktimeo_t timeo); * In this case the process will also receive a SIGPIPE unless * MSG_NOSIGNAL is set. * - * Assumptions: - * ****************************************************************************/ ssize_t psock_send(FAR struct socket *psock, FAR const void *buf, size_t len, int flags); +/**************************************************************************** + * Name: inet_recvfrom + * + * Description: + * Implements the socket recvfrom interface for the case of the AF_INET + * and AF_INET6 address families. inet_recvfrom() receives messages from + * a socket, and may be used to receive data on a socket whether or not it + * is connection-oriented. + * + * If 'from' is not NULL, and the underlying protocol provides the source + * address, this source address is filled in. The argument 'fromlen' is + * initialized to the size of the buffer associated with from, and + * modified on return to indicate the actual size of the address stored + * there. + * + * Parameters: + * psock A pointer to a NuttX-specific, internal socket structure + * buf Buffer to receive data + * len Length of buffer + * flags Receive flags + * from Address of source (may be NULL) + * fromlen The length of the address structure + * + * Returned Value: + * On success, returns the number of characters received. If no data is + * available to be received and the peer has performed an orderly shutdown, + * recv() will return 0. Otherwise, on errors, a negated errno value is + * returned (see recvfrom() for the list of appropriate error values). + * + ****************************************************************************/ + +ssize_t inet_recvfrom(FAR struct socket *psock, FAR void *buf, size_t len, + int flags, FAR struct sockaddr *from, + FAR socklen_t *fromlen); + #undef EXTERN #if defined(__cplusplus) }