Oopenvela-robotxtensa/esp32s3: Add support for RT-Timer based on Systimer peripheral

================== Network Interfaces

NuttX supports a BSD-compatible socket interface layer. These socket interface can be enabled by settings in the architecture configuration file. Those socket APIs are discussed in the following paragraphs.

:c:func:socket
:c:func:bind
:c:func:connect
:c:func:listen
:c:func:accept
:c:func:send
:c:func:sendto
:c:func:recv
:c:func:recvfrom
:c:func:setsockopt
:c:func:getsockopt

.. c:function:: int socket(int domain, int type, int protocol);

Creates an endpoint for communication and returns a descriptor.

:param domain: (see sys/socket.h) :param type: (see sys/socket.h) :param protocol: (see sys/socket.h)

:return: 0 on success; -1 on error with errno set appropriately:

-  ``EACCES``. Permission to create a socket of the specified type
   and/or protocol is denied.
-  ``EAFNOSUPPORT``. The implementation does not support the specified
   address family.
-  ``EINVAL``. Unknown protocol, or protocol family not available.
-  ``EMFILE``. Process file table overflow.
-  ``ENFILE`` The system limit on the total number of open files has
   been reached.
-  ``ENOBUFS`` or ``ENOMEM``. Insufficient memory is available. The
   socket cannot be created until sufficient resources are freed.
-  ``EPROTONOSUPPORT``. The protocol type or the specified protocol is
   not supported within this domain.

.. c:function:: int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)

Gives the socket sockfd the local address addr. addr is addrlen bytes long. Traditionally, this is called "assigning a name to a socket." When a socket is created with socket(), it exists in a name space (address family) but has no name assigned.

:param sockfd: Socket descriptor from socket. :param addr: Socket local address. :param addrlen: Length of addr.

:return: 0 on success; -1 on error with errno set appropriately: - EACCES The address is protected, and the user is not the superuser. - EADDRINUSE The given address is already in use. - EBADF sockfd is not a valid descriptor. - EINVAL The socket is already bound to an address. - ENOTSOCK sockfd is a descriptor for a file, not a socket.

.. c:function:: int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

connect() connects the socket referred to by the file descriptor sockfd to the address specified by addr. The addrlen argument specifies the size of addr. The format of the address in addr is determined by the address space of the socket sockfd. If the socket sockfd is of type SOCK_DGRAM then addr is the address to which datagrams are sent by default, and the only address from which datagrams are received. If the socket is of type SOCK_STREAM or SOCK_SEQPACKET, this call attempts to make a connection to the socket that is bound to the address specified by addr. Generally, connection-based protocol sockets may successfully connect() only once; connectionless protocol sockets may use connect() multiple times to change their association. Connectionless sockets may dissolve the association by connecting to an address with the sa_family member of sockaddr set to AF_UNSPEC.

Input Parameters:

sockfd: Socket descriptor returned by socket()
addr: Server address (form depends on type of socket)
addrlen: Length of actual addr

Returned Value: 0 on success; -1 on error with ```errno` set appropriately:

EACCES or EPERM: The user tried to connect to a broadcast address without having the socket broadcast flag enabled or the connection request failed because of a local firewall rule.

EADDRINUSE Local address is already in use.

EAFNOSUPPORT The passed address didn't have the correct address family in its sa_family field.

EAGAIN No more free local ports or insufficient entries in the routing cache. For PF_INET.

EALREADY The socket is non-blocking and a previous connection attempt has not yet been completed.

EBADF The file descriptor is not a valid index in the descriptor table.

ECONNREFUSED No one listening on the remote address.

EFAULT The socket structure address is outside the user's address space.

EINPROGRESS The socket is non-blocking and the connection cannot be completed immediately.

EINTR The system call was interrupted by a signal that was caught.

EISCONN The socket is already connected.

ENETUNREACH Network is unreachable.

ENOTSOCK The file descriptor is not associated with a socket.

ETIMEDOUT Timeout while attempting connection. The server may be too busy to accept new connections.

.. c:function:: int listen(int sockfd, int backlog);

To accept connections, a socket is first created with socket(), a willingness to accept incoming connections and a queue limit for incoming connections are specified with listen(), and then the connections are accepted with accept(). The listen() call applies only to sockets of type SOCK_STREAM or SOCK_SEQPACKET.

Input Parameters:

sockfd: Socket descriptor of the bound socket.
backlog: The maximum length the queue of pending connections may grow. If a connection request arrives with the queue full, the client may receive an error with an indication of ECONNREFUSED or, if the underlying protocol supports retransmission, the request may be ignored so that retries succeed.

