* net/pkt/pkt_input.c
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#if defined(CONFIG_NET) && defined(CONFIG_NET_PKT)
#include <errno.h>
#include <debug.h>
#include <nuttx/mutex.h>
#include <nuttx/mm/iob.h>
#include <nuttx/net/netdev.h>
#include <nuttx/net/pkt.h>
#include "devif/devif.h"
#include "pkt/pkt.h"
#include "utils/utils.h"
#include "socket/socket.h"
* Private Functions
****************************************************************************/
* Name: pkt_datahandler
*
* Description:
* Handle packet that are not accepted by the application.
*
* Input Parameters:
* dev - Device instance only the input packet in d_buf, length = d_len;
* conn - A pointer to the PKT connection structure
* iobq - A pointer to the buffer queue
*
* Returned Value:
* The number of bytes actually buffered is returned. This will be either
* zero or equal to buflen; partial packets are not buffered.
*
****************************************************************************/
static uint16_t pkt_datahandler(FAR struct net_driver_s *dev,
FAR struct pkt_conn_s *conn,
FAR struct iob_queue_s *iobq)
{
FAR struct iob_s *iob = iob_tryalloc(true);
int ret;
if (iob == NULL)
{
return 0;
}
* overconsumption.
* TODO: Optimize IOB clone after we support shared IOB.
*/
ret = iob_clone_partial(dev->d_iob, dev->d_len, -NET_LL_HDRLEN(dev),
iob, 0, true, false);
if (ret < 0)
{
nerr("ERROR: Failed to clone the I/O buffer chain: %d\n", ret);
goto errout;
}
* without waiting).
*/
conn_lock(&conn->sconn);
ret = iob_tryadd_queue(iob, iobq);
conn_unlock(&conn->sconn);
if (ret < 0)
{
nerr("ERROR: Failed to queue the I/O buffer chain: %d\n", ret);
goto errout;
}
else
{
ninfo("Buffered %d bytes\n", dev->d_len);
return dev->d_len;
}
errout:
iob_free_chain(iob);
return 0;
}
* Name: pkt_in_
*
* Description:
* Handle incoming packet input
*
* This is the iob buffer version of pkt_input(),
* this function will support send/receive iob vectors directly between
* the driver and l3/l4 stack to avoid unnecessary memory copies,
* especially on hardware that supports Scatter/gather, which can
* greatly improve performance
* this function will uses d_iob as packets input which used by some
* NICs such as celluler net driver.
*
* Input Parameters:
* dev - The device driver structure containing the received packet
* loopback - Indicate whether it is a loopback packet
*
* Returned Value:
* OK The packet has been processed and can be deleted
* -EAGAIN There is a matching connection, but could not dispatch the packet
* yet. Useful when a packet arrives before a recv call is in
* place.
*
* Assumptions:
* The network is locked.
*
****************************************************************************/
static int pkt_in_(FAR struct net_driver_s *dev, bool loopback)
{
FAR struct pkt_conn_s *conn = NULL;
uint32_t flags;
int ret = OK;
dev->d_appdata = dev->d_buf;
dev->d_sndlen = 0;
pkt_conn_list_lock();
while ((conn = pkt_active(dev, conn, loopback)) != NULL)
{
if (loopback && conn->pendiob == dev->d_iob)
{
conn->pendiob = NULL;
continue;
}
#ifdef CONFIG_NET_TIMESTAMPING
if (dev->d_iob->io_conn == &conn->sconn)
{
if (pkt_datahandler(dev, conn, &conn->errahead) > 0)
{
pkt_callback(dev, conn, PKT_NEWDATA);
}
break;
}
if (dev->d_iob->io_conn != NULL)
{
continue;
}
#endif
#ifdef CONFIG_NET_TIMESTAMP
if ((dev->d_features & NETDEV_RX_STAMP) == 0 &&
(_SO_GETOPT(conn->sconn.s_options, SO_TIMESTAMP) ||
_SO_GETOPT(conn->sconn.s_options, SO_TIMESTAMPNS)))
{
* if timestamp no provided by hardware.
*/
clock_gettime(CLOCK_REALTIME, &dev->d_iob->io_time);
}
#endif
flags = pkt_callback(dev, conn, PKT_NEWDATA);
* and thus the packet can be deleted (OK will be returned).
*/
if ((flags & PKT_NEWDATA) != 0)
{
#if CONFIG_NET_RECV_BUFSIZE > 0
if ((iob_get_queue_size(&conn->readahead) + dev->d_len) >
conn->sconn.s_rcvbufs)
{
nwarn("WARNING: Full read-ahead buffer, dropping packet\n");
continue;
}
#endif
if (pkt_datahandler(dev, conn, &conn->readahead) == 0)
{
* that the driver may retry again later.
*/
nwarn("WARNING: Packet not processed\n");
ret = -EAGAIN;
break;
}
}
}
pkt_conn_list_unlock();
return ret;
}
* Name: pkt_in
*
* Description:
* To be compatible with the old framework, keep this function.
* For more detailed information, please refer to __pkt_input
*
* Input Parameters:
* dev - The device driver structure containing the received packet
*
* Returned Value:
* OK The packet has been processed and can be deleted
* -EAGAIN There is a matching connection, but could not dispatch the packet
* yet. Useful when a packet arrives before a recv call is in
* place.
*
* Assumptions:
* The network is locked.
*
****************************************************************************/
static int pkt_in(FAR struct net_driver_s *dev)
{
return pkt_in_(dev, false);
}
* Public Functions
****************************************************************************/
* Name: pkt_input
*
* Description:
* Handle incoming packet input
*
* Input Parameters:
* dev - The device driver structure containing the received packet
*
* Returned Value:
* OK The packet has been processed and can be deleted
* -EAGAIN There is a matching connection, but could not dispatch the
* packet yet. Useful when a packet arrives before a recv call
* is in place.
*
* Assumptions:
* The network is locked.
*
****************************************************************************/
int pkt_input(FAR struct net_driver_s *dev)
{
FAR uint8_t *buf;
int ret;
netdev_lock(dev);
if (dev->d_iob != NULL)
{
buf = dev->d_buf;
dev->d_buf = NETLLBUF;
ret = pkt_in(dev);
dev->d_buf = buf;
netdev_unlock(dev);
return ret;
}
ret = netdev_input(dev, pkt_in, false);
netdev_unlock(dev);
return ret;
}
* Name: pkt_loopback
*
* Description:
* Handle looback packet input.
* This function is quite similar to pkt_inpt, and we made a distinction
* to ensure compatibility with old code
*
* Input Parameters:
* dev - The device driver structure containing the received packet
*
* Returned Value:
* OK The packet has been processed and can be deleted
* -EAGAIN There is a matching connection, but could not dispatch the
* packet yet. Useful when a packet arrives before a recv call
* is in place.
*
* Assumptions:
* The network is locked.
*
****************************************************************************/
int pkt_loopback(FAR struct net_driver_s *dev)
{
FAR uint8_t *buf;
int ret;
netdev_lock(dev);
buf = dev->d_buf;
dev->d_buf = NETLLBUF;
ret = pkt_in_(dev, true);
dev->d_buf = buf;
netdev_unlock(dev);
return ret;
}
#endif