/**************************************************************************** * net/udp/udp_sendto_buffered.c * * 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 #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 #include #include #include #include #include #include #include #include #include #include #include #include #include #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" #include "utils/utils.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 /* 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 static int sendto_next_transfer(FAR struct udp_conn_s *conn); static uint16_t sendto_eventhandler(FAR struct net_driver_s *dev, 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: * conn - The UDP connection of interest * * Returned Value: * None * * Assumptions: * The network is locked * ****************************************************************************/ static void sendto_writebuffer_release(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. */ conn->sndcb->flags = 0; conn->sndcb->priv = NULL; conn->sndcb->event = NULL; wrb = NULL; #ifdef CONFIG_NET_UDP_NOTIFIER /* Notify any waiters that the write buffers have been drained. */ udp_writebuffer_signal(conn); #endif } 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(conn); } } while (wrb != NULL && ret < 0); #if CONFIG_NET_SEND_BUFSIZE > 0 /* Notify the send buffer available if wrbbuffer drained */ udp_sendbuffer_notify(conn); #endif /* CONFIG_NET_SEND_BUFSIZE */ } /**************************************************************************** * 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 * conn - The UDP connection of interest * * 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 || (conn->domain == PF_INET6 && ip6_is_ipv4addr((FAR struct in6_addr *)conn->u.ipv6.raddr))) { /* Select the IPv4 domain */ udp_ipv4_select(dev); } else /* if (conn->domain == PF_INET6) */ { /* Select the IPv6 domain */ udp_ipv6_select(dev); } } #endif /**************************************************************************** * Name: sendto_next_transfer * * Description: * Setup for the next packet transfer. That function is called (1) * psock_udp_sendto() by when the new UDP packet is buffered at the head of * the write queue and (2) by sendto_writebuffer_release() when that * previously queued write buffer was sent and a new write buffer lies at * the head of the write queue. * * Input Parameters: * conn - The UDP connection structure * * Returned Value: * None * ****************************************************************************/ static int sendto_next_transfer(FAR struct udp_conn_s *conn) { FAR struct udp_wrbuffer_s *wrb; FAR struct net_driver_s *dev; /* 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; } /* Has this address already been bound to a local port (lport)? */ if (!conn->lport) { /* No.. Find an unused local port number and bind it to the * connection structure. */ conn->lport = HTONS(udp_select_port(conn->domain, &conn->u)); if (!conn->lport) { nerr("ERROR: Failed to get a local port!\n"); return -EADDRINUSE; } } /* Get the device that will handle the remote packet transfers. This * should never be NULL. * * REVISIT: There is a logical error here for the case where there are * multiple network devices. In that case, the packets may need to be sent * in a different order than they were queued. Forcing FIFO packet * transmission could harm performance. */ dev = udp_find_raddr_device(conn, &wrb->wb_dest); 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; } #ifndef CONFIG_NET_IPFRAG /* Sanity check if the packet len (with IP hdr) is greater than the MTU */ if (wrb->wb_iob->io_pktlen > devif_get_mtu(dev)) { nerr("ERROR: Packet too long to send!\n"); return -EMSGSIZE; } #endif /* 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 (conn->sndcb != NULL && conn->dev != dev) { udp_callback_free(conn->dev, conn, conn->sndcb); conn->sndcb = NULL; } /* Allocate resources to receive a callback from this device if the * callback is not already in place. */ if (conn->sndcb == NULL) { conn->sndcb = udp_callback_alloc(dev, conn); } /* Test if the callback has been allocated */ if (conn->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 */ conn->sndcb->flags = (UDP_POLL | NETDEV_DOWN); conn->sndcb->priv = (FAR void *)conn; conn->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 *pvpriv, uint16_t flags) { FAR struct udp_conn_s *conn = pvpriv; DEBUGASSERT(dev != NULL && conn != NULL); 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(conn); return flags; } /* The UDP socket should be bound to a device. Make sure that the polling * device is the one that we are bound to. * * REVISIT: There is a logical error here for the case where there are * multiple network devices. In that case, the packets may need to be sent * in a different order than they were queued. The packet we may need to * send on this device may not be at the head of the list. Forcing FIFO * packet transmission could degrade performance! */ DEBUGASSERT(conn != NULL); DEBUGASSERT(conn->dev != NULL); if (dev != conn->dev) { 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)) { uint16_t udpiplen = udpip_hdrsize(conn); FAR struct udp_wrbuffer_s *wrb; /* 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); /* If the udp socket not connected, it is possible to have * multi-different destination address in each iob entry, * update the remote address every time to avoid sent to the * incorrect destination. */ udp_connect(conn, (FAR const struct sockaddr *)&wrb->wb_dest); /* Then set-up to send that amount of data with the offset * corresponding to the size of the IP-dependent address structure. */ netdev_iob_replace(dev, wrb->wb_iob); /* 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. */ dev->d_sndlen = wrb->wb_iob->io_pktlen - udpiplen; ninfo("wrb=%p sndlen=%d\n", wrb, dev->d_sndlen); /* Do not need to release wb_iob, the life cycle of wb_iob is * handed over to the network device */ wrb->wb_iob = NULL; #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 /* Free the write buffer at the head of the queue and attempt to * setup the next transfer. */ sendto_writebuffer_release(conn); /* Only one data can be sent by low level driver at once, * tell the caller stop polling the other connections. */ flags &= ~UDP_POLL; } /* Continue waiting */ return flags; } /**************************************************************************** * Name: udp_send_gettimeout * * Description: * Calculate the send timeout * ****************************************************************************/ static unsigned int udp_send_gettimeout(clock_t start, unsigned int timeout) { unsigned int elapse; if (timeout != UINT_MAX) { elapse = TICK2MSEC(clock_systime_ticks() - start); if (elapse >= timeout) { timeout = 0; } else { timeout -= elapse; } } return timeout; } /**************************************************************************** * 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_wrbuffer_s *wrb; FAR struct udp_conn_s *conn; unsigned int timeout; uint16_t udpiplen; bool nonblock; bool empty; int ret = OK; clock_t start; /* Get the underlying the UDP connection structure. */ conn = psock->s_conn; /* The length of a datagram to be up to 65,535 octets */ if (len > 65535) { return -EMSGSIZE; } /* 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(conn->sconn.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(conn->sconn.s_flags)) { /* EDESTADDRREQ - The socket is not connection-mode and no peer * address is set. */ return -EDESTADDRREQ; } #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. */ if (psock->s_domain == PF_INET) { in_addr_t destipaddr; /* Check if the socket is connection mode */ if (_SS_ISCONNECTED(conn->sconn.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. */ if (psock->s_domain == PF_INET6) { FAR const uint16_t *destipaddr; /* Check if the socket is connection mode */ if (_SS_ISCONNECTED(conn->sconn.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(NULL, 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 */ nonblock = _SS_ISNONBLOCK(conn->sconn.s_flags) || (flags & MSG_DONTWAIT) != 0; start = clock_systime_ticks(); timeout = _SO_TIMEOUT(conn->sconn.s_sndtimeo); /* Dump the incoming buffer */ BUF_DUMP("psock_udp_sendto", buf, len); if (len > 0) { net_lock(); #if CONFIG_NET_SEND_BUFSIZE > 0 /* If the send buffer size exceeds the send limit, * wait for the write buffer to be released */ while (udp_wrbuffer_inqueue_size(conn) + len > conn->sndbufs) { if (nonblock) { ret = -EAGAIN; goto errout_with_lock; } ret = net_sem_timedwait_uninterruptible(&conn->sndsem, udp_send_gettimeout(start, timeout)); if (ret < 0) { if (ret == -ETIMEDOUT) { ret = -EAGAIN; } goto errout_with_lock; } } #endif /* CONFIG_NET_SEND_BUFSIZE */ /* Allocate a write buffer. Careful, the network will be momentarily * unlocked here. */ #ifdef CONFIG_NET_JUMBO_FRAME /* alloc iob of gso pkt for udp data */ wrb = udp_wrbuffer_tryalloc(len + udpip_hdrsize(conn) + CONFIG_NET_LL_GUARDSIZE); #else if (nonblock) { wrb = udp_wrbuffer_tryalloc(); } else { wrb = udp_wrbuffer_timedalloc(udp_send_gettimeout(start, timeout)); } #endif if (wrb == NULL) { /* A buffer allocation error occurred */ nerr("ERROR: Failed to allocate write buffer\n"); if (nonblock || timeout != UINT_MAX) { ret = -EAGAIN; } else { ret = -ENOMEM; } goto errout_with_lock; } /* Initialize the write buffer * * Check if the socket is connected */ if (_SS_ISCONNECTED(conn->sconn.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); memset(addr4->sin_zero, 0, sizeof(addr4->sin_zero)); } #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); udp_connect(conn, to); } /* Skip l2/l3/l4 offset before copy */ udpiplen = udpip_hdrsize(conn); iob_reserve(wrb->wb_iob, CONFIG_NET_LL_GUARDSIZE); iob_update_pktlen(wrb->wb_iob, udpiplen, false); /* Copy the user data into the write buffer. We cannot wait for * buffer space if the socket was opened non-blocking. */ if (nonblock) { ret = iob_trycopyin(wrb->wb_iob, (FAR uint8_t *)buf, len, udpiplen, false); } else { unsigned int count; int blresult; /* iob_copyin might wait for buffers to be freed, but if * network is locked this might never happen, since network * driver is also locked, therefore we need to break the lock */ blresult = net_breaklock(&count); ret = iob_copyin(wrb->wb_iob, (FAR uint8_t *)buf, len, udpiplen, false); if (blresult >= 0) { net_restorelock(count); } } 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. */ empty = sq_empty(&conn->write_q); 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); if (empty) { /* The new write buffer lies at the head of the write queue. 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(conn); if (ret < 0) { sq_remlast(&conn->write_q); goto errout_with_wrb; } } net_unlock(); } /* 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: * conn A reference to UDP connection 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 udp_conn_s *conn) { /* Verify that we received a valid socket */ if (conn == NULL) { 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; } /**************************************************************************** * Name: udp_sendbuffer_notify * * Description: * Notify the send buffer semaphore * * Input Parameters: * conn - The UDP connection of interest * * Assumptions: * Called from user logic with the network locked. * ****************************************************************************/ #if CONFIG_NET_SEND_BUFSIZE > 0 void udp_sendbuffer_notify(FAR struct udp_conn_s *conn) { int val = 0; nxsem_get_value(&conn->sndsem, &val); if (val < 0) { nxsem_post(&conn->sndsem); } } #endif /* CONFIG_NET_SEND_BUFSIZE */ #endif /* CONFIG_NET && CONFIG_NET_UDP && CONFIG_NET_UDP_WRITE_BUFFERS */