Returned Value: On success, zero is returned. On error, -1 is returned, and ```errno` is set appropriately.

EADDRINUSE: Another socket is already listening on the same port.
EBADF: The argument sockfd is not a valid descriptor.
ENOTSOCK: The argument sockfd is not a socket.
EOPNOTSUPP: The socket is not of a type that supports the listen operation.

.. c:function:: int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

The accept() function is used with connection-based socket types (SOCK_STREAM, SOCK_SEQPACKET and SOCK_RDM). It extracts the first connection request on the queue of pending connections, creates a new connected socket with most of the same properties as sockfd, and allocates a new socket descriptor for the socket, which is returned. The newly created socket is no longer in the listening state. The original socket sockfd is unaffected by this call. Per file descriptor flags are not inherited across an accept.

The sockfd argument is a socket descriptor that has been created with socket(), bound to a local address with bind(), and is listening for connections after a call to listen().

On return, the addr structure is filled in with the address of the connecting entity. The addrlen argument initially contains the size of the structure pointed to by addr; on return it will contain the actual length of the address returned.

If no pending connections are present on the queue, and the socket is not marked as non-blocking, accept blocks the caller until a connection is present. If the socket is marked non-blocking and no pending connections are present on the queue, accept returns EAGAIN.

Input Parameters:

sockfd: Socket descriptor of the listening socket.
addr: Receives the address of the connecting client.
addrlen: Input: allocated size of addr, Return: returned size of addr.

Returned Value: Returns -1 on error. If it succeeds, it returns a non-negative integer that is a descriptor for the accepted socket.

EAGAIN or EWOULDBLOCK: The socket is marked non-blocking and no connections are present to be accepted.
EBADF: The descriptor is invalid.
ENOTSOCK: The descriptor references a file, not a socket.
EOPNOTSUPP: The referenced socket is not of type SOCK_STREAM.
EINTR: The system call was interrupted by a signal that was caught before a valid connection arrived.
ECONNABORTED: A connection has been aborted.
EINVAL: Socket is not listening for connections.
EMFILE: The per-process limit of open file descriptors has been reached.
ENFILE: The system maximum for file descriptors has been reached.
EFAULT: The addr parameter is not in a writable part of the user address space.
ENOBUFS or ENOMEM: Not enough free memory.
EPROTO: Protocol error.
EPERM: Firewall rules forbid connection.

.. c:function:: ssize_t send(int sockfd, const void *buf, size_t len, int flags);

The send() call may be used only when the socket is in a connected state (so that the intended recipient is known). The only difference between send() and write() is the presence of flags. With zero flags parameter, send() is equivalent to write(). Also, send(s,buf,len,flags) is equivalent to sendto(s,buf,len,flags,NULL,0).

Input Parameters:

sockfd: Socket descriptor of socket
buf: Data to send
len: Length of data to send
flags: Send flags

Returned Value: See ```sendto()`.

.. c:function:: ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
const struct sockaddr *to, socklen_t tolen);

If sendto() is used on a connection-mode (SOCK_STREAM, SOCK_SEQPACKET) socket, the parameters to and tolen are ignored (and the error EISCONN may be returned when they are not NULL and 0), and the error ENOTCONN is returned when the socket was not actually connected.

Input Parameters:

sockfd: Socket descriptor of socket
buf: Data to send
len: Length of data to send
flags: Send flags
to: Address of recipient
tolen: The length of the address structure

Returned Value: On success, returns the number of characters sent. On error, -1 is returned, and ```errno` is set appropriately:

EAGAIN or EWOULDBLOCK. The socket is marked non-blocking and the requested operation would block.
EBADF. An invalid descriptor was specified.
ECONNRESET. Connection reset by peer.
EDESTADDRREQ. The socket is not connection-mode, and no peer address is set.
EFAULT. An invalid user space address was specified for a parameter.
EINTR. A signal occurred before any data was transmitted.
EINVAL. Invalid argument passed.
EISCONN. The connection-mode socket was connected already but a recipient was specified. (Now either this error is returned, or the recipient specification is ignored.)
EMSGSIZE. The socket type requires that message be sent atomically, and the size of the message to be sent made this impossible.
ENOBUFS. The output queue for a network interface was full. This generally indicates that the interface has stopped sending, but may be caused by transient congestion.
ENOMEM. No memory available.
ENOTCONN. The socket is not connected, and no target has been given.
ENOTSOCK. The argument s is not a socket.
EOPNOTSUPP. Some bit in the flags argument is inappropriate for the socket type.
EPIPE. The local end has been shut down on a connection oriented socket. In this case the process will also receive a SIGPIPE unless MSG_NOSIGNAL is set.

.. c:function:: ssize_t recv(int sockfd, void *buf, size_t len, int flags);

The recv() call is identical to ```recvfrom()` with a NULL from parameter.

Input Parameters:

sockfd: Socket descriptor of socket
buf: Buffer to receive data
len: Length of buffer
flags: Receive flags

Returned Value: See ```recvfrom()`.

.. c:function:: ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
struct sockaddr *from, socklen_t *fromlen);

recvfrom() receives messages from a socket, and may be used to receive data on a socket whether or not it is connection-oriented.

If from is not NULL, and the underlying protocol provides the source address, this source address is filled in. The argument fromlen initialized to the size of the buffer associated with from, and modified on return to indicate the actual size of the address stored there.

Input Parameters:

sockfd: Socket descriptor of socket.
buf: Buffer to receive data.
len: Length of buffer.
flags: Receive flags.
from: Address of source.
fromlen: The length of the address structure.

Returned Value: On success, returns the number of characters sent. If no data is available to be received and the peer has performed an orderly shutdown, recv() will return 0. Otherwise, on errors, -1 is returned, and ```errno` is set appropriately:

EAGAIN. The socket is marked non-blocking and the receive operation would block, or a receive timeout had been set and the timeout expired before data was received.
EBADF. The argument sockfd is an invalid descriptor.
ECONNREFUSED. A remote host refused to allow the network connection (typically because it is not running the requested service).
EFAULT. The receive buffer pointer(s) point outside the process's address space.
EINTR. The receive was interrupted by delivery of a signal before any data were available.
EINVAL. Invalid argument passed.
ENOMEM. Could not allocate memory.
ENOTCONN. The socket is associated with a connection-oriented protocol and has not been connected.
ENOTSOCK. The argument sockfd does not refer to a socket.

.. c:function:: int setsockopt(int sockfd, int level, int option,
const void *value, socklen_t value_len);

setsockopt() sets the option specified by the option argument, at the protocol level specified by the level argument, to the value pointed to by the value argument for the socket associated with the file descriptor specified by the sockfd argument.

The level argument specifies the protocol level of the option. To set options at the socket level, specify the level argument as SOL_SOCKET.

See sys/socket.h for a complete list of values for the option argument.

Input Parameters:

sockfd: Socket descriptor of socket
level: Protocol level to set the option
option: identifies the option to set
value: Points to the argument value
value_len: The length of the argument value

Returned Value: On success, returns the number of characters sent. On error, -1 is returned, and ```errno` is set appropriately:

BADF. The sockfd argument is not a valid socket descriptor.
DOM. The send and receive timeout values are too big to fit into the timeout fields in the socket structure.
INVAL. The specified option is invalid at the specified socket level or the socket has been shut down.
ISCONN. The socket is already connected, and a specified option cannot be set while the socket is connected.
NOPROTOOPT. The option is not supported by the protocol.
NOTSOCK. The sockfd argument does not refer to a socket.
NOMEM. There was insufficient memory available for the operation to complete.
NOBUFS. Insufficient resources are available in the system to complete the call.

.. c:function:: int getsockopt(int sockfd, int level, int option, void *value, socklen_t *value_len);

getsockopt() retrieve those value for the option specified by the option argument for the socket specified by the sockfd argument. If the size of the option value is greater than value_len, the value stored in the object pointed to by the value argument will be silently truncated. Otherwise, the length pointed to by the value_len argument will be modified to indicate the actual length of the value.

The level argument specifies the protocol level of the option. To retrieve options at the socket level, specify the level argument as SOL_SOCKET.

See sys/socket.h for a complete list of values for the option argument.

Input Parameters:

sockfd: Socket descriptor of socket
level: Protocol level to set the option
option: Identifies the option to get
value: Points to the argument value
value_len: The length of the argument value

Returned Value: On success, returns the number of characters sent. On error, -1 is returned, and ```errno` is set appropriately:

BADF. The sockfd argument is not a valid socket descriptor.
INVAL. The specified option is invalid at the specified socket level or the socket has been shutdown.
NOPROTOOPT. The option is not supported by the protocol.
NOTSOCK. The sockfd argument does not refer to a socket.
NOBUFS. Insufficient resources are available in the system to complete the call.