1981 lines
56 KiB
C
1981 lines
56 KiB
C
/****************************************************************************
|
|
* net/socket/recvfrom.c
|
|
*
|
|
* Copyright (C) 2007-2009, 2011-2015 Gregory Nutt. All rights reserved.
|
|
* Author: Gregory Nutt <gnutt@nuttx.org>
|
|
*
|
|
* 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 <nuttx/config.h>
|
|
|
|
#ifdef CONFIG_NET
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <debug.h>
|
|
#include <assert.h>
|
|
|
|
#ifdef CONFIG_NET_PKT
|
|
# include <netpacket/packet.h>
|
|
#endif
|
|
|
|
#include <arch/irq.h>
|
|
|
|
#include <nuttx/clock.h>
|
|
#include <nuttx/net/net.h>
|
|
#include <nuttx/net/iob.h>
|
|
#include <nuttx/net/netdev.h>
|
|
#include <nuttx/net/ip.h>
|
|
#include <nuttx/net/tcp.h>
|
|
#include <nuttx/net/udp.h>
|
|
|
|
#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"
|
|
|
|
/****************************************************************************
|
|
* 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(CONFIG_NET_UDP) || defined(CONFIG_NET_TCP)
|
|
struct recvfrom_s
|
|
{
|
|
FAR struct socket *rf_sock; /* The parent socket structure */
|
|
#ifdef CONFIG_NET_SOCKOPTS
|
|
uint32_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 */
|
|
size_t rf_recvlen; /* The received length */
|
|
int rf_result; /* Success:OK, failure:negated errno */
|
|
};
|
|
#endif /* CONFIG_NET_UDP || CONFIG_NET_TCP */
|
|
|
|
/****************************************************************************
|
|
* Private Functions
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Function: 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:
|
|
* Running at the interrupt level
|
|
*
|
|
****************************************************************************/
|
|
|
|
#if defined(CONFIG_NET_UDP) || defined(CONFIG_NET_TCP)
|
|
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);
|
|
nllvdbg("Received %d bytes (of %d)\n", (int)recvlen, (int)dev->d_len);
|
|
|
|
/* Update the accumulated size of the data read */
|
|
|
|
pstate->rf_recvlen += recvlen;
|
|
pstate->rf_buffer += recvlen;
|
|
pstate->rf_buflen -= recvlen;
|
|
|
|
return recvlen;
|
|
}
|
|
#endif /* CONFIG_NET_UDP || CONFIG_NET_TCP */
|
|
|
|
/****************************************************************************
|
|
* Function: 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:
|
|
* Running at the interrupt level
|
|
*
|
|
****************************************************************************/
|
|
|
|
#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);
|
|
nllvdbg("Received %d bytes (of %d)\n", (int)recvlen, (int)dev->d_len);
|
|
|
|
/* Update the accumulated size of the data read */
|
|
|
|
pstate->rf_recvlen += recvlen;
|
|
pstate->rf_buffer += recvlen;
|
|
pstate->rf_buffer -= recvlen;
|
|
}
|
|
#endif /* CONFIG_NET_PKT */
|
|
|
|
/****************************************************************************
|
|
* Function: 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:
|
|
* Running at the interrupt level
|
|
*
|
|
****************************************************************************/
|
|
|
|
#ifdef CONFIG_NET_TCP
|
|
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, than
|
|
* 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)
|
|
{
|
|
ndbg("ERROR: packet data not saved (%d bytes)\n", buflen - nsaved);
|
|
}
|
|
#endif
|
|
#else
|
|
ndbg("ERROR: packet data lost (%d bytes)\n", dev->d_len - recvlen);
|
|
#endif
|
|
}
|
|
|
|
/* Indicate no data in the buffer */
|
|
|
|
dev->d_len = 0;
|
|
}
|
|
#endif /* CONFIG_NET_TCP */
|
|
|
|
/****************************************************************************
|
|
* Function: 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:
|
|
* Running at the interrupt level
|
|
*
|
|
****************************************************************************/
|
|
|
|
#ifdef CONFIG_NET_UDP
|
|
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 /* CONFIG_NET_TCP */
|
|
|
|
/****************************************************************************
|
|
* Function: 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:
|
|
* Running at the interrupt level
|
|
*
|
|
****************************************************************************/
|
|
|
|
#if defined(CONFIG_NET_TCP) && 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);
|
|
nllvdbg("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;
|
|
|
|
/* 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 /* CONFIG_NET_UDP || CONFIG_NET_TCP */
|
|
|
|
#if defined(CONFIG_NET_UDP) && 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.
|
|
*/
|
|
|
|
if ((iob = iob_peek_queue(&conn->readahead)) != NULL &&
|
|
pstate->rf_buflen > 0)
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
recvlen = iob_copyout(pstate->rf_buffer, iob, pstate->rf_buflen,
|
|
src_addr_size + sizeof(uint8_t));
|
|
|
|
nllvdbg("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;
|
|
|
|
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
|
|
|
|
/****************************************************************************
|
|
* Function: recvfrom_timeout
|
|
*
|
|
* Description:
|
|
* Check for recvfrom timeout.
|
|
*
|
|
* Parameters:
|
|
* pstate recvfrom state structure
|
|
*
|
|
* Returned Value:
|
|
* TRUE:timeout FALSE:no timeout
|
|
*
|
|
* Assumptions:
|
|
* Running at the interrupt level
|
|
*
|
|
****************************************************************************/
|
|
|
|
#if defined(CONFIG_NET_UDP) || defined(CONFIG_NET_TCP)
|
|
#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 /* CONFIG_NET_UDP || CONFIG_NET_TCP */
|
|
|
|
/****************************************************************************
|
|
* Function: 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 */
|
|
|
|
/****************************************************************************
|
|
* Function: recvfrom_pktinterrupt
|
|
*
|
|
* Description:
|
|
*
|
|
* Parameters:
|
|
*
|
|
* Returned Values:
|
|
*
|
|
* Assumptions:
|
|
*
|
|
****************************************************************************/
|
|
|
|
#ifdef CONFIG_NET_PKT
|
|
static uint16_t recvfrom_pktinterrupt(FAR struct net_driver_s *dev,
|
|
FAR void *conn, FAR void *pvpriv,
|
|
uint16_t flags)
|
|
{
|
|
struct recvfrom_s *pstate = (struct recvfrom_s *)pvpriv;
|
|
|
|
nllvdbg("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. */
|
|
|
|
nllvdbg("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 */
|
|
|
|
/****************************************************************************
|
|
* Function: 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 CONFIG_NET_TCP
|
|
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 /* CONFIG_NET_TCP */
|
|
|
|
/****************************************************************************
|
|
* Function: 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
|
|
* conn The connection structure associated with the socket
|
|
* flags Set of events describing why the callback was invoked
|
|
*
|
|
* Returned Value:
|
|
* None
|
|
*
|
|
* Assumptions:
|
|
* Running at the interrupt level
|
|
*
|
|
****************************************************************************/
|
|
|
|
#ifdef CONFIG_NET_TCP
|
|
static uint16_t recvfrom_tcpinterrupt(FAR struct net_driver_s *dev,
|
|
FAR void *conn, FAR void *pvpriv,
|
|
uint16_t flags)
|
|
{
|
|
FAR struct recvfrom_s *pstate = (struct recvfrom_s *)pvpriv;
|
|
|
|
nllvdbg("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
|
|
{
|
|
nllvdbg("TCP resume\n");
|
|
|
|
/* The TCP receive buffer is full. 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_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.
|
|
*/
|
|
|
|
else if ((flags & (TCP_CLOSE | TCP_ABORT | TCP_TIMEDOUT)) != 0)
|
|
{
|
|
nllvdbg("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
|
|
*/
|
|
|
|
nllvdbg("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
|
|
* 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 tht the timeout occured (no error).
|
|
*/
|
|
|
|
sem_post(&pstate->rf_sem);
|
|
}
|
|
#endif /* CONFIG_NET_SOCKOPTS */
|
|
}
|
|
|
|
return flags;
|
|
}
|
|
#endif /* CONFIG_NET_TCP */
|
|
|
|
/****************************************************************************
|
|
* Function: 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:
|
|
* Running at the interrupt level
|
|
*
|
|
****************************************************************************/
|
|
|
|
#ifdef CONFIG_NET_UDP
|
|
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)
|
|
{
|
|
FAR struct udp_hdr_s *udp = UDPIPv4BUF;
|
|
FAR struct ipv4_hdr_s *ipv4 = IPv4BUF;
|
|
|
|
#ifdef CONFIG_NET_IPv6
|
|
FAR struct udp_conn_s *conn = (FAR struct udp_conn_s*)pstate->rf_sock->s_conn;
|
|
FAR struct sockaddr_in6 *infrom6 = (FAR struct sockaddr_in6 *)infrom;
|
|
|
|
/* Hybrid dual-stack IPv6/IPv4 implementations recognize a special
|
|
* class of addresses, the IPv4-mapped IPv6 addresses.
|
|
*/
|
|
|
|
if (conn->domain == PF_INET6)
|
|
{
|
|
FAR socklen_t *fromlen = pstate->rf_fromlen;
|
|
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(ipv4->srcipaddr);
|
|
ip6_map_ipv4addr(ipv4addr,
|
|
(net_ipv6addr_t)src_addr6.sin6_addr.s6_addr16);
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
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 /* CONFIG_NET_UDP */
|
|
|
|
/****************************************************************************
|
|
* Function: recvfrom_udpinterrupt
|
|
*
|
|
* 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
|
|
* conn The connection structure associated with the socket
|
|
* flags Set of events describing why the callback was invoked
|
|
*
|
|
* Returned Value:
|
|
* None
|
|
*
|
|
* Assumptions:
|
|
* Running at the interrupt level
|
|
*
|
|
****************************************************************************/
|
|
|
|
#ifdef CONFIG_NET_UDP
|
|
static uint16_t recvfrom_udpinterrupt(struct net_driver_s *dev, void *pvconn,
|
|
void *pvpriv, uint16_t flags)
|
|
{
|
|
struct recvfrom_s *pstate = (struct recvfrom_s *)pvpriv;
|
|
|
|
nllvdbg("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 & UDP_NEWDATA) != 0)
|
|
{
|
|
/* Copy the data from the packet */
|
|
|
|
recvfrom_newudpdata(dev, pstate);
|
|
|
|
/* We are finished. */
|
|
|
|
nllvdbg("UDP done\n");
|
|
|
|
/* 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 sender's address in the caller's 'from' location */
|
|
|
|
recvfrom_udpsender(dev, pstate);
|
|
|
|
/* Indicate that the data has been consumed */
|
|
|
|
flags &= ~UDP_NEWDATA;
|
|
|
|
/* Wake up the waiting thread, returning the number of bytes
|
|
* actually read.
|
|
*/
|
|
|
|
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
|
|
*/
|
|
|
|
nllvdbg("UDP timeout\n");
|
|
|
|
/* Stop further callbacks */
|
|
|
|
pstate->rf_cb->flags = 0;
|
|
pstate->rf_cb->priv = NULL;
|
|
pstate->rf_cb->event = NULL;
|
|
|
|
/* Report a timeout error */
|
|
|
|
pstate->rf_result = -EAGAIN;
|
|
|
|
/* Wake up the waiting thread */
|
|
|
|
sem_post(&pstate->rf_sem);
|
|
}
|
|
#endif /* CONFIG_NET_SOCKOPTS */
|
|
}
|
|
|
|
return flags;
|
|
}
|
|
#endif /* CONFIG_NET_UDP */
|
|
|
|
/****************************************************************************
|
|
* Function: 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(CONFIG_NET_UDP) || defined(CONFIG_NET_TCP)
|
|
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));
|
|
(void)sem_init(&pstate->rf_sem, 0, 0); /* Doesn't really fail */
|
|
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 /* CONFIG_NET_UDP || CONFIG_NET_TCP */
|
|
|
|
/****************************************************************************
|
|
* Function: 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(CONFIG_NET_UDP) || defined(CONFIG_NET_TCP)
|
|
static ssize_t recvfrom_result(int result, struct recvfrom_s *pstate)
|
|
{
|
|
int save_errno = 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 /* CONFIG_NET_UDP || CONFIG_NET_TCP */
|
|
|
|
/****************************************************************************
|
|
* Function: 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
|
|
|
|
/****************************************************************************
|
|
* Function: 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 CONFIG_NET_UDP
|
|
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 /* CONFIG_NET_UDP */
|
|
|
|
/****************************************************************************
|
|
* Function: 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;
|
|
struct recvfrom_s state;
|
|
net_lock_t save;
|
|
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.
|
|
*/
|
|
|
|
save = net_lock();
|
|
recvfrom_init(psock, buf, len, from, fromlen, &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(conn);
|
|
if (state.rf_cb)
|
|
{
|
|
state.rf_cb->flags = (PKT_NEWDATA | PKT_POLL);
|
|
state.rf_cb->priv = (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(conn, state.rf_cb);
|
|
ret = recvfrom_result(ret, &state);
|
|
}
|
|
else
|
|
{
|
|
ret = -EBUSY;
|
|
}
|
|
|
|
#if 0 /* Not used */
|
|
errout_with_state:
|
|
#endif
|
|
net_unlock(save);
|
|
recvfrom_uninit(&state);
|
|
return ret;
|
|
}
|
|
#endif /* CONFIG_NET_PKT */
|
|
|
|
/****************************************************************************
|
|
* Function: 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 CONFIG_NET_UDP
|
|
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;
|
|
struct recvfrom_s state;
|
|
net_lock_t save;
|
|
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.
|
|
*/
|
|
|
|
save = 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').
|
|
*/
|
|
|
|
else if (state.rf_recvlen == 0)
|
|
#endif
|
|
{
|
|
/* Set up the callback in the connection */
|
|
|
|
state.rf_cb = udp_callback_alloc(conn);
|
|
if (state.rf_cb)
|
|
{
|
|
/* Set up the callback in the connection */
|
|
|
|
state.rf_cb->flags = (UDP_NEWDATA | UDP_POLL);
|
|
state.rf_cb->priv = (void*)&state;
|
|
state.rf_cb->event = recvfrom_udpinterrupt;
|
|
|
|
/* 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(conn, state.rf_cb);
|
|
ret = recvfrom_result(ret, &state);
|
|
}
|
|
else
|
|
{
|
|
ret = -EBUSY;
|
|
}
|
|
}
|
|
|
|
errout_with_state:
|
|
net_unlock(save);
|
|
recvfrom_uninit(&state);
|
|
return ret;
|
|
}
|
|
#endif /* CONFIG_NET_UDP */
|
|
|
|
/****************************************************************************
|
|
* Function: 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 CONFIG_NET_TCP
|
|
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;
|
|
net_lock_t save;
|
|
int ret;
|
|
|
|
/* Initialize the state structure. This is done with interrupts
|
|
* disabled because we don't want anything to happen until we
|
|
* are ready.
|
|
*/
|
|
|
|
save = 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 uIP-based 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_CLOSE |
|
|
TCP_ABORT | TCP_TIMEDOUT);
|
|
state.rf_cb->priv = (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(save);
|
|
recvfrom_uninit(&state);
|
|
return (ssize_t)ret;
|
|
}
|
|
#endif /* CONFIG_NET_TCP */
|
|
|
|
/****************************************************************************
|
|
* Public Functions
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Function: psock_recvfrom
|
|
*
|
|
* Description:
|
|
* 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
|
|
* 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, -1 is returned, and errno
|
|
* is set appropriately:
|
|
*
|
|
* EAGAIN
|
|
* The socket is marked non-blocking and the receive operation would block,
|
|
* or a receive timeout had been set and the timeout expired before data
|
|
* was received.
|
|
* EBADF
|
|
* The argument sockfd is an invalid descriptor.
|
|
* ECONNREFUSED
|
|
* A remote host refused to allow the network connection (typically because
|
|
* it is not running the requested service).
|
|
* EFAULT
|
|
* The receive buffer pointer(s) point outside the process's address space.
|
|
* EINTR
|
|
* The receive was interrupted by delivery of a signal before any data were
|
|
* available.
|
|
* EINVAL
|
|
* Invalid argument passed.
|
|
* ENOMEM
|
|
* Could not allocate memory.
|
|
* ENOTCONN
|
|
* The socket is associated with a connection-oriented protocol and has
|
|
* not been connected.
|
|
* ENOTSOCK
|
|
* The argument sockfd does not refer to a socket.
|
|
*
|
|
* Assumptions:
|
|
*
|
|
****************************************************************************/
|
|
|
|
ssize_t psock_recvfrom(FAR struct socket *psock, FAR void *buf, size_t len,
|
|
int flags, FAR struct sockaddr *from,
|
|
FAR socklen_t *fromlen)
|
|
{
|
|
ssize_t ret;
|
|
int err;
|
|
|
|
/* Verify that non-NULL pointers were passed */
|
|
|
|
#ifdef CONFIG_DEBUG
|
|
if (!buf)
|
|
{
|
|
err = EINVAL;
|
|
goto errout;
|
|
}
|
|
#endif
|
|
|
|
if (from && !fromlen)
|
|
{
|
|
err = EINVAL;
|
|
goto errout;
|
|
}
|
|
|
|
/* Verify that the sockfd corresponds to valid, allocated socket */
|
|
|
|
if (!psock || psock->s_crefs <= 0)
|
|
{
|
|
err = EBADF;
|
|
goto errout;
|
|
}
|
|
|
|
/* 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
|
|
|
|
#ifdef CONFIG_NET_LOCAL
|
|
case PF_LOCAL:
|
|
{
|
|
minlen = sizeof(sa_family_t);
|
|
}
|
|
break;
|
|
#endif
|
|
|
|
default:
|
|
DEBUGPANIC();
|
|
err = EINVAL;
|
|
goto errout;
|
|
}
|
|
|
|
if (*fromlen < minlen)
|
|
{
|
|
err = 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:
|
|
{
|
|
ret = pkt_recvfrom(psock, buf, len, from, fromlen);
|
|
}
|
|
break;
|
|
#endif /* CONFIG_NET_PKT */
|
|
|
|
#if defined(CONFIG_NET_TCP) || defined(CONFIG_NET_LOCAL_STREAM)
|
|
case SOCK_STREAM:
|
|
{
|
|
#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
|
|
{
|
|
ret = tcp_recvfrom(psock, buf, len, from, fromlen);
|
|
}
|
|
#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
|
|
{
|
|
ret = udp_recvfrom(psock, buf, len, from, fromlen);
|
|
}
|
|
#endif /* CONFIG_NET_UDP */
|
|
}
|
|
break;
|
|
#endif /* CONFIG_NET_UDP || CONFIG_NET_LOCAL_DGRAM */
|
|
|
|
default:
|
|
{
|
|
ndbg("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 */
|
|
|
|
if (ret < 0)
|
|
{
|
|
err = -ret;
|
|
goto errout;
|
|
}
|
|
|
|
/* Success return */
|
|
|
|
return ret;
|
|
|
|
errout:
|
|
set_errno(err);
|
|
return ERROR;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Function: recvfrom
|
|
*
|
|
* Description:
|
|
* 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
|
|
* 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:
|
|
* sockfd Socket descriptor of socket
|
|
* 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. On error,
|
|
* -1 is returned, and errno is set appropriately:
|
|
*
|
|
* EAGAIN
|
|
* The socket is marked non-blocking and the receive operation would block,
|
|
* or a receive timeout had been set and the timeout expired before data
|
|
* was received.
|
|
* EBADF
|
|
* The argument sockfd is an invalid descriptor.
|
|
* ECONNREFUSED
|
|
* A remote host refused to allow the network connection (typically because
|
|
* it is not running the requested service).
|
|
* EFAULT
|
|
* The receive buffer pointer(s) point outside the process's address space.
|
|
* EINTR
|
|
* The receive was interrupted by delivery of a signal before any data were
|
|
* available.
|
|
* EINVAL
|
|
* Invalid argument passed.
|
|
* ENOMEM
|
|
* Could not allocate memory.
|
|
* ENOTCONN
|
|
* The socket is associated with a connection-oriented protocol and has
|
|
* not been connected.
|
|
* ENOTSOCK
|
|
* The argument sockfd does not refer to a socket.
|
|
*
|
|
* Assumptions:
|
|
*
|
|
****************************************************************************/
|
|
|
|
ssize_t recvfrom(int sockfd, FAR void *buf, size_t len, int flags,
|
|
FAR struct sockaddr *from, FAR socklen_t *fromlen)
|
|
{
|
|
FAR struct socket *psock;
|
|
|
|
/* Get the underlying socket structure */
|
|
|
|
psock = sockfd_socket(sockfd);
|
|
|
|
/* Then let psock_recvfrom() do all of the work */
|
|
|
|
return psock_recvfrom(psock, buf, len, flags, from, fromlen);
|
|
}
|
|
|
|
#endif /* CONFIG_NET */
|