2017-07-13 01:36:05 +02:00
|
|
|
/****************************************************************************
|
2020-01-21 08:50:39 +01:00
|
|
|
* net/tcp/tcp_recvfrom.c
|
2017-07-13 01:36:05 +02:00
|
|
|
*
|
2020-05-17 16:47:40 +02:00
|
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
|
|
* this work for additional information regarding copyright ownership. The
|
|
|
|
* ASF licenses this file to you under the Apache License, Version 2.0 (the
|
|
|
|
* "License"); you may not use this file except in compliance with the
|
|
|
|
* License. You may obtain a copy of the License at
|
|
|
|
*
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
*
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
|
|
* License for the specific language governing permissions and limitations
|
|
|
|
* under the License.
|
2017-07-13 01:36:05 +02:00
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Included Files
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
#include <nuttx/config.h>
|
2020-01-21 08:50:39 +01:00
|
|
|
#ifdef CONFIG_NET_TCP
|
2017-07-13 01:36:05 +02:00
|
|
|
|
|
|
|
#include <string.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <debug.h>
|
|
|
|
#include <assert.h>
|
|
|
|
|
2020-01-22 16:29:26 +01:00
|
|
|
#include <nuttx/semaphore.h>
|
2017-07-13 01:36:05 +02:00
|
|
|
#include <nuttx/net/net.h>
|
|
|
|
#include <nuttx/mm/iob.h>
|
|
|
|
#include <nuttx/net/netdev.h>
|
|
|
|
#include <nuttx/net/ip.h>
|
|
|
|
#include <nuttx/net/tcp.h>
|
|
|
|
|
|
|
|
#include "netdev/netdev.h"
|
|
|
|
#include "devif/devif.h"
|
|
|
|
#include "tcp/tcp.h"
|
|
|
|
#include "socket/socket.h"
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Pre-processor Definitions
|
|
|
|
****************************************************************************/
|
|
|
|
|
2022-01-17 23:09:14 +01:00
|
|
|
#define IPv4BUF ((FAR struct ipv4_hdr_s *)&dev->d_buf[NET_LL_HDRLEN(dev)])
|
|
|
|
#define IPv6BUF ((FAR struct ipv6_hdr_s *)&dev->d_buf[NET_LL_HDRLEN(dev)])
|
2017-07-13 01:36:05 +02:00
|
|
|
|
2022-01-17 23:09:14 +01:00
|
|
|
#define TCPIPv4BUF ((FAR struct tcp_hdr_s *)&dev->d_buf[NET_LL_HDRLEN(dev) + IPv4_HDRLEN])
|
|
|
|
#define TCPIPv6BUF ((FAR struct tcp_hdr_s *)&dev->d_buf[NET_LL_HDRLEN(dev) + IPv6_HDRLEN])
|
2017-07-13 01:36:05 +02:00
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Private Types
|
|
|
|
****************************************************************************/
|
|
|
|
|
2020-01-21 08:50:39 +01:00
|
|
|
struct tcp_recvfrom_s
|
2017-07-13 01:36:05 +02:00
|
|
|
{
|
2022-02-08 17:08:15 +01:00
|
|
|
FAR struct tcp_conn_s *ir_conn; /* Connection associated with the socket */
|
2017-07-13 01:36:05 +02:00
|
|
|
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 */
|
|
|
|
};
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Private Functions
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
/****************************************************************************
|
2020-01-21 08:50:39 +01:00
|
|
|
* Name: tcp_update_recvlen
|
2017-07-13 01:36:05 +02:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Update information about space available for new data and update size
|
2020-01-21 08:50:39 +01:00
|
|
|
* of data in buffer.
|
2017-07-13 01:36:05 +02:00
|
|
|
*
|
2018-03-13 16:52:27 +01:00
|
|
|
* Input Parameters:
|
2017-07-13 01:36:05 +02:00
|
|
|
* pstate recvfrom state structure
|
|
|
|
* recvlen size of new data appended to buffer
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* None
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2020-01-21 08:50:39 +01:00
|
|
|
static inline void tcp_update_recvlen(FAR struct tcp_recvfrom_s *pstate,
|
|
|
|
size_t recvlen)
|
2017-07-13 01:36:05 +02:00
|
|
|
{
|
|
|
|
if (pstate->ir_recvlen < 0)
|
|
|
|
{
|
|
|
|
pstate->ir_recvlen = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
pstate->ir_recvlen += recvlen;
|
|
|
|
pstate->ir_buffer += recvlen;
|
|
|
|
pstate->ir_buflen -= recvlen;
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
2020-01-21 08:50:39 +01:00
|
|
|
* Name: tcp_recvfrom_newdata
|
2017-07-13 01:36:05 +02:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Copy the read data from the packet
|
|
|
|
*
|
2018-03-13 16:52:27 +01:00
|
|
|
* Input Parameters:
|
2018-06-23 22:09:06 +02:00
|
|
|
* dev The structure of the network driver that generated the event.
|
2017-07-13 01:36:05 +02:00
|
|
|
* pstate recvfrom state structure
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* The number of bytes taken from the packet.
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
* The network is locked.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2020-01-21 08:50:39 +01:00
|
|
|
static size_t tcp_recvfrom_newdata(FAR struct net_driver_s *dev,
|
|
|
|
FAR struct tcp_recvfrom_s *pstate)
|
2017-07-13 01:36:05 +02:00
|
|
|
{
|
|
|
|
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 */
|
|
|
|
|
2020-01-21 08:50:39 +01:00
|
|
|
tcp_update_recvlen(pstate, recvlen);
|
2017-07-13 01:36:05 +02:00
|
|
|
|
|
|
|
return recvlen;
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
2020-01-21 08:50:39 +01:00
|
|
|
* Name: tcp_newdata
|
2017-07-13 01:36:05 +02:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Copy the read data from the packet
|
|
|
|
*
|
2018-03-13 16:52:27 +01:00
|
|
|
* Input Parameters:
|
2018-06-23 22:09:06 +02:00
|
|
|
* dev The structure of the network driver that generated the event
|
2017-07-13 01:36:05 +02:00
|
|
|
* pstate recvfrom state structure
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* None.
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
* The network is locked.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2021-06-17 06:27:18 +02:00
|
|
|
static inline uint16_t tcp_newdata(FAR struct net_driver_s *dev,
|
|
|
|
FAR struct tcp_recvfrom_s *pstate,
|
|
|
|
uint16_t flags)
|
2017-07-13 01:36:05 +02:00
|
|
|
{
|
2022-02-08 17:08:15 +01:00
|
|
|
FAR struct tcp_conn_s *conn = pstate->ir_conn;
|
2021-06-17 06:27:18 +02:00
|
|
|
|
2017-07-13 01:36:05 +02:00
|
|
|
/* Take as much data from the packet as we can */
|
|
|
|
|
2020-01-21 08:50:39 +01:00
|
|
|
size_t recvlen = tcp_recvfrom_newdata(dev, pstate);
|
2017-07-13 01:36:05 +02:00
|
|
|
|
|
|
|
/* 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)
|
|
|
|
{
|
|
|
|
FAR uint8_t *buffer = (FAR uint8_t *)dev->d_appdata + recvlen;
|
|
|
|
uint16_t buflen = dev->d_len - recvlen;
|
|
|
|
uint16_t nsaved;
|
|
|
|
|
|
|
|
nsaved = tcp_datahandler(conn, buffer, buflen);
|
|
|
|
if (nsaved < buflen)
|
|
|
|
{
|
2021-06-17 06:27:18 +02:00
|
|
|
nwarn("WARNING: packet data not fully saved "
|
|
|
|
"(%d/%u/%zu/%u bytes)\n",
|
|
|
|
buflen - nsaved,
|
|
|
|
(unsigned int)nsaved,
|
|
|
|
recvlen,
|
|
|
|
(unsigned int)dev->d_len);
|
2017-07-13 01:36:05 +02:00
|
|
|
}
|
2021-06-17 06:27:18 +02:00
|
|
|
|
|
|
|
recvlen += nsaved;
|
2019-07-03 02:02:23 +02:00
|
|
|
}
|
2017-07-13 01:36:05 +02:00
|
|
|
|
2021-06-17 06:27:18 +02:00
|
|
|
if (recvlen < dev->d_len)
|
|
|
|
{
|
|
|
|
/* Clear the TCP_CLOSE because we effectively dropped the FIN as well.
|
|
|
|
*/
|
|
|
|
|
|
|
|
flags &= ~TCP_CLOSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
net_incr32(conn->rcvseq, recvlen);
|
|
|
|
|
2017-07-13 01:36:05 +02:00
|
|
|
/* Indicate no data in the buffer */
|
|
|
|
|
|
|
|
dev->d_len = 0;
|
2021-06-17 06:27:18 +02:00
|
|
|
|
|
|
|
return flags;
|
2017-07-13 01:36:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
2020-01-21 08:50:39 +01:00
|
|
|
* Name: tcp_readahead
|
2017-07-13 01:36:05 +02:00
|
|
|
*
|
|
|
|
* Description:
|
2017-10-23 16:45:12 +02:00
|
|
|
* Copy the read-ahead data from the packet
|
2017-07-13 01:36:05 +02:00
|
|
|
*
|
2018-03-13 16:52:27 +01:00
|
|
|
* Input Parameters:
|
2017-07-13 01:36:05 +02:00
|
|
|
* pstate recvfrom state structure
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* None
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
* The network is locked.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2020-01-21 08:50:39 +01:00
|
|
|
static inline void tcp_readahead(struct tcp_recvfrom_s *pstate)
|
2017-07-13 01:36:05 +02:00
|
|
|
{
|
2022-02-08 17:08:15 +01:00
|
|
|
FAR struct tcp_conn_s *conn = pstate->ir_conn;
|
2017-07-13 01:36:05 +02:00
|
|
|
FAR struct iob_s *iob;
|
|
|
|
int recvlen;
|
|
|
|
|
|
|
|
/* Check there is any TCP data already buffered in a read-ahead
|
|
|
|
* buffer.
|
|
|
|
*/
|
|
|
|
|
2021-06-18 07:34:21 +02:00
|
|
|
while ((iob = conn->readahead) != NULL &&
|
2017-07-13 01:36:05 +02:00
|
|
|
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 */
|
|
|
|
|
2020-01-21 08:50:39 +01:00
|
|
|
tcp_update_recvlen(pstate, recvlen);
|
2017-07-13 01:36:05 +02:00
|
|
|
|
2020-01-04 11:37:46 +01:00
|
|
|
/* If we took all of the data from the I/O buffer chain is empty, then
|
2017-07-13 01:36:05 +02:00
|
|
|
* 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)
|
|
|
|
{
|
2021-06-18 07:34:21 +02:00
|
|
|
/* Free free the I/O buffer chain */
|
2017-07-13 01:36:05 +02:00
|
|
|
|
2022-08-08 04:21:03 +02:00
|
|
|
iob_free_chain(iob);
|
2021-06-18 07:34:21 +02:00
|
|
|
conn->readahead = NULL;
|
2017-07-13 01:36:05 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* The bytes that we have received from the head of the I/O
|
2021-06-18 07:34:21 +02:00
|
|
|
* buffer chain.
|
2017-07-13 01:36:05 +02:00
|
|
|
*/
|
|
|
|
|
2022-08-08 04:21:03 +02:00
|
|
|
conn->readahead = iob_trimhead(iob, recvlen);
|
2017-07-13 01:36:05 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
2020-01-21 08:50:39 +01:00
|
|
|
* Name: tcp_sender
|
2017-07-13 01:36:05 +02:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Getting the sender's address from the UDP packet
|
|
|
|
*
|
2018-03-13 16:52:27 +01:00
|
|
|
* Input Parameters:
|
2017-07-13 01:36:05 +02:00
|
|
|
* dev - The device driver data structure
|
|
|
|
* pstate - the recvfrom state structure
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* None
|
|
|
|
*
|
|
|
|
* Assumptions:
|
2017-08-29 23:08:38 +02:00
|
|
|
* The network is locked
|
2017-07-13 01:36:05 +02:00
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2020-01-21 08:50:39 +01:00
|
|
|
static inline void tcp_sender(FAR struct net_driver_s *dev,
|
|
|
|
FAR struct tcp_recvfrom_s *pstate)
|
2017-07-13 01:36:05 +02:00
|
|
|
{
|
|
|
|
/* 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));
|
2020-02-25 15:53:39 +01:00
|
|
|
memset(infrom->sin_zero, 0, sizeof(infrom->sin_zero));
|
2017-07-13 01:36:05 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_NET_IPv4 */
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
2020-12-04 20:05:59 +01:00
|
|
|
* Name: tcp_recvhandler
|
2017-07-13 01:36:05 +02:00
|
|
|
*
|
|
|
|
* Description:
|
2018-06-23 22:09:06 +02:00
|
|
|
* This function is called with the network locked to perform the actual
|
2017-07-13 01:36:05 +02:00
|
|
|
* TCP receive operation via by the lower, device interfacing layer.
|
|
|
|
*
|
2018-03-13 16:52:27 +01:00
|
|
|
* Input Parameters:
|
2018-06-23 22:09:06 +02:00
|
|
|
* dev The structure of the network driver that generated the event.
|
2017-07-13 01:36:05 +02:00
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2020-12-04 20:05:59 +01:00
|
|
|
static uint16_t tcp_recvhandler(FAR struct net_driver_s *dev,
|
|
|
|
FAR void *pvconn, FAR void *pvpriv,
|
|
|
|
uint16_t flags)
|
2017-07-13 01:36:05 +02:00
|
|
|
{
|
2020-01-21 08:50:39 +01:00
|
|
|
FAR struct tcp_recvfrom_s *pstate = (struct tcp_recvfrom_s *)pvpriv;
|
2017-07-13 01:36:05 +02:00
|
|
|
|
|
|
|
#if 0 /* REVISIT: The assertion fires. Why? */
|
|
|
|
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
|
|
|
|
|
|
|
|
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).
|
|
|
|
*/
|
|
|
|
|
2021-06-17 06:27:18 +02:00
|
|
|
flags = tcp_newdata(dev, pstate, flags);
|
2017-07-13 01:36:05 +02:00
|
|
|
|
|
|
|
/* Save the sender's address in the caller's 'from' location */
|
|
|
|
|
2020-01-21 08:50:39 +01:00
|
|
|
tcp_sender(dev, pstate);
|
2017-07-13 01:36:05 +02:00
|
|
|
|
|
|
|
/* Indicate that the data has been consumed and that an ACK
|
|
|
|
* should be sent.
|
|
|
|
*/
|
|
|
|
|
|
|
|
flags = (flags & ~TCP_NEWDATA) | TCP_SNDACK;
|
|
|
|
|
2020-01-11 04:56:03 +01:00
|
|
|
/* Check for transfer complete. 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.
|
2017-07-13 01:36:05 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
if (pstate->ir_recvlen > 0)
|
|
|
|
{
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
|
2017-10-03 23:35:24 +02:00
|
|
|
nxsem_post(&pstate->ir_sem);
|
2017-07-13 01:36:05 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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)
|
|
|
|
{
|
2022-02-08 17:08:15 +01:00
|
|
|
FAR struct tcp_conn_s *conn = pstate->ir_conn;
|
2017-07-13 01:36:05 +02:00
|
|
|
|
2017-10-20 00:45:00 +02:00
|
|
|
nwarn("WARNING: Lost connection\n");
|
2017-07-13 01:36:05 +02:00
|
|
|
|
2017-10-20 00:45:00 +02:00
|
|
|
/* We could get here recursively through the callback actions of
|
|
|
|
* tcp_lost_connection(). So don't repeat that action if we have
|
|
|
|
* already been disconnected.
|
|
|
|
*/
|
|
|
|
|
2022-02-08 17:08:15 +01:00
|
|
|
DEBUGASSERT(conn != NULL);
|
|
|
|
if (_SS_ISCONNECTED(conn->sconn.s_flags))
|
2017-10-20 00:45:00 +02:00
|
|
|
{
|
|
|
|
/* Handle loss-of-connection event */
|
|
|
|
|
2022-02-08 17:08:15 +01:00
|
|
|
tcp_lost_connection(conn, pstate->ir_cb, flags);
|
2017-10-20 00:45:00 +02:00
|
|
|
}
|
2017-07-13 01:36:05 +02:00
|
|
|
|
|
|
|
/* 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
|
|
|
|
{
|
|
|
|
pstate->ir_result = -ENOTCONN;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Wake up the waiting thread */
|
|
|
|
|
2017-10-03 23:35:24 +02:00
|
|
|
nxsem_post(&pstate->ir_sem);
|
2017-07-13 01:36:05 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return flags;
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
2020-01-21 08:50:39 +01:00
|
|
|
* Name: tcp_recvfrom_initialize
|
2017-07-13 01:36:05 +02:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Initialize the state structure
|
|
|
|
*
|
2018-03-13 16:52:27 +01:00
|
|
|
* Input Parameters:
|
2022-02-08 17:08:15 +01:00
|
|
|
* conn The TCP connection of interest
|
2017-07-13 01:36:05 +02:00
|
|
|
* buf Buffer to receive data
|
|
|
|
* len Length of buffer
|
|
|
|
* pstate A pointer to the state structure to be initialized
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* None
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2022-02-08 17:08:15 +01:00
|
|
|
static void tcp_recvfrom_initialize(FAR struct tcp_conn_s *conn,
|
|
|
|
FAR void *buf, size_t len,
|
|
|
|
FAR struct sockaddr *infrom,
|
2020-01-21 08:50:39 +01:00
|
|
|
FAR socklen_t *fromlen,
|
|
|
|
FAR struct tcp_recvfrom_s *pstate)
|
2017-07-13 01:36:05 +02:00
|
|
|
{
|
|
|
|
/* Initialize the state structure. */
|
|
|
|
|
2020-01-21 08:50:39 +01:00
|
|
|
memset(pstate, 0, sizeof(struct tcp_recvfrom_s));
|
2017-07-13 01:36:05 +02:00
|
|
|
|
|
|
|
/* This semaphore is used for signaling and, hence, should not have
|
|
|
|
* priority inheritance enabled.
|
|
|
|
*/
|
|
|
|
|
2020-01-02 17:49:34 +01:00
|
|
|
nxsem_init(&pstate->ir_sem, 0, 0); /* Doesn't really fail */
|
2020-05-17 15:56:21 +02:00
|
|
|
nxsem_set_protocol(&pstate->ir_sem, SEM_PRIO_NONE);
|
2017-07-13 01:36:05 +02:00
|
|
|
|
|
|
|
pstate->ir_buflen = len;
|
|
|
|
pstate->ir_buffer = buf;
|
|
|
|
pstate->ir_from = infrom;
|
|
|
|
pstate->ir_fromlen = fromlen;
|
|
|
|
|
|
|
|
/* Set up the start time for the timeout */
|
|
|
|
|
2022-02-08 17:08:15 +01:00
|
|
|
pstate->ir_conn = conn;
|
2017-07-13 01:36:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* The only un-initialization that has to be performed is destroying the
|
|
|
|
* semaphore.
|
|
|
|
*/
|
|
|
|
|
2020-01-21 08:50:39 +01:00
|
|
|
#define tcp_recvfrom_uninitialize(s) nxsem_destroy(&(s)->ir_sem)
|
2017-07-13 01:36:05 +02:00
|
|
|
|
|
|
|
/****************************************************************************
|
2020-01-21 08:50:39 +01:00
|
|
|
* Name: tcp_recvfrom_result
|
2017-07-13 01:36:05 +02:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Evaluate the result of the recv operations
|
|
|
|
*
|
2018-03-13 16:52:27 +01:00
|
|
|
* Input Parameters:
|
2020-01-04 11:37:46 +01:00
|
|
|
* result The result of the net_timedwait operation (may indicate EINTR)
|
2017-07-13 01:36:05 +02:00
|
|
|
* pstate A pointer to the state structure to be initialized
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* The result of the recv operation with errno set appropriately
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2020-01-21 08:50:39 +01:00
|
|
|
static ssize_t tcp_recvfrom_result(int result, struct tcp_recvfrom_s *pstate)
|
2017-07-13 01:36:05 +02:00
|
|
|
{
|
2018-06-23 22:09:06 +02:00
|
|
|
/* Check for a error/timeout detected by the event handler. Errors are
|
2017-07-13 01:36:05 +02:00
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
2020-05-17 16:47:40 +02:00
|
|
|
/* If net_timedwait failed, then we were probably reawakened by a signal.
|
|
|
|
* In this case, net_timedwait will have returned negated errno
|
|
|
|
* appropriately.
|
2017-07-13 01:36:05 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
if (result < 0)
|
|
|
|
{
|
2017-09-04 14:55:28 +02:00
|
|
|
return result;
|
2017-07-13 01:36:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return pstate->ir_recvlen;
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
2020-01-21 08:50:39 +01:00
|
|
|
* Public Functions
|
2017-07-13 01:36:05 +02:00
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
/****************************************************************************
|
2020-01-21 08:50:39 +01:00
|
|
|
* Name: psock_tcp_recvfrom
|
2017-07-13 01:36:05 +02:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Perform the recvfrom operation for a TCP/IP SOCK_STREAM
|
|
|
|
*
|
2018-03-13 16:52:27 +01:00
|
|
|
* Input Parameters:
|
2020-02-19 19:21:28 +01:00
|
|
|
* psock Pointer to the socket structure for the SOCK_DRAM socket
|
|
|
|
* buf Buffer to receive data
|
|
|
|
* len Length of buffer
|
|
|
|
* flags Receive flags
|
|
|
|
* from INET address of source (may be NULL)
|
|
|
|
* fromlen The length of the address structure
|
2017-07-13 01:36:05 +02:00
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* On success, returns the number of characters received. On error,
|
|
|
|
* -errno is returned (see recvfrom for list of errnos).
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2020-01-21 08:50:39 +01:00
|
|
|
ssize_t psock_tcp_recvfrom(FAR struct socket *psock, FAR void *buf,
|
2020-02-19 19:21:28 +01:00
|
|
|
size_t len, int flags, FAR struct sockaddr *from,
|
2020-01-21 08:50:39 +01:00
|
|
|
FAR socklen_t *fromlen)
|
2017-07-13 01:36:05 +02:00
|
|
|
{
|
2020-12-04 20:05:59 +01:00
|
|
|
struct tcp_recvfrom_s state;
|
|
|
|
FAR struct tcp_conn_s *conn;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
net_lock();
|
|
|
|
|
|
|
|
conn = (FAR struct tcp_conn_s *)psock->s_conn;
|
2017-07-13 01:36:05 +02:00
|
|
|
|
2018-06-23 22:09:06 +02:00
|
|
|
/* Initialize the state structure. This is done with the network locked
|
|
|
|
* because we don't want anything to happen until we are ready.
|
2017-07-13 01:36:05 +02:00
|
|
|
*/
|
|
|
|
|
2022-02-08 17:08:15 +01:00
|
|
|
tcp_recvfrom_initialize(conn, buf, len, from, fromlen, &state);
|
2017-07-13 01:36:05 +02:00
|
|
|
|
|
|
|
/* 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.
|
|
|
|
*/
|
|
|
|
|
2020-01-21 08:50:39 +01:00
|
|
|
tcp_readahead(&state);
|
2017-07-13 01:36:05 +02:00
|
|
|
|
|
|
|
/* 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;
|
|
|
|
|
|
|
|
/* Verify that the SOCK_STREAM has been and still is connected */
|
|
|
|
|
2022-02-08 06:18:01 +01:00
|
|
|
if (!_SS_ISCONNECTED(conn->sconn.s_flags))
|
2017-07-13 01:36:05 +02:00
|
|
|
{
|
|
|
|
/* 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.
|
|
|
|
*
|
2020-05-17 16:47:40 +02:00
|
|
|
* 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.
|
2017-07-13 01:36:05 +02:00
|
|
|
*/
|
|
|
|
|
2022-02-08 06:18:01 +01:00
|
|
|
if (ret <= 0 && !_SS_ISCLOSED(conn->sconn.s_flags))
|
2017-07-13 01:36:05 +02:00
|
|
|
{
|
2020-05-17 16:47:40 +02:00
|
|
|
/* Nothing was previously received from the read-ahead buffers.
|
2017-07-13 01:36:05 +02:00
|
|
|
* 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
|
2020-05-17 16:47:40 +02:00
|
|
|
* 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.
|
2017-07-13 01:36:05 +02:00
|
|
|
*/
|
|
|
|
|
2022-02-08 06:18:01 +01:00
|
|
|
else if (_SS_ISNONBLOCK(conn->sconn.s_flags) ||
|
|
|
|
(flags & MSG_DONTWAIT) != 0)
|
2017-07-13 01:36:05 +02:00
|
|
|
{
|
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-17 16:47:40 +02:00
|
|
|
/* 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').
|
2017-07-13 01:36:05 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
else
|
|
|
|
|
2020-05-17 16:47:40 +02:00
|
|
|
/* 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:
|
2017-07-13 01:36:05 +02:00
|
|
|
*
|
|
|
|
* 1) Make sure thet there is buffer space to receive additional data
|
2020-01-11 04:56:03 +01:00
|
|
|
* (state.ir_buflen > 0). This could be zero, for example, we filled
|
|
|
|
* the user buffer with data from the read-ahead buffers. And
|
|
|
|
* 2) 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).
|
2017-07-13 01:36:05 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
if (state.ir_recvlen == 0 && state.ir_buflen > 0)
|
|
|
|
{
|
|
|
|
/* Set up the callback in the connection */
|
|
|
|
|
|
|
|
state.ir_cb = tcp_callback_alloc(conn);
|
|
|
|
if (state.ir_cb)
|
|
|
|
{
|
2019-11-24 17:41:11 +01:00
|
|
|
state.ir_cb->flags = (TCP_NEWDATA | TCP_DISCONN_EVENTS);
|
2017-07-13 01:36:05 +02:00
|
|
|
state.ir_cb->priv = (FAR void *)&state;
|
2020-12-04 20:05:59 +01:00
|
|
|
state.ir_cb->event = tcp_recvhandler;
|
2017-07-13 01:36:05 +02:00
|
|
|
|
|
|
|
/* Wait for either the receive to complete or for an error/timeout
|
2020-01-04 11:37:46 +01:00
|
|
|
* to occur. net_timedwait will also terminate if a signal isi
|
2018-06-23 22:09:06 +02:00
|
|
|
* received.
|
2017-07-13 01:36:05 +02:00
|
|
|
*/
|
|
|
|
|
2022-02-07 07:36:54 +01:00
|
|
|
ret = net_timedwait(&state.ir_sem,
|
|
|
|
_SO_TIMEOUT(conn->sconn.s_rcvtimeo));
|
2020-01-17 18:26:47 +01:00
|
|
|
if (ret == -ETIMEDOUT)
|
|
|
|
{
|
|
|
|
ret = -EAGAIN;
|
|
|
|
}
|
2017-07-13 01:36:05 +02:00
|
|
|
|
2018-06-23 22:09:06 +02:00
|
|
|
/* Make sure that no further events are processed */
|
2017-07-13 01:36:05 +02:00
|
|
|
|
|
|
|
tcp_callback_free(conn, state.ir_cb);
|
2020-01-21 08:50:39 +01:00
|
|
|
ret = tcp_recvfrom_result(ret, &state);
|
2017-07-13 01:36:05 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ret = -EBUSY;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-05-28 10:02:42 +02:00
|
|
|
/* Receive additional data from read-ahead buffer, send the ACK timely.
|
|
|
|
*
|
|
|
|
* Revisit: Because IOBs are system-wide resources, consuming the read
|
|
|
|
* ahead buffer would update recv window of all connections in the system,
|
|
|
|
* not only this particular connection.
|
|
|
|
*/
|
2020-12-04 20:05:59 +01:00
|
|
|
|
2021-06-01 09:57:00 +02:00
|
|
|
if (tcp_should_send_recvwindow(conn))
|
2020-12-04 20:05:59 +01:00
|
|
|
{
|
2021-06-01 09:57:00 +02:00
|
|
|
netdev_txnotify_dev(conn->dev);
|
2020-12-04 20:05:59 +01:00
|
|
|
}
|
|
|
|
|
2017-07-13 01:36:05 +02:00
|
|
|
net_unlock();
|
2020-01-21 08:50:39 +01:00
|
|
|
tcp_recvfrom_uninitialize(&state);
|
2017-07-13 01:36:05 +02:00
|
|
|
return (ssize_t)ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* CONFIG_NET_TCP */
|