123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932 |
- /****************************************************************************
- * net/udp/udp_send_buffered.c
- *
- * Copyright (C) 2018 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>
- #if defined(CONFIG_NET) && defined(CONFIG_NET_UDP) && \
- defined(CONFIG_NET_UDP_WRITE_BUFFERS)
- #if defined(CONFIG_DEBUG_FEATURES) && defined(CONFIG_NET_UDP_WRBUFFER_DEBUG)
- /* Force debug output (from this file only) */
- # undef CONFIG_DEBUG_NET
- # define CONFIG_DEBUG_NET 1
- #endif
- #include <sys/types.h>
- #include <sys/socket.h>
- #include <stdint.h>
- #include <stdbool.h>
- #include <stdio.h>
- #include <string.h>
- #include <errno.h>
- #include <debug.h>
- #include <debug.h>
- #include <arch/irq.h>
- #include <nuttx/clock.h>
- #include <nuttx/net/net.h>
- #include <nuttx/mm/iob.h>
- #include <nuttx/net/netdev.h>
- #include <nuttx/net/arp.h>
- #include <nuttx/net/udp.h>
- #include "netdev/netdev.h"
- #include "socket/socket.h"
- #include "inet/inet.h"
- #include "arp/arp.h"
- #include "icmpv6/icmpv6.h"
- #include "neighbor/neighbor.h"
- #include "udp/udp.h"
- #include "devif/devif.h"
- /****************************************************************************
- * Pre-processor Definitions
- ****************************************************************************/
- /* If both IPv4 and IPv6 support are both enabled, then we will need to build
- * in some additional domain selection support.
- */
- #if defined(CONFIG_NET_IPv4) && defined(CONFIG_NET_IPv6)
- # define NEED_IPDOMAIN_SUPPORT 1
- #endif
- #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])
- /* Debug */
- #ifdef CONFIG_NET_UDP_WRBUFFER_DUMP
- # define BUF_DUMP(msg,buf,len) lib_dumpbuffer(msg,buf,len)
- #else
- # define BUF_DUMP(msg,buf,len)
- # undef UDP_WBDUMP
- # define UDP_WBDUMP(msg,wrb,len,offset)
- #endif
- /****************************************************************************
- * Private Function Prototypes
- ****************************************************************************/
- #ifdef NEED_IPDOMAIN_SUPPORT
- static inline void sendto_ipselect(FAR struct net_driver_s *dev,
- FAR struct udp_conn_s *conn);
- #endif
- #ifdef CONFIG_NET_ETHERNET
- static inline bool sendto_addrcheck(FAR struct udp_conn_s *conn,
- FAR struct net_driver_s *dev);
- #else
- # define sendto_addrcheck(c,d) (true)
- #endif
- #ifdef CONFIG_NET_SOCKOPTS
- static inline int sendto_timeout(FAR struct socket *psock,
- FAR struct udp_conn_s *conn);
- #endif
- static int sendto_next_transfer(FAR struct socket *psock,
- FAR struct udp_conn_s *conn);
- static uint16_t sendto_eventhandler(FAR struct net_driver_s *dev,
- FAR void *pvconn, FAR void *pvpriv,
- uint16_t flags);
- /****************************************************************************
- * Private Functions
- ****************************************************************************/
- /****************************************************************************
- * Name: sendto_writebuffer_release
- *
- * Description:
- * Release the write buffer at the head of the write buffer queue.
- *
- * Input Parameters:
- * dev - The structure of the network driver that caused the event
- * psock - Socket state structure
- *
- * Returned Value:
- * None
- *
- * Assumptions:
- * The network is locked
- *
- ****************************************************************************/
- static void sendto_writebuffer_release(FAR struct socket *psock,
- FAR struct udp_conn_s *conn)
- {
- FAR struct udp_wrbuffer_s *wrb;
- int ret = OK;
- do
- {
- /* Check if the write queue became empty */
- if (sq_empty(&conn->write_q))
- {
- /* Yes.. stifle any further callbacks until more write data is
- * enqueued.
- */
- psock->s_sndcb->flags = 0;
- psock->s_sndcb->priv = NULL;
- psock->s_sndcb->event = NULL;
- wrb = NULL;
- }
- else
- {
- /* Remove the write buffer from the head of the write buffer queue
- * and release it.
- */
- wrb = (FAR struct udp_wrbuffer_s *)sq_remfirst(&conn->write_q);
- DEBUGASSERT(wrb != NULL);
- udp_wrbuffer_release(wrb);
- /* Set up for the next packet transfer by setting the connection
- * address to the address of the next packet now at the header of
- * the write buffer queue.
- */
- ret = sendto_next_transfer(psock, conn);
- }
- }
- while (wrb != NULL && ret < 0);
- }
- /****************************************************************************
- * Name: sendto_ipselect
- *
- * Description:
- * If both IPv4 and IPv6 support are enabled, then we will need to select
- * which one to use when generating the outgoing packet. If only one
- * domain is selected, then the setup is already in place and we need do
- * nothing.
- *
- * Input Parameters:
- * dev - The structure of the network driver that caused the event
- * psock - Socket state structure
- *
- * Returned Value:
- * None
- *
- * Assumptions:
- * The network is locked
- *
- ****************************************************************************/
- #ifdef NEED_IPDOMAIN_SUPPORT
- static inline void sendto_ipselect(FAR struct net_driver_s *dev,
- FAR struct udp_conn_s *conn)
- {
- /* Which domain the socket support */
- if (conn->domain == PF_INET)
- {
- /* Select the IPv4 domain */
- udp_ipv4_select(dev);
- }
- else /* if (conn->domain == PF_INET6) */
- {
- /* Select the IPv6 domain */
- DEBUGASSERT(conn->domain == PF_INET6);
- udp_ipv6_select(dev);
- }
- }
- #endif
- /****************************************************************************
- * Name: sendto_addrcheck
- *
- * Description:
- * Check if the destination IP address is in the IPv4 ARP or IPv6 Neighbor
- * tables. If not, then the send won't actually make it out... it will be
- * replaced with an ARP request (IPv4) or a Neighbor Solicitation (IPv6).
- *
- * NOTE 1: This could be an expensive check if there are a lot of
- * entries in the ARP or Neighbor tables.
- *
- * NOTE 2: If we are actually harvesting IP addresses on incoming IP
- * packets, then this check should not be necessary; the MAC mapping
- * should already be in the ARP table in many cases (IPv4 only).
- *
- * NOTE 3: If CONFIG_NET_ARP_SEND then we can be assured that the IP
- * address mapping is already in the ARP table.
- *
- * Input Parameters:
- * conn - The UDP connection structure
- * dev - Polling network device
- *
- * Returned Value:
- * true - The Ethernet MAC address is in the ARP or Neighbor table (OR
- * the network device is not Ethernet).
- *
- * Assumptions:
- * The network is locked
- *
- ****************************************************************************/
- #ifdef CONFIG_NET_ETHERNET
- static inline bool sendto_addrcheck(FAR struct udp_conn_s *conn,
- FAR struct net_driver_s *dev)
- {
- /* REVISIT: Could the MAC address not also be in a routing table? */
- if (dev->d_lltype != NET_LL_ETHERNET)
- {
- return true;
- }
- #ifdef CONFIG_NET_IPv4
- #ifdef CONFIG_NET_IPv6
- if (conn->domain == PF_INET)
- #endif
- {
- #if !defined(CONFIG_NET_ARP_IPIN) && !defined(CONFIG_NET_ARP_SEND)
- return (arp_find(conn->u.ipv4.raddr, NULL) >= 0);
- #else
- return true;
- #endif
- }
- #endif /* CONFIG_NET_IPv4 */
- #ifdef CONFIG_NET_IPv6
- #ifdef CONFIG_NET_IPv4
- else
- #endif
- {
- #if !defined(CONFIG_NET_ICMPv6_NEIGHBOR)
- return (neighbor_lookup(conn->u.ipv6.raddr, NULL) >= 0);
- #else
- return true;
- #endif
- }
- #endif /* CONFIG_NET_IPv6 */
- }
- #endif /* CONFIG_NET_ETHERNET */
- /****************************************************************************
- * Name: sendto_timeout
- *
- * Description:
- * Check for send timeout.
- *
- * Input Parameters:
- * pstate - sendto state structure
- *
- * Returned Value:
- * TRUE:timeout FALSE:no timeout
- *
- * Assumptions:
- * The network is locked
- *
- ****************************************************************************/
- #ifdef CONFIG_NET_SOCKOPTS
- static inline int sendto_timeout(FAR struct socket *psock,
- FAR struct udp_conn_s *conn)
- {
- FAR struct udp_wrbuffer_s *wrb;
- /* Peek at the head of the write queue (without altering the write queue). */
- wrb = (FAR struct udp_wrbuffer_s *)sq_peek(&conn->write_q);
- if (wrb != NULL)
- {
- /* Check for a timeout configured via setsockopts(SO_SNDTIMEO).
- * If none... we well let the send wait forever.
- */
- if (psock->s_sndtimeo != 0)
- {
- /* Check if the configured timeout has elapsed */
- return net_timeo(wrb->wb_start, psock->s_sndtimeo);
- }
- }
- /* No timeout */
- return FALSE;
- }
- #endif /* CONFIG_NET_SOCKOPTS */
- /****************************************************************************
- * Name: sendto_next_transfer
- *
- * Description:
- * Setup for the next packet transfer
- *
- * Input Parameters:
- * psock - Socket state structure
- * conn - The UDP connection structure
- *
- * Returned Value:
- * None
- *
- ****************************************************************************/
- static int sendto_next_transfer(FAR struct socket *psock,
- FAR struct udp_conn_s *conn)
- {
- FAR struct udp_wrbuffer_s *wrb;
- FAR struct net_driver_s *dev;
- int ret;
- /* Set the UDP "connection" to the destination address of the write buffer
- * at the head of the queue.
- */
- wrb = (FAR struct udp_wrbuffer_s *)sq_peek(&conn->write_q);
- if (wrb == NULL)
- {
- ninfo("Write buffer queue is empty\n");
- return -ENOENT;
- }
- ret = udp_connect(conn, (FAR const struct sockaddr *)&wrb->wb_dest);
- if (ret < 0)
- {
- nerr("ERROR: udp_connect failed: %d\n", ret);
- return ret;
- }
- /* Get the device that will handle the remote packet transfers. This
- * should never be NULL.
- */
- dev = udp_find_raddr_device(conn);
- if (dev == NULL)
- {
- nerr("ERROR: udp_find_raddr_device failed\n");
- return -ENETUNREACH;
- }
- /* Make sure that the device is in the UP state */
- if ((dev->d_flags & IFF_UP) == 0)
- {
- nwarn("WARNING: device is DOWN\n");
- return -EHOSTUNREACH;
- }
- /* If this is not the same device that we used in the last call to
- * udp_callback_alloc(), then we need to release and reallocate the old
- * callback instance.
- */
- if (psock->s_sndcb != NULL && conn->dev != dev)
- {
- udp_callback_free(conn->dev, conn, psock->s_sndcb);
- psock->s_sndcb = NULL;
- }
- /* Allocate resources to receive a callback from this device if the
- * callback is not already in place.
- */
- if (psock->s_sndcb == NULL)
- {
- psock->s_sndcb = udp_callback_alloc(dev, conn);
- }
- /* Test if the callback has been allocated */
- if (psock->s_sndcb == NULL)
- {
- /* A buffer allocation error occurred */
- nerr("ERROR: Failed to allocate callback\n");
- return -ENOMEM;
- }
- conn->dev = dev;
- /* Set up the callback in the connection */
- psock->s_sndcb->flags = (UDP_POLL | NETDEV_DOWN);
- psock->s_sndcb->priv = (FAR void *)psock;
- psock->s_sndcb->event = sendto_eventhandler;
- /* Notify the device driver of the availability of TX data */
- netdev_txnotify_dev(dev);
- return OK;
- }
- /****************************************************************************
- * Name: sendto_eventhandler
- *
- * Description:
- * This function is called to perform the actual send operation when
- * polled by the lower, device interfacing layer.
- *
- * Input Parameters:
- * dev The structure of the network driver that caused the event
- * conn 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
- *
- ****************************************************************************/
- static uint16_t sendto_eventhandler(FAR struct net_driver_s *dev,
- FAR void *pvconn, FAR void *pvpriv,
- uint16_t flags)
- {
- FAR struct udp_conn_s *conn = (FAR struct udp_conn_s *)pvconn;
- FAR struct socket *psock = (FAR struct socket *)pvpriv;
- ninfo("flags: %04x\n", flags);
- /* Check if the network device has gone down */
- if ((flags & NETDEV_DOWN) != 0)
- {
- ninfo("Device down: %04x\n", flags);
- /* Free the write buffer at the head of the queue and attempt to setup
- * the next transfer.
- */
- sendto_writebuffer_release(psock, conn);
- return flags;
- }
- /* Check for a normal polling cycle and if the outgoing packet is
- * available. It would not be available if it has been claimed by a send
- * event serving a different thread -OR- if the output buffer currently
- * contains unprocessed incoming data. In these cases we will just have
- * to wait for the next polling cycle.
- *
- * And, of course, we can do nothing if we have no data in the write
- * buffers to send.
- */
- if (dev->d_sndlen <= 0 && (flags & UDP_NEWDATA) == 0 &&
- (flags & UDP_POLL) != 0 && !sq_empty(&conn->write_q))
- {
- /* Check if the destination IP address is in the ARP, Neighbor
- * table, or routing table. If not, then the send won't actually
- * make it out... it will be replaced with an ARP request or
- * Neighbor Solicitation.
- */
- if (sendto_addrcheck(conn, dev))
- {
- FAR struct udp_wrbuffer_s *wrb;
- size_t sndlen;
- /* Peek at the head of the write queue (but don't remove anything
- * from the write queue yet). We know from the above test that
- * the write_q is not empty.
- */
- wrb = (FAR struct udp_wrbuffer_s *)sq_peek(&conn->write_q);
- DEBUGASSERT(wrb != NULL);
- /* Get the amount of data that we can send in the next packet.
- * We will send either the remaining data in the buffer I/O
- * buffer chain, or as much as will fit given the MSS and current
- * window size.
- */
- sndlen = wrb->wb_iob->io_pktlen;
- ninfo("wrb=%p sndlen=%u\n", wrb, sndlen);
- #ifdef NEED_IPDOMAIN_SUPPORT
- /* If both IPv4 and IPv6 support are enabled, then we will need to
- * select which one to use when generating the outgoing packet.
- * If only one domain is selected, then the setup is already in
- * place and we need do nothing.
- */
- sendto_ipselect(dev, conn);
- #endif
- /* Then set-up to send that amount of data with the offset
- * corresponding to the size of the IP-dependent address structure.
- */
- devif_iob_send(dev, wrb->wb_iob, sndlen, 0);
- /* Free the write buffer at the head of the queue and attempt to
- * setup the next transfer.
- */
- sendto_writebuffer_release(psock, conn);
- /* Only one data can be sent by low level driver at once,
- * tell the caller stop polling the other connections.
- */
- flags &= ~UDP_POLL;
- }
- }
- #ifdef CONFIG_NET_SOCKOPTS
- /* We cannot send the data now. Check for a timeout. */
- else if (sendto_timeout(psock, conn))
- {
- /* Free the write buffer at the head of the queue and attempt to setup
- * the next transfer.
- */
- sendto_writebuffer_release(psock, conn);
- }
- #endif /* CONFIG_NET_SOCKOPTS */
- /* Continue waiting */
- return flags;
- }
- /****************************************************************************
- * Public Functions
- ****************************************************************************/
- /****************************************************************************
- * Name: psock_udp_sendto
- *
- * Description:
- * This function implements the UDP-specific logic of the standard
- * sendto() socket operation.
- *
- * Input Parameters:
- * psock A pointer to a NuttX-specific, internal socket structure
- * buf Data to send
- * len Length of data to send
- * flags Send flags
- * to Address of recipient
- * tolen The length of the address structure
- *
- * NOTE: All input parameters were verified by sendto() before this
- * function was called.
- *
- * Returned Value:
- * On success, returns the number of characters sent. On error,
- * a negated errno value is returned. See the description in
- * net/socket/sendto.c for the list of appropriate return value.
- *
- ****************************************************************************/
- ssize_t psock_udp_sendto(FAR struct socket *psock, FAR const void *buf,
- size_t len, int flags, FAR const struct sockaddr *to,
- socklen_t tolen)
- {
- FAR struct udp_conn_s *conn;
- FAR struct udp_wrbuffer_s *wrb;
- int ret = OK;
- /* If the UDP socket was previously assigned a remote peer address via
- * connect(), then as with connection-mode socket, sendto() may not be
- * used with a non-NULL destination address. Normally send() would be
- * used with such connected UDP sockets.
- */
- if (to != NULL && _SS_ISCONNECTED(psock->s_flags))
- {
- /* EISCONN - A destination address was specified and the socket is
- * already connected.
- */
- return -EISCONN;
- }
- /* Otherwise, if the socket is not connected, then a destination address
- * must be provided.
- */
- else if (to == NULL && !_SS_ISCONNECTED(psock->s_flags))
- {
- /* EDESTADDRREQ - The socket is not connection-mode and no peer
- * address is set.
- */
- return -EDESTADDRREQ;
- }
- /* Get the underlying the UDP connection structure. */
- conn = (FAR struct udp_conn_s *)psock->s_conn;
- DEBUGASSERT(conn);
- #if defined(CONFIG_NET_ARP_SEND) || defined(CONFIG_NET_ICMPv6_NEIGHBOR)
- #ifdef CONFIG_NET_ARP_SEND
- /* Assure the the IPv4 destination address maps to a valid MAC address in
- * the ARP table.
- */
- #ifdef CONFIG_NET_ICMPv6_NEIGHBOR
- if (psock->s_domain == PF_INET)
- #endif
- {
- in_addr_t destipaddr;
- /* Check if the socket is connection mode */
- if (_SS_ISCONNECTED(psock->s_flags))
- {
- /* Yes.. use the connected remote address (the 'to' address is
- * null).
- */
- destipaddr = conn->u.ipv4.raddr;
- }
- else
- {
- FAR const struct sockaddr_in *into;
- /* No.. use the destination address provided by the non-NULL 'to'
- * argument.
- */
- into = (FAR const struct sockaddr_in *)to;
- destipaddr = into->sin_addr.s_addr;
- }
- /* Make sure that the IP address mapping is in the ARP table */
- ret = arp_send(destipaddr);
- }
- #endif /* CONFIG_NET_ARP_SEND */
- #ifdef CONFIG_NET_ICMPv6_NEIGHBOR
- /* Assure the the IPv6 destination address maps to a valid MAC address in
- * the neighbor table.
- */
- #ifdef CONFIG_NET_ARP_SEND
- else
- #endif
- {
- FAR const uint16_t *destipaddr;
- /* Check if the socket is connection mode */
- if (_SS_ISCONNECTED(psock->s_flags))
- {
- /* Yes.. use the connected remote address (the 'to' address is
- * null).
- */
- destipaddr = conn->u.ipv6.raddr;
- }
- else
- {
- FAR const struct sockaddr_in6 *into;
- /* No.. use the destination address provided by the non-NULL 'to'
- * argument.
- */
- into = (FAR const struct sockaddr_in6 *)to;
- destipaddr = into->sin6_addr.s6_addr16;
- }
- /* Make sure that the IP address mapping is in the Neighbor Table */
- ret = icmpv6_neighbor(destipaddr);
- }
- #endif /* CONFIG_NET_ICMPv6_NEIGHBOR */
- /* Did we successfully get the address mapping? */
- if (ret < 0)
- {
- nerr("ERROR: Not reachable\n");
- return -ENETUNREACH;
- }
- #endif /* CONFIG_NET_ARP_SEND || CONFIG_NET_ICMPv6_NEIGHBOR */
- /* Dump the incoming buffer */
- BUF_DUMP("psock_udp_send", buf, len);
- /* Set the socket state to sending */
- psock->s_flags = _SS_SETSTATE(psock->s_flags, _SF_SEND);
- if (len > 0)
- {
- /* Allocate a write buffer. Careful, the network will be momentarily
- * unlocked here.
- */
- net_lock();
- wrb = udp_wrbuffer_alloc();
- if (wrb == NULL)
- {
- /* A buffer allocation error occurred */
- nerr("ERROR: Failed to allocate write buffer\n");
- ret = -ENOMEM;
- goto errout_with_lock;
- }
- /* Initialize the write buffer */
- /* Check if the socket is connected */
- if (_SS_ISCONNECTED(psock->s_flags))
- {
- /* Yes.. get the connection address from the connection structure */
- #ifdef CONFIG_NET_IPv4
- #ifdef CONFIG_NET_IPv6
- if (conn->domain == PF_INET)
- #endif
- {
- FAR struct sockaddr_in *addr4 =
- (FAR struct sockaddr_in *)&wrb->wb_dest;
- addr4->sin_family = AF_INET;
- addr4->sin_port = conn->rport;
- net_ipv4addr_copy(addr4->sin_addr.s_addr, conn->u.ipv4.raddr);
- }
- #endif /* CONFIG_NET_IPv4 */
- #ifdef CONFIG_NET_IPv6
- #ifdef CONFIG_NET_IPv4
- else
- #endif
- {
- FAR struct sockaddr_in6 *addr6 =
- (FAR struct sockaddr_in6 *)&wrb->wb_dest;
- addr6->sin6_family = AF_INET6;
- addr6->sin6_port = conn->rport;
- net_ipv6addr_copy(addr6->sin6_addr.s6_addr, conn->u.ipv6.raddr);
- }
- #endif /* CONFIG_NET_IPv6 */
- }
- /* Not connected. Use the provided destination address */
- else
- {
- memcpy(&wrb->wb_dest, to, tolen);
- }
- #ifdef CONFIG_NET_SOCKOPTS
- wrb->wb_start = clock_systimer();
- #endif
- /* Copy the user data into the write buffer. We cannot wait for
- * buffer space if the socket was opened non-blocking.
- */
- if (_SS_ISNONBLOCK(psock->s_flags))
- {
- ret = iob_trycopyin(wrb->wb_iob, (FAR uint8_t *)buf, len, 0, false);
- }
- else
- {
- ret = iob_copyin(wrb->wb_iob, (FAR uint8_t *)buf, len, 0, false);
- }
- if (ret < 0)
- {
- goto errout_with_wrb;
- }
- /* Dump I/O buffer chain */
- UDP_WBDUMP("I/O buffer chain", wrb, wrb->wb_iob->io_pktlen, 0);
- /* sendto_eventhandler() will send data in FIFO order from the
- * conn->write_q.
- *
- * REVISIT: Why FIFO order? Because it is easy. In a real world
- * environment where there are multiple network devices this might
- * be inefficient because we could be sending data to different
- * device out-of-queued-order to optimize performance. Sending
- * data to different networks from a single UDP socket is probably
- * not a very common use case, however.
- */
- sq_addlast(&wrb->wb_node, &conn->write_q);
- ninfo("Queued WRB=%p pktlen=%u write_q(%p,%p)\n",
- wrb, wrb->wb_iob->io_pktlen,
- conn->write_q.head, conn->write_q.tail);
- /* Set up for the next packet transfer by setting the connection
- * address to the address of the next packet now at the header of the
- * write buffer queue.
- */
- ret = sendto_next_transfer(psock, conn);
- if (ret < 0)
- {
- (void)sq_remlast(&conn->write_q);
- goto errout_with_wrb;
- }
- net_unlock();
- }
- /* Set the socket state to idle */
- psock->s_flags = _SS_SETSTATE(psock->s_flags, _SF_IDLE);
- /* Return the number of bytes that will be sent */
- return len;
- errout_with_wrb:
- udp_wrbuffer_release(wrb);
- errout_with_lock:
- net_unlock();
- return ret;
- }
- /****************************************************************************
- * Name: psock_udp_cansend
- *
- * Description:
- * psock_udp_cansend() returns a value indicating if a write to the socket
- * would block. No space in the buffer is actually reserved, so it is
- * possible that the write may still block if the buffer is filled by
- * another means.
- *
- * Input Parameters:
- * psock An instance of the internal socket structure.
- *
- * Returned Value:
- * OK
- * At least one byte of data could be successfully written.
- * -EWOULDBLOCK
- * There is no room in the output buffer.
- * -EBADF
- * An invalid descriptor was specified.
- *
- ****************************************************************************/
- int psock_udp_cansend(FAR struct socket *psock)
- {
- /* Verify that we received a valid socket */
- if (!psock || psock->s_crefs <= 0)
- {
- nerr("ERROR: Invalid socket\n");
- return -EBADF;
- }
- /* In order to setup the send, we need to have at least one free write
- * buffer head and at least one free IOB to initialize the write buffer head.
- *
- * REVISIT: The send will still block if we are unable to buffer the entire
- * user-provided buffer which may be quite large. We will almost certainly
- * need to have more than one free IOB, but we don't know how many more.
- */
- if (udp_wrbuffer_test() < 0 || iob_navail(false) <= 0)
- {
- return -EWOULDBLOCK;
- }
- return OK;
- }
- #endif /* CONFIG_NET && CONFIG_NET_UDP && CONFIG_NET_UDP_WRITE_BUFFERS */
|