2014-06-25 02:12:49 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* net/udp/udp.h
|
|
|
|
*
|
2021-02-19 12:45:37 +01: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
|
2014-06-25 02:12:49 +02:00
|
|
|
*
|
2021-02-19 12:45:37 +01:00
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
2014-06-25 02:12:49 +02:00
|
|
|
*
|
2021-02-19 12:45:37 +01:00
|
|
|
* 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.
|
2014-06-25 02:12:49 +02:00
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
#ifndef __NET_UDP_UDP_H
|
|
|
|
#define __NET_UDP_UDP_H
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Included Files
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
#include <nuttx/config.h>
|
|
|
|
|
|
|
|
#include <sys/types.h>
|
2018-01-23 14:32:17 +01:00
|
|
|
#include <sys/socket.h>
|
2015-01-28 20:41:24 +01:00
|
|
|
|
2022-09-25 17:08:38 +02:00
|
|
|
#include <nuttx/queue.h>
|
2021-07-19 15:45:46 +02:00
|
|
|
#include <nuttx/semaphore.h>
|
2015-01-28 20:41:24 +01:00
|
|
|
#include <nuttx/net/ip.h>
|
2022-02-07 04:34:18 +01:00
|
|
|
#include <nuttx/net/net.h>
|
2022-11-23 12:39:40 +01:00
|
|
|
#include <nuttx/net/udp.h>
|
2020-01-11 04:56:03 +01:00
|
|
|
#include <nuttx/mm/iob.h>
|
2015-01-30 13:08:26 +01:00
|
|
|
|
2019-12-31 16:26:14 +01:00
|
|
|
#ifdef CONFIG_NET_UDP_NOTIFIER
|
2018-09-09 23:01:44 +02:00
|
|
|
# include <nuttx/wqueue.h>
|
|
|
|
#endif
|
|
|
|
|
2017-03-31 16:58:14 +02:00
|
|
|
#if defined(CONFIG_NET_UDP) && !defined(CONFIG_NET_UDP_NO_STACK)
|
2014-06-25 02:12:49 +02:00
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Pre-processor Definitions
|
|
|
|
****************************************************************************/
|
2017-03-31 16:58:14 +02:00
|
|
|
|
|
|
|
#define NET_UDP_HAVE_STACK 1
|
|
|
|
|
2018-01-23 01:32:02 +01:00
|
|
|
#ifdef CONFIG_NET_UDP_WRITE_BUFFERS
|
|
|
|
/* UDP write buffer dump macros */
|
|
|
|
|
|
|
|
# ifdef CONFIG_DEBUG_FEATURES
|
2018-01-23 02:33:14 +01:00
|
|
|
# define UDP_WBDUMP(msg,wrb,len,offset) \
|
2018-01-23 01:32:02 +01:00
|
|
|
udp_wrbuffer_dump(msg,wrb,len,offset)
|
|
|
|
# else
|
2018-01-23 02:33:14 +01:00
|
|
|
# define UDP_WBDUMP(msg,wrb,len,offset)
|
2018-01-23 01:32:02 +01:00
|
|
|
# endif
|
|
|
|
#endif
|
|
|
|
|
2015-01-17 14:42:09 +01:00
|
|
|
/* Allocate a new UDP data callback */
|
2014-06-29 02:36:09 +02:00
|
|
|
|
2017-07-05 19:01:16 +02:00
|
|
|
#define udp_callback_alloc(dev,conn) \
|
2022-02-07 04:34:18 +01:00
|
|
|
devif_callback_alloc((dev), &(conn)->sconn.list, &(conn)->sconn.list_tail)
|
2017-07-05 19:01:16 +02:00
|
|
|
#define udp_callback_free(dev,conn,cb) \
|
2022-02-07 04:34:18 +01:00
|
|
|
devif_conn_callback_free((dev), (cb), &(conn)->sconn.list, &(conn)->sconn.list_tail)
|
2014-06-29 02:36:09 +02:00
|
|
|
|
net/udp: Resolve race condition in connection-less UDP sockets with read-ahead buffering.
In connection-mode UDP sockets, a remote address is retained in the UDP connection structure. This determines both there send() will send the packets and which packets recv() will accept.
This same mechanism is used for connection-less UDP sendto: A temporary remote address is written into the connection structure to support the sendto() operation. That address persists until the next recvfrom() when it is reset to accept any address.
When UDP read-ahead buffering is enabled, however, that means that the old, invalid remote address can be left in the connection structure for some time. This can cause read-ahead buffer to fail, dropping UDP packets.
Shortening the time between when he remote address is reset (i.e., immediately after the sendto() completes) is not a solution, that does not eliminate the race condition; in only makes it smaller.
With this change, a flag was added to the connection structure to indicate if the UDP socket is in connection mode or if it is connection-less. This change effects only UDP receive operations: The remote address in the UDP connection is always ignored if the UDP socket is not in connection-mode.
No for connection-mode sockets, that remote address behaves as before. But for connection-less sockets, it is only used by sendto().
2018-05-13 17:57:34 +02:00
|
|
|
/* Definitions for the UDP connection struct flag field */
|
|
|
|
|
|
|
|
#define _UDP_FLAG_CONNECTMODE (1 << 0) /* Bit 0: UDP connection-mode */
|
|
|
|
|
|
|
|
#define _UDP_ISCONNECTMODE(f) (((f) & _UDP_FLAG_CONNECTMODE) != 0)
|
|
|
|
|
2022-10-26 06:35:08 +02:00
|
|
|
/* This is a helper pointer for accessing the contents of the udp header */
|
|
|
|
|
|
|
|
#define UDPIPv4BUF ((FAR struct udp_hdr_s *)IPBUF(IPv4_HDRLEN))
|
|
|
|
#define UDPIPv6BUF ((FAR struct udp_hdr_s *)IPBUF(IPv6_HDRLEN))
|
|
|
|
|
2014-06-25 02:12:49 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Public Type Definitions
|
|
|
|
****************************************************************************/
|
|
|
|
|
2019-12-31 16:26:14 +01:00
|
|
|
struct sockaddr; /* Forward reference */
|
|
|
|
struct socket; /* Forward reference */
|
|
|
|
struct net_driver_s; /* Forward reference */
|
|
|
|
struct pollfd; /* Forward reference */
|
|
|
|
|
2016-05-30 17:31:44 +02:00
|
|
|
/* Representation of a UDP connection */
|
2014-07-05 22:40:29 +02:00
|
|
|
|
|
|
|
struct devif_callback_s; /* Forward reference */
|
2015-01-15 22:06:46 +01:00
|
|
|
struct udp_hdr_s; /* Forward reference */
|
2014-07-05 22:40:29 +02:00
|
|
|
|
2019-12-31 16:26:14 +01:00
|
|
|
/* This is a container that holds the poll-related information */
|
|
|
|
|
|
|
|
struct udp_poll_s
|
|
|
|
{
|
2022-02-08 16:24:04 +01:00
|
|
|
FAR struct udp_conn_s *conn; /* Needed to handle loss of connection */
|
2019-12-31 16:26:14 +01:00
|
|
|
FAR struct net_driver_s *dev; /* Needed to free the callback structure */
|
|
|
|
struct pollfd *fds; /* Needed to handle poll events */
|
|
|
|
FAR struct devif_callback_s *cb; /* Needed to teardown the poll */
|
|
|
|
};
|
|
|
|
|
2014-07-05 22:40:29 +02:00
|
|
|
struct udp_conn_s
|
|
|
|
{
|
2019-09-01 16:47:01 +02:00
|
|
|
/* Common prologue of all connection structures. */
|
|
|
|
|
2022-02-07 04:34:18 +01:00
|
|
|
struct socket_conn_s sconn;
|
2019-09-01 16:47:01 +02:00
|
|
|
|
|
|
|
/* UDP-specific content follows */
|
|
|
|
|
2015-01-16 17:01:54 +01:00
|
|
|
union ip_binding_u u; /* IP address binding */
|
2014-11-21 21:21:30 +01:00
|
|
|
uint16_t lport; /* Bound local port number (network byte order) */
|
|
|
|
uint16_t rport; /* Remote port number (network byte order) */
|
net/udp: Resolve race condition in connection-less UDP sockets with read-ahead buffering.
In connection-mode UDP sockets, a remote address is retained in the UDP connection structure. This determines both there send() will send the packets and which packets recv() will accept.
This same mechanism is used for connection-less UDP sendto: A temporary remote address is written into the connection structure to support the sendto() operation. That address persists until the next recvfrom() when it is reset to accept any address.
When UDP read-ahead buffering is enabled, however, that means that the old, invalid remote address can be left in the connection structure for some time. This can cause read-ahead buffer to fail, dropping UDP packets.
Shortening the time between when he remote address is reset (i.e., immediately after the sendto() completes) is not a solution, that does not eliminate the race condition; in only makes it smaller.
With this change, a flag was added to the connection structure to indicate if the UDP socket is in connection mode or if it is connection-less. This change effects only UDP receive operations: The remote address in the UDP connection is always ignored if the UDP socket is not in connection-mode.
No for connection-mode sockets, that remote address behaves as before. But for connection-less sockets, it is only used by sendto().
2018-05-13 17:57:34 +02:00
|
|
|
uint8_t flags; /* See _UDP_FLAG_* definitions */
|
2016-02-26 13:45:37 +01:00
|
|
|
uint8_t domain; /* IP domain: PF_INET or PF_INET6 */
|
2014-07-05 22:40:29 +02:00
|
|
|
uint8_t ttl; /* Default time-to-live */
|
|
|
|
uint8_t crefs; /* Reference counts on this instance */
|
|
|
|
|
2021-07-05 10:01:48 +02:00
|
|
|
#if CONFIG_NET_RECV_BUFSIZE > 0
|
|
|
|
int32_t rcvbufs; /* Maximum amount of bytes queued in recv */
|
|
|
|
#endif
|
2021-07-19 15:45:46 +02:00
|
|
|
#if CONFIG_NET_SEND_BUFSIZE > 0
|
|
|
|
int32_t sndbufs; /* Maximum amount of bytes queued in send */
|
|
|
|
sem_t sndsem; /* Semaphore signals send completion */
|
|
|
|
#endif
|
2018-06-25 23:07:53 +02:00
|
|
|
|
2015-01-30 13:08:26 +01:00
|
|
|
/* Read-ahead buffering.
|
|
|
|
*
|
|
|
|
* readahead - A singly linked list of type struct iob_qentry_s
|
|
|
|
* where the UDP/IP read-ahead data is retained.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct iob_queue_s readahead; /* Read-ahead buffering */
|
|
|
|
|
2018-03-30 20:03:34 +02:00
|
|
|
#ifdef CONFIG_NET_UDP_WRITE_BUFFERS
|
2018-01-23 01:32:02 +01:00
|
|
|
/* Write buffering
|
|
|
|
*
|
|
|
|
* write_q - The queue of unsent I/O buffers. The head of this
|
|
|
|
* list may be partially sent. FIFO ordering.
|
|
|
|
*/
|
|
|
|
|
|
|
|
sq_queue_t write_q; /* Write buffering for UDP packets */
|
|
|
|
FAR struct net_driver_s *dev; /* Last device */
|
2022-02-07 04:03:03 +01:00
|
|
|
|
|
|
|
/* Callback instance for UDP sendto() */
|
|
|
|
|
|
|
|
FAR struct devif_callback_s *sndcb;
|
2018-01-23 01:32:02 +01:00
|
|
|
#endif
|
2019-12-31 16:26:14 +01:00
|
|
|
|
|
|
|
/* The following is a list of poll structures of threads waiting for
|
|
|
|
* socket events.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct udp_poll_s pollinfo[CONFIG_NET_UDP_NPOLLWAITERS];
|
2014-07-05 22:40:29 +02:00
|
|
|
};
|
|
|
|
|
2018-01-23 01:32:02 +01:00
|
|
|
/* This structure supports UDP write buffering. It is simply a container
|
|
|
|
* for a IOB list and associated destination address.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef CONFIG_NET_UDP_WRITE_BUFFERS
|
|
|
|
struct udp_wrbuffer_s
|
|
|
|
{
|
2018-01-23 14:32:17 +01:00
|
|
|
sq_entry_t wb_node; /* Supports a singly linked list */
|
|
|
|
struct sockaddr_storage wb_dest; /* Destination address */
|
|
|
|
struct iob_s *wb_iob; /* Head of the I/O buffer chain */
|
2018-01-23 01:32:02 +01:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
2014-06-25 02:12:49 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Public Data
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
|
|
# define EXTERN extern "C"
|
|
|
|
extern "C"
|
|
|
|
{
|
|
|
|
#else
|
|
|
|
# define EXTERN extern
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Public Function Prototypes
|
|
|
|
****************************************************************************/
|
|
|
|
|
2014-07-05 22:40:29 +02:00
|
|
|
/****************************************************************************
|
2015-01-17 20:07:48 +01:00
|
|
|
* Name: udp_initialize
|
2014-07-05 22:40:29 +02:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Initialize the UDP connection structures. Called once and only from
|
|
|
|
* the UIP layer.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
2014-06-26 17:32:39 +02:00
|
|
|
|
2014-06-25 02:55:01 +02:00
|
|
|
void udp_initialize(void);
|
2014-07-05 22:40:29 +02:00
|
|
|
|
|
|
|
/****************************************************************************
|
2015-01-17 20:07:48 +01:00
|
|
|
* Name: udp_alloc
|
2014-07-05 22:40:29 +02:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Allocate a new, uninitialized UDP connection structure. This is
|
|
|
|
* normally something done by the implementation of the socket() API
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2015-01-17 20:07:48 +01:00
|
|
|
FAR struct udp_conn_s *udp_alloc(uint8_t domain);
|
2014-07-05 22:40:29 +02:00
|
|
|
|
|
|
|
/****************************************************************************
|
2015-01-17 20:07:48 +01:00
|
|
|
* Name: udp_free
|
2014-07-05 22:40:29 +02:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Free a UDP connection structure that is no longer in use. This should be
|
|
|
|
* done by the implementation of close().
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
void udp_free(FAR struct udp_conn_s *conn);
|
|
|
|
|
|
|
|
/****************************************************************************
|
2015-01-17 20:07:48 +01:00
|
|
|
* Name: udp_active
|
2014-07-05 22:40:29 +02:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Find a connection structure that is the appropriate
|
2015-01-17 14:42:09 +01:00
|
|
|
* connection to be used within the provided UDP/IP header
|
2014-07-05 22:40:29 +02:00
|
|
|
*
|
|
|
|
* Assumptions:
|
2015-01-15 22:06:46 +01:00
|
|
|
* Called from network stack logic with the network stack locked
|
2014-07-05 22:40:29 +02:00
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2015-01-15 22:06:46 +01:00
|
|
|
FAR struct udp_conn_s *udp_active(FAR struct net_driver_s *dev,
|
|
|
|
FAR struct udp_hdr_s *udp);
|
2014-07-05 22:40:29 +02:00
|
|
|
|
|
|
|
/****************************************************************************
|
2015-01-17 20:07:48 +01:00
|
|
|
* Name: udp_nextconn
|
2014-07-05 22:40:29 +02:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Traverse the list of allocated UDP connections
|
|
|
|
*
|
|
|
|
* Assumptions:
|
2015-01-15 22:06:46 +01:00
|
|
|
* Called from network stack logic with the network stack locked
|
2014-07-05 22:40:29 +02:00
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2014-07-01 02:03:58 +02:00
|
|
|
FAR struct udp_conn_s *udp_nextconn(FAR struct udp_conn_s *conn);
|
2014-06-25 02:55:01 +02:00
|
|
|
|
2021-12-17 07:35:51 +01:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: udp_select_port
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Select an unused port number.
|
|
|
|
*
|
|
|
|
* NOTE that in principle this function could fail if there is no available
|
|
|
|
* port number. There is no check for that case and it would actually
|
|
|
|
* in an infinite loop if that were the case. In this simple, small UDP
|
|
|
|
* implementation, it is reasonable to assume that that error cannot happen
|
|
|
|
* and that a port number will always be available.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
uint16_t udp_select_port(uint8_t domain, FAR union ip_binding_u *u);
|
|
|
|
|
2014-07-05 22:40:29 +02:00
|
|
|
/****************************************************************************
|
2015-01-17 20:07:48 +01:00
|
|
|
* Name: udp_bind
|
2014-07-05 22:40:29 +02:00
|
|
|
*
|
|
|
|
* Description:
|
2015-01-17 14:42:09 +01:00
|
|
|
* This function implements the low-level parts of the standard UDP bind()
|
|
|
|
* operation.
|
2014-07-05 22:40:29 +02:00
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
* This function is called from normal user level code.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2015-01-17 21:13:56 +01:00
|
|
|
int udp_bind(FAR struct udp_conn_s *conn, FAR const struct sockaddr *addr);
|
2014-07-05 22:40:29 +02:00
|
|
|
|
|
|
|
/****************************************************************************
|
2015-01-17 20:07:48 +01:00
|
|
|
* Name: udp_connect
|
2014-07-05 22:40:29 +02:00
|
|
|
*
|
|
|
|
* Description:
|
2018-04-25 16:43:38 +02:00
|
|
|
* This function simply assigns a remote address to UDP "connection"
|
|
|
|
* structure. This function is called as part of the implementation of:
|
2014-07-05 22:40:29 +02:00
|
|
|
*
|
2018-04-25 16:43:38 +02:00
|
|
|
* - connect(). If connect() is called for a SOCK_DGRAM socket, then
|
|
|
|
* this logic performs the moral equivalent of connect() operation
|
|
|
|
* for the UDP socket.
|
|
|
|
* - recvfrom() and sendto(). This function is called to set the
|
|
|
|
* remote address of the peer.
|
|
|
|
*
|
|
|
|
* The function will automatically allocate an unused local port for the
|
|
|
|
* new connection if the socket is not yet bound to a local address.
|
|
|
|
* However, another port can be chosen by using the udp_bind() call,
|
|
|
|
* after the udp_connect() function has been called.
|
2014-07-05 22:40:29 +02:00
|
|
|
*
|
|
|
|
* Input Parameters:
|
2018-04-25 16:43:38 +02:00
|
|
|
* conn - A reference to UDP connection structure. A value of NULL will
|
|
|
|
* disconnect from any previously connected address.
|
2014-07-05 22:40:29 +02:00
|
|
|
* addr - The address of the remote host.
|
|
|
|
*
|
|
|
|
* Assumptions:
|
2018-04-25 16:43:38 +02:00
|
|
|
* This function is called (indirectly) from user code. Interrupts may
|
|
|
|
* be enabled.
|
2014-07-05 22:40:29 +02:00
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2019-12-31 07:44:44 +01:00
|
|
|
int udp_connect(FAR struct udp_conn_s *conn,
|
|
|
|
FAR const struct sockaddr *addr);
|
2014-07-05 22:40:29 +02:00
|
|
|
|
2020-01-21 07:11:29 +01:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: udp_close
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Break any current UDP connection
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* psock - An instance of the internal socket structure.
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
* Called from normal user-level logic
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
int udp_close(FAR struct socket *psock);
|
|
|
|
|
2015-01-17 14:42:09 +01:00
|
|
|
/****************************************************************************
|
2017-04-22 00:33:14 +02:00
|
|
|
* Name: udp_ipv4_select
|
2015-01-17 14:42:09 +01:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Configure to send or receive an UDP IPv4 packet
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
#ifdef CONFIG_NET_IPv4
|
|
|
|
void udp_ipv4_select(FAR struct net_driver_s *dev);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/****************************************************************************
|
2017-04-22 00:33:14 +02:00
|
|
|
* Name: udp_ipv6_select
|
2015-01-17 14:42:09 +01:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Configure to send or receive an UDP IPv6 packet
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
#ifdef CONFIG_NET_IPv6
|
|
|
|
void udp_ipv6_select(FAR struct net_driver_s *dev);
|
|
|
|
#endif
|
|
|
|
|
2014-07-05 22:40:29 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: udp_poll
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Poll a UDP "connection" structure for availability of TX data
|
|
|
|
*
|
2018-03-13 16:52:27 +01:00
|
|
|
* Input Parameters:
|
2014-07-05 22:40:29 +02:00
|
|
|
* dev - The device driver structure to use in the send operation
|
|
|
|
* conn - The UDP "connection" to poll for TX data
|
|
|
|
*
|
2018-02-01 17:00:02 +01:00
|
|
|
* Returned Value:
|
2014-07-05 22:40:29 +02:00
|
|
|
* None
|
|
|
|
*
|
|
|
|
* Assumptions:
|
2015-01-15 22:06:46 +01:00
|
|
|
* Called from network stack logic with the network stack locked
|
2014-07-05 22:40:29 +02:00
|
|
|
*
|
|
|
|
****************************************************************************/
|
2014-06-25 02:55:01 +02:00
|
|
|
|
2014-06-28 00:48:12 +02:00
|
|
|
void udp_poll(FAR struct net_driver_s *dev, FAR struct udp_conn_s *conn);
|
2014-06-25 02:55:01 +02:00
|
|
|
|
2018-09-15 21:22:45 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: psock_udp_cansend
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* psock_udp_cansend() returns a value indicating if a write to the socket
|
|
|
|
* would block. It is still possible that the write may block if another
|
|
|
|
* write occurs first.
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
2022-02-08 16:24:04 +01:00
|
|
|
* conn A reference to UDP connection structure.
|
2018-09-15 21:22:45 +02:00
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* -ENOSYS (Function not implemented, always have to wait to send).
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
* None
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2022-02-08 16:24:04 +01:00
|
|
|
int psock_udp_cansend(FAR struct udp_conn_s *conn);
|
2019-06-02 19:05:31 +02:00
|
|
|
|
2014-07-05 22:40:29 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: udp_send
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Set-up to send a UDP packet
|
|
|
|
*
|
2018-03-13 16:52:27 +01:00
|
|
|
* Input Parameters:
|
2014-07-05 22:40:29 +02:00
|
|
|
* dev - The device driver structure to use in the send operation
|
|
|
|
* conn - The UDP "connection" structure holding port information
|
|
|
|
*
|
2018-02-01 17:00:02 +01:00
|
|
|
* Returned Value:
|
2014-07-05 22:40:29 +02:00
|
|
|
* None
|
|
|
|
*
|
|
|
|
* Assumptions:
|
2015-01-15 22:06:46 +01:00
|
|
|
* Called from network stack logic with the network stack locked
|
2014-07-05 22:40:29 +02:00
|
|
|
*
|
|
|
|
****************************************************************************/
|
2014-06-25 02:55:01 +02:00
|
|
|
|
2014-06-28 00:48:12 +02:00
|
|
|
void udp_send(FAR struct net_driver_s *dev, FAR struct udp_conn_s *conn);
|
2014-06-25 02:55:01 +02:00
|
|
|
|
2018-06-25 20:41:28 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: udp_setsockopt
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* udp_setsockopt() sets the UDP-protocol option specified by the
|
|
|
|
* 'option' argument to the value pointed to by the 'value' argument for
|
|
|
|
* the socket specified by the 'psock' argument.
|
|
|
|
*
|
|
|
|
* See <netinet/udp.h> for the a complete list of values of UDP protocol
|
|
|
|
* options.
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* psock Socket structure of socket to operate on
|
|
|
|
* option identifies the option to set
|
|
|
|
* value Points to the argument value
|
|
|
|
* value_len The length of the argument value
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* Returns zero (OK) on success. On failure, it returns a negated errno
|
|
|
|
* value to indicate the nature of the error. See psock_setcockopt() for
|
|
|
|
* the list of possible error values.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
#ifdef CONFIG_NET_UDPPROTO_OPTIONS
|
|
|
|
int udp_setsockopt(FAR struct socket *psock, int option,
|
|
|
|
FAR const void *value, socklen_t value_len);
|
|
|
|
#endif
|
|
|
|
|
2018-01-23 01:32:02 +01:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: udp_wrbuffer_initialize
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Initialize the list of free write buffers
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
* Called once early initialization.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
#ifdef CONFIG_NET_UDP_WRITE_BUFFERS
|
|
|
|
void udp_wrbuffer_initialize(void);
|
|
|
|
#endif /* CONFIG_NET_UDP_WRITE_BUFFERS */
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: udp_wrbuffer_alloc
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Allocate a UDP write buffer by taking a pre-allocated buffer from
|
|
|
|
* the free list. This function is called from UDP logic when a buffer
|
|
|
|
* of UDP data is about to sent
|
|
|
|
*
|
2018-02-01 17:00:02 +01:00
|
|
|
* Input Parameters:
|
2018-01-23 01:32:02 +01:00
|
|
|
* None
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
* Called from user logic with the network locked.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
#ifdef CONFIG_NET_UDP_WRITE_BUFFERS
|
|
|
|
struct udp_wrbuffer_s;
|
|
|
|
FAR struct udp_wrbuffer_s *udp_wrbuffer_alloc(void);
|
|
|
|
#endif /* CONFIG_NET_UDP_WRITE_BUFFERS */
|
|
|
|
|
2022-06-25 13:53:50 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: udp_wrbuffer_timedalloc
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Allocate a UDP write buffer by taking a pre-allocated buffer from
|
|
|
|
* the free list. This function is called from udp logic when a buffer
|
|
|
|
* of udp data is about to sent
|
|
|
|
* This function is wrapped version of udp_wrbuffer_alloc(),
|
|
|
|
* this wait will be terminated when the specified timeout expires.
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* timeout - The relative time to wait until a timeout is declared.
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
* Called from user logic with the network locked.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
#ifdef CONFIG_NET_UDP_WRITE_BUFFERS
|
|
|
|
FAR struct udp_wrbuffer_s *udp_wrbuffer_timedalloc(unsigned int timeout);
|
|
|
|
#endif /* CONFIG_NET_UDP_WRITE_BUFFERS */
|
|
|
|
|
2019-12-31 16:52:40 +01:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: udp_wrbuffer_tryalloc
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Try to allocate a UDP write buffer by taking a pre-allocated buffer from
|
|
|
|
* the free list. This function is called from UDP logic when a buffer
|
|
|
|
* of UDP data is about to be sent if the socket is non-blocking. Returns
|
|
|
|
* immediately if allocation fails.
|
|
|
|
*
|
|
|
|
* Input parameters:
|
|
|
|
* None
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
* Called from user logic with the network locked.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
#ifdef CONFIG_NET_UDP_WRITE_BUFFERS
|
|
|
|
FAR struct udp_wrbuffer_s *udp_wrbuffer_tryalloc(void);
|
|
|
|
#endif /* CONFIG_NET_UDP_WRITE_BUFFERS */
|
|
|
|
|
2018-01-23 01:32:02 +01:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: udp_wrbuffer_release
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Release a UDP write buffer by returning the buffer to the free list.
|
|
|
|
* This function is called from user logic after it is consumed the
|
|
|
|
* buffered data.
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
* Called from network stack logic with the network stack locked
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
#ifdef CONFIG_NET_UDP_WRITE_BUFFERS
|
|
|
|
void udp_wrbuffer_release(FAR struct udp_wrbuffer_s *wrb);
|
|
|
|
#endif /* CONFIG_NET_UDP_WRITE_BUFFERS */
|
|
|
|
|
2022-03-31 05:40:08 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: udp_wrbuffer_inqueue_size
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Get the in-queued write buffer size from connection
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* conn - The UDP connection of interest
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
* Called from user logic with the network locked.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
#if CONFIG_NET_SEND_BUFSIZE > 0
|
|
|
|
uint32_t udp_wrbuffer_inqueue_size(FAR struct udp_conn_s *conn);
|
|
|
|
#endif /* CONFIG_NET_SEND_BUFSIZE */
|
|
|
|
|
2018-01-23 01:32:02 +01:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: udp_wrbuffer_test
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Check if there is room in the write buffer. Does not reserve any space.
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
* None.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
#ifdef CONFIG_NET_UDP_WRITE_BUFFERS
|
|
|
|
int udp_wrbuffer_test(void);
|
|
|
|
#endif /* CONFIG_NET_UDP_WRITE_BUFFERS */
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: udp_wrbuffer_dump
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Dump the contents of a write buffer.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
#ifdef CONFIG_NET_UDP_WRITE_BUFFERS
|
|
|
|
#ifdef CONFIG_DEBUG_FEATURES
|
|
|
|
void udp_wrbuffer_dump(FAR const char *msg, FAR struct udp_wrbuffer_s *wrb,
|
|
|
|
unsigned int len, unsigned int offset);
|
|
|
|
#else
|
|
|
|
# define udp_wrbuffer_dump(msg,wrb)
|
|
|
|
#endif
|
|
|
|
#endif /* CONFIG_NET_UDP_WRITE_BUFFERS */
|
|
|
|
|
2014-07-05 22:40:29 +02:00
|
|
|
/****************************************************************************
|
2015-01-15 22:06:46 +01:00
|
|
|
* Name: udp_ipv4_input
|
2014-07-05 22:40:29 +02:00
|
|
|
*
|
|
|
|
* Description:
|
2015-01-15 22:06:46 +01:00
|
|
|
* Handle incoming UDP input in an IPv4 packet
|
2014-07-05 22:40:29 +02:00
|
|
|
*
|
2018-03-13 16:52:27 +01:00
|
|
|
* Input Parameters:
|
2014-07-05 22:40:29 +02:00
|
|
|
* dev - The device driver structure containing the received UDP packet
|
|
|
|
*
|
2018-02-01 17:00:02 +01:00
|
|
|
* Returned Value:
|
2014-07-05 22:40:29 +02:00
|
|
|
* OK The packet has been processed and can be deleted
|
|
|
|
* ERROR Hold the packet and try again later. There is a listening socket
|
|
|
|
* but no receive in place to catch the packet yet.
|
|
|
|
*
|
|
|
|
* Assumptions:
|
2015-01-15 22:06:46 +01:00
|
|
|
* Called from network stack logic with the network stack locked
|
2014-07-05 22:40:29 +02:00
|
|
|
*
|
|
|
|
****************************************************************************/
|
2014-06-25 02:55:01 +02:00
|
|
|
|
2015-01-15 22:06:46 +01:00
|
|
|
#ifdef CONFIG_NET_IPv4
|
|
|
|
int udp_ipv4_input(FAR struct net_driver_s *dev);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: udp_ipv6_input
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Handle incoming UDP input in an IPv6 packet
|
|
|
|
*
|
2018-03-13 16:52:27 +01:00
|
|
|
* Input Parameters:
|
2018-11-03 00:50:01 +01:00
|
|
|
* dev - The device driver structure containing the received UDP packet
|
|
|
|
* iplen - The size of the IPv6 header. This may be larger than
|
|
|
|
* IPv6_HDRLEN the IPv6 header if IPv6 extension headers are
|
|
|
|
* present.
|
2015-01-15 22:06:46 +01:00
|
|
|
*
|
2018-02-01 17:00:02 +01:00
|
|
|
* Returned Value:
|
2015-01-15 22:06:46 +01:00
|
|
|
* OK The packet has been processed and can be deleted
|
|
|
|
* ERROR Hold the packet and try again later. There is a listening socket
|
|
|
|
* but no receive in place to catch the packet yet.
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
* Called from network stack logic with the network stack locked
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
#ifdef CONFIG_NET_IPv6
|
2018-11-03 00:50:01 +01:00
|
|
|
int udp_ipv6_input(FAR struct net_driver_s *dev, unsigned int iplen);
|
2015-01-15 22:06:46 +01:00
|
|
|
#endif
|
2014-06-25 02:55:01 +02:00
|
|
|
|
2015-05-29 18:45:41 +02:00
|
|
|
/****************************************************************************
|
2017-04-22 00:33:14 +02:00
|
|
|
* Name: udp_find_laddr_device
|
2015-05-29 18:45:41 +02:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Select the network driver to use with the UDP transaction using the
|
|
|
|
* locally bound IP address.
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* conn - UDP connection structure (not currently used).
|
|
|
|
*
|
|
|
|
* Returned Value:
|
2018-07-04 15:35:51 +02:00
|
|
|
* A pointer to the network driver to use. NULL is returned if driver is
|
|
|
|
* not bound to any local device.
|
2015-05-29 18:45:41 +02:00
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
FAR struct net_driver_s *udp_find_laddr_device(FAR struct udp_conn_s *conn);
|
|
|
|
|
|
|
|
/****************************************************************************
|
2017-04-22 00:33:14 +02:00
|
|
|
* Name: udp_find_raddr_device
|
2015-05-29 18:45:41 +02:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Select the network driver to use with the UDP transaction using the
|
|
|
|
* remote IP address.
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* conn - UDP connection structure (not currently used).
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* A pointer to the network driver to use.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2021-12-17 07:35:51 +01:00
|
|
|
FAR struct net_driver_s *
|
|
|
|
udp_find_raddr_device(FAR struct udp_conn_s *conn,
|
|
|
|
FAR struct sockaddr_storage *remote);
|
2015-05-29 18:45:41 +02:00
|
|
|
|
2014-07-05 22:40:29 +02:00
|
|
|
/****************************************************************************
|
2017-04-22 00:33:14 +02:00
|
|
|
* Name: udp_callback
|
2014-07-05 22:40:29 +02:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Inform the application holding the UDP socket of a change in state.
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* OK if packet has been processed, otherwise ERROR.
|
|
|
|
*
|
|
|
|
* Assumptions:
|
2015-01-15 22:06:46 +01:00
|
|
|
* Called from network stack logic with the network stack locked
|
2014-07-05 22:40:29 +02:00
|
|
|
*
|
|
|
|
****************************************************************************/
|
2014-06-25 02:55:01 +02:00
|
|
|
|
2014-06-28 00:48:12 +02:00
|
|
|
uint16_t udp_callback(FAR struct net_driver_s *dev,
|
2014-06-25 02:55:01 +02:00
|
|
|
FAR struct udp_conn_s *conn, uint16_t flags);
|
|
|
|
|
2020-01-21 08:50:39 +01:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: psock_udp_recvfrom
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Perform the recvfrom operation for a UDP SOCK_DGRAM
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
2020-02-19 19:21:28 +01:00
|
|
|
* psock Pointer to the socket structure for the SOCK_DRAM socket
|
2022-08-24 08:55:56 +02:00
|
|
|
* msg Receive info and buffer for receive data
|
2020-02-19 19:21:28 +01:00
|
|
|
* flags Receive flags
|
2020-01-21 08:50:39 +01:00
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* On success, returns the number of characters received. On error,
|
|
|
|
* -errno is returned (see recvfrom for list of errnos).
|
|
|
|
*
|
|
|
|
* Assumptions:
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2022-08-24 08:55:56 +02:00
|
|
|
ssize_t psock_udp_recvfrom(FAR struct socket *psock, FAR struct msghdr *msg,
|
|
|
|
int flags);
|
2020-01-21 08:50:39 +01:00
|
|
|
|
2015-01-28 20:41:24 +01:00
|
|
|
/****************************************************************************
|
2017-04-22 00:33:14 +02:00
|
|
|
* Name: psock_udp_sendto
|
2015-01-28 20:41:24 +01:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2019-12-31 07:44:44 +01:00
|
|
|
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);
|
2015-01-28 20:41:24 +01:00
|
|
|
|
2015-01-30 14:09:25 +01:00
|
|
|
/****************************************************************************
|
2017-04-22 00:33:14 +02:00
|
|
|
* Name: udp_pollsetup
|
2015-01-30 14:09:25 +01:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Setup to monitor events on one UDP/IP socket
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* psock - The UDP/IP socket of interest
|
|
|
|
* fds - The structure describing the events to be monitored, OR NULL if
|
|
|
|
* this is a request to stop monitoring events.
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* 0: Success; Negated errno on failure
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
int udp_pollsetup(FAR struct socket *psock, FAR struct pollfd *fds);
|
|
|
|
|
|
|
|
/****************************************************************************
|
2017-04-22 00:33:14 +02:00
|
|
|
* Name: udp_pollteardown
|
2015-01-30 14:09:25 +01:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Teardown monitoring of events on an UDP/IP socket
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
2018-01-23 01:32:02 +01:00
|
|
|
* psock - The UDP/IP socket of interest
|
2015-01-30 14:09:25 +01:00
|
|
|
* fds - The structure describing the events to be monitored, OR NULL if
|
|
|
|
* this is a request to stop monitoring events.
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* 0: Success; Negated errno on failure
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
int udp_pollteardown(FAR struct socket *psock, FAR struct pollfd *fds);
|
|
|
|
|
2018-09-09 17:21:39 +02:00
|
|
|
/****************************************************************************
|
2019-07-01 20:25:32 +02:00
|
|
|
* Name: udp_readahead_notifier_setup
|
2018-09-09 17:21:39 +02:00
|
|
|
*
|
|
|
|
* Description:
|
2018-09-09 23:01:44 +02:00
|
|
|
* Set up to perform a callback to the worker function when an UDP data
|
|
|
|
* is added to the read-ahead buffer. The worker function will execute
|
2018-09-11 16:49:39 +02:00
|
|
|
* on the low priority worker thread.
|
2018-09-09 19:57:25 +02:00
|
|
|
*
|
2018-09-09 17:21:39 +02:00
|
|
|
* Input Parameters:
|
2018-09-11 16:49:39 +02:00
|
|
|
* worker - The worker function to execute on the low priority work
|
|
|
|
* queue when data is available in the UDP read-ahead buffer.
|
2018-09-09 17:21:39 +02:00
|
|
|
* conn - The UDP connection where read-ahead data is needed.
|
2018-09-09 23:01:44 +02:00
|
|
|
* arg - A user-defined argument that will be available to the worker
|
|
|
|
* function when it runs.
|
2018-09-09 17:21:39 +02:00
|
|
|
*
|
|
|
|
* Returned Value:
|
2018-09-11 16:49:39 +02:00
|
|
|
* > 0 - The notification is in place. The returned value is a key that
|
|
|
|
* may be used later in a call to udp_notifier_teardown().
|
|
|
|
* == 0 - There is already buffered read-ahead data. No notification
|
|
|
|
* will be provided.
|
|
|
|
* < 0 - An unexpected error occurred and no notification will occur.
|
|
|
|
* The returned value is a negated errno value that indicates the
|
2018-09-09 17:21:39 +02:00
|
|
|
* nature of the failure.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2019-12-31 16:26:14 +01:00
|
|
|
#ifdef CONFIG_NET_UDP_NOTIFIER
|
2019-07-01 20:25:32 +02:00
|
|
|
int udp_readahead_notifier_setup(worker_t worker,
|
|
|
|
FAR struct udp_conn_s *conn,
|
|
|
|
FAR void *arg);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: udp_writebuffer_notifier_setup
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Set up to perform a callback to the worker function when an UDP write
|
|
|
|
* buffer is emptied. The worker function will execute on the high
|
|
|
|
* priority worker thread.
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* worker - The worker function to execute on the low priority work
|
|
|
|
* queue when data is available in the UDP read-ahead buffer.
|
|
|
|
* conn - The UDP connection where read-ahead data is needed.
|
|
|
|
* arg - A user-defined argument that will be available to the worker
|
|
|
|
* function when it runs.
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* > 0 - The notification is in place. The returned value is a key that
|
|
|
|
* may be used later in a call to udp_notifier_teardown().
|
|
|
|
* == 0 - There is already buffered read-ahead data. No notification
|
|
|
|
* will be provided.
|
|
|
|
* < 0 - An unexpected error occurred and no notification will occur.
|
|
|
|
* The returned value is a negated errno value that indicates the
|
|
|
|
* nature of the failure.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2019-12-31 16:26:14 +01:00
|
|
|
#ifdef CONFIG_NET_UDP_NOTIFIER
|
2019-07-01 20:25:32 +02:00
|
|
|
int udp_writebuffer_notifier_setup(worker_t worker,
|
|
|
|
FAR struct udp_conn_s *conn,
|
|
|
|
FAR void *arg);
|
2018-09-09 17:21:39 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: udp_notifier_teardown
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Eliminate a UDP read-ahead notification previously setup by
|
2019-12-31 07:44:44 +01:00
|
|
|
* udp_readahead_notifier_setup(). This function should only be called if
|
|
|
|
* the notification should be aborted prior to the notification. The
|
2018-09-11 16:49:39 +02:00
|
|
|
* notification will automatically be torn down after the notification.
|
2018-09-09 17:21:39 +02:00
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* key - The key value returned from a previous call to
|
2019-07-01 20:25:32 +02:00
|
|
|
* udp_readahead_notifier_setup().
|
2018-09-09 17:21:39 +02:00
|
|
|
*
|
|
|
|
* Returned Value:
|
2022-05-13 12:26:42 +02:00
|
|
|
* None.
|
2018-09-09 17:21:39 +02:00
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2019-12-31 16:26:14 +01:00
|
|
|
#ifdef CONFIG_NET_UDP_NOTIFIER
|
2022-05-13 12:26:42 +02:00
|
|
|
void udp_notifier_teardown(int key);
|
2018-09-09 17:21:39 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/****************************************************************************
|
2019-07-01 20:25:32 +02:00
|
|
|
* Name: udp_readahead_signal
|
2018-09-09 17:21:39 +02:00
|
|
|
*
|
|
|
|
* Description:
|
2018-09-11 16:49:39 +02:00
|
|
|
* Read-ahead data has been buffered. Notify all threads waiting for
|
2018-09-09 17:21:39 +02:00
|
|
|
* read-ahead data to become available.
|
|
|
|
*
|
2018-09-09 23:01:44 +02:00
|
|
|
* When read-ahead data becomes available, *all* of the workers waiting
|
|
|
|
* for read-ahead data will be executed. If there are multiple workers
|
|
|
|
* waiting for read-ahead data then only the first to execute will get the
|
2019-12-31 07:44:44 +01:00
|
|
|
* data. Others will need to call udp_readahead_notifier_setup once again.
|
2019-07-01 20:25:32 +02:00
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* conn - The UDP connection where read-ahead data was just buffered.
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* None.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2020-01-11 04:56:03 +01:00
|
|
|
#ifdef CONFIG_NET_UDP_NOTIFIER
|
2019-07-01 20:25:32 +02:00
|
|
|
void udp_readahead_signal(FAR struct udp_conn_s *conn);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: udp_writebuffer_signal
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* All buffer Tx data has been sent. Signal all threads waiting for the
|
|
|
|
* write buffers to become empty.
|
|
|
|
*
|
|
|
|
* When write buffer becomes empty, *all* of the workers waiting
|
|
|
|
* for that event data will be executed. If there are multiple workers
|
|
|
|
* waiting for read-ahead data then only the first to execute will get the
|
2022-11-23 12:39:40 +01:00
|
|
|
* data. Others will need to call udp_writebuffer_notifier_setup() once
|
2019-07-01 20:25:32 +02:00
|
|
|
* again.
|
2018-09-09 19:57:25 +02:00
|
|
|
*
|
2018-09-09 17:21:39 +02:00
|
|
|
* Input Parameters:
|
|
|
|
* conn - The UDP connection where read-ahead data was just buffered.
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* None.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2019-12-31 16:26:14 +01:00
|
|
|
#if defined(CONFIG_NET_UDP_WRITE_BUFFERS) && defined(CONFIG_NET_UDP_NOTIFIER)
|
2019-07-01 20:25:32 +02:00
|
|
|
void udp_writebuffer_signal(FAR struct udp_conn_s *conn);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
* Name: udp_txdrain
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Wait for all write buffers to be sent (or for a timeout to occur).
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* psock - An instance of the internal socket structure.
|
2020-01-04 11:37:46 +01:00
|
|
|
* timeout - The relative time when the timeout will occur
|
2019-07-01 20:25:32 +02:00
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* Zero (OK) is returned on success; a negated errno value is returned
|
|
|
|
* on any failure.
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2019-12-31 16:26:14 +01:00
|
|
|
#if defined(CONFIG_NET_UDP_WRITE_BUFFERS) && defined(CONFIG_NET_UDP_NOTIFIER)
|
2020-01-04 11:37:46 +01:00
|
|
|
int udp_txdrain(FAR struct socket *psock, unsigned int timeout);
|
2019-07-01 20:25:32 +02:00
|
|
|
#else
|
2020-01-04 11:37:46 +01:00
|
|
|
# define udp_txdrain(conn, timeout) (0)
|
2018-09-09 17:21:39 +02:00
|
|
|
#endif
|
|
|
|
|
2021-06-07 12:06:44 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: udp_ioctl
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* This function performs udp specific ioctl() operations.
|
|
|
|
*
|
|
|
|
* Parameters:
|
|
|
|
* conn The TCP connection of interest
|
|
|
|
* cmd The ioctl command
|
|
|
|
* arg The argument of the ioctl cmd
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
2022-08-30 20:18:33 +02:00
|
|
|
int udp_ioctl(FAR struct udp_conn_s *conn, int cmd, unsigned long arg);
|
2021-06-07 12:06:44 +02:00
|
|
|
|
2021-07-19 15:45:46 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* 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);
|
|
|
|
#endif /* CONFIG_NET_SEND_BUFSIZE */
|
|
|
|
|
2022-11-23 12:39:40 +01:00
|
|
|
/****************************************************************************
|
|
|
|
* Name: udpip_hdrsize
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Get the total size of L3 and L4 UDP header
|
|
|
|
*
|
|
|
|
* Input Parameters:
|
|
|
|
* conn The connection structure associated with the socket
|
|
|
|
*
|
|
|
|
* Returned Value:
|
|
|
|
* the total size of L3 and L4 TCP header
|
|
|
|
*
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
uint16_t udpip_hdrsize(FAR struct udp_conn_s *conn);
|
|
|
|
|
2014-06-25 02:12:49 +02:00
|
|
|
#undef EXTERN
|
|
|
|
#ifdef __cplusplus
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2017-03-31 16:58:14 +02:00
|
|
|
#endif /* CONFIG_NET_UDP && !CONFIG_NET_UDP_NO_STACK */
|
2014-06-25 02:12:49 +02:00
|
|
|
#endif /* __NET_UDP_UDP_H */
|