/**************************************************************************** * include/nuttx/net/net.h * * Copyright (C) 2007, 2009-2014 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * 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. * ****************************************************************************/ #ifndef __INCLUDE_NUTTX_NET_NET_H #define __INCLUDE_NUTTX_NET_NET_H /**************************************************************************** * Included Files ****************************************************************************/ #include #ifdef CONFIG_NET #include #include #include #include #include /**************************************************************************** * Pre-processor Definitions ****************************************************************************/ /* Socket descriptors are the index into the TCB sockets list, offset by the * following amount. This offset is used to distinguish file descriptors from * socket descriptors */ #ifdef CONFIG_NFILE_DESCRIPTORS # define __SOCKFD_OFFSET CONFIG_NFILE_DESCRIPTORS #else # define __SOCKFD_OFFSET 0 #endif /**************************************************************************** * Public Types ****************************************************************************/ /* Data link layer type */ enum net_lltype_e { NET_LL_ETHERNET = 0, /* Ethernet */ NET_LL_SLIP, /* Serial Line Internet Protocol (SLIP) */ NET_LL_PPP /* Point-to-Point Protocol (PPP) */ }; /* This defines a bitmap big enough for one bit for each socket option */ typedef uint16_t sockopt_t; /* This defines the storage size of a timeout value. This effects only * range of supported timeout values. With an LSB in seciseconds, the * 16-bit maximum of 65535 corresponds to 1 hr 49 min 13.5 sec at decisecond * resolution. */ typedef uint16_t socktimeo_t; /* This is the internal representation of a socket reference by a file * descriptor. */ struct devif_callback_s; /* Forward reference */ struct socket { int16_t s_crefs; /* Reference count on the socket */ uint8_t s_domain; /* Domain: PF_INET, PF_INET6, or PF_PACKET */ uint8_t s_type; /* Protocol type: Only SOCK_STREAM or SOCK_DGRAM */ uint8_t s_flags; /* See _SF_* definitions */ /* Socket options */ #ifdef CONFIG_NET_SOCKOPTS sockopt_t s_options; /* Selected socket options */ socktimeo_t s_rcvtimeo; /* Receive timeout value (in deciseconds) */ socktimeo_t s_sndtimeo; /* Send timeout value (in deciseconds) */ #ifdef CONFIG_NET_SOLINGER socktimeo_t s_linger; /* Linger timeout value (in deciseconds) */ #endif #endif FAR void *s_conn; /* Connection: struct tcp_conn_s or udp_conn_s */ #ifdef CONFIG_NET_TCP_WRITE_BUFFERS /* Callback instance for TCP send */ FAR struct devif_callback_s *s_sndcb; #endif }; /* This defines a list of sockets indexed by the socket descriptor */ #if CONFIG_NSOCKET_DESCRIPTORS > 0 struct socketlist { sem_t sl_sem; /* Manage access to the socket list */ struct socket sl_sockets[CONFIG_NSOCKET_DESCRIPTORS]; }; #endif /* Callback from netdev_foreach() */ struct net_driver_s; /* Forward reference. Defined in nuttx/net/netdev.h */ typedef int (*netdev_callback_t)(FAR struct net_driver_s *dev, void *arg); #ifdef CONFIG_NET_NOINTS /* Semaphore based locking for non-interrupt based logic. * * net_lock_t -- Not used. Only for compatibility */ typedef uint8_t net_lock_t; /* Not really used */ #else /* Enable/disable locking for interrupt based logic: * * net_lock_t -- The processor specific representation of interrupt state. */ # define net_lock_t irqstate_t #endif /**************************************************************************** * Public Data ****************************************************************************/ #ifdef __cplusplus #define EXTERN extern "C" extern "C" { #else #define EXTERN extern #endif /**************************************************************************** * Public Function Prototypes ****************************************************************************/ /**************************************************************************** * Critical section management. The NuttX configuration setting * CONFIG_NET_NOINT indicates that uIP not called from the interrupt level. * If CONFIG_NET_NOINTS is defined, then these will map to semaphore * controls. Otherwise, it assumed that uIP will be called from interrupt * level handling and these will map to interrupt enable/disable controls. * * * If CONFIG_NET_NOINTS is defined, then semaphore based locking is used: * * net_lock() - Takes the semaphore(). Implements a re-entrant mutex. * net_unlock() - Gives the semaphore(). * net_lockedwait() - Like pthread_cond_wait(); releases the semaphore * momentarily to wait on another semaphore() * * Otherwise, interrupt based locking is used: * * net_lock() - Disables interrupts. * net_unlock() - Conditionally restores interrupts. * net_lockedwait() - Just wait for the semaphore. * ****************************************************************************/ /**************************************************************************** * Function: net_lock * * Description: * Take the lock * ****************************************************************************/ #ifdef CONFIG_NET_NOINTS net_lock_t net_lock(void); #else # define net_lock() irqsave() #endif /**************************************************************************** * Function: net_unlock * * Description: * Release the lock. * ****************************************************************************/ #ifdef CONFIG_NET_NOINTS void net_unlock(net_lock_t flags); #else # define net_unlock(f) irqrestore(f) #endif /**************************************************************************** * Function: net_lockedwait * * Description: * Atomically wait for sem while temporarily releasing g_netlock. * ****************************************************************************/ #ifdef CONFIG_NET_NOINTS int net_lockedwait(sem_t *sem); #else # define net_lockedwait(s) sem_wait(s) #endif /**************************************************************************** * Function: net_setipid * * Description: * This function may be used at boot time to set the initial ip_id. * * Assumptions: * ****************************************************************************/ void net_setipid(uint16_t id); /**************************************************************************** * Name: net_checksd * * Description: * Check if the socket descriptor is valid for the provided TCB and if it * supports the requested access. This trivial operation is part of the * fdopen() operation when the fdopen() is performed on a socket descriptor. * It simply performs some sanity checking before permitting the socket * descriptor to be wrapped as a C FILE stream. * ****************************************************************************/ int net_checksd(int fd, int oflags); /**************************************************************************** * Name: net_initialize * * Description: * This is called from the OS initialization logic at power-up reset in * order to configure the networking subsystem. * * Input Parameters: * None * * Returned Value: * None * ****************************************************************************/ void net_initialize(void); /**************************************************************************** * Name: * * Description: * Initialize a list of sockets for a new task * * Input Parameters: * list -- A reference to the pre-alloated socket list to be initialized. * * Returned Value: * None * ****************************************************************************/ void net_initlist(FAR struct socketlist *list); /**************************************************************************** * Name: net_releaselist * * Description: * Release resources held by the socket list * * Input Parameters: * list -- A reference to the pre-allocated socket list to be un-initialized. * * Returned Value: * None * ****************************************************************************/ void net_releaselist(FAR struct socketlist *list); /**************************************************************************** * Name: sockfd_socket * * Description: * Given a socket descriptor, return the underlying socket structure. * * Input Parameters: * sockfd - The socket descriptor index o use. * * Returned Value: * On success, a reference to the socket structure associated with the * the socket descriptor is returned. NULL is returned on any failure. * ****************************************************************************/ FAR struct socket *sockfd_socket(int sockfd); /**************************************************************************** * Function: psock_socket * * Description: * socket() creates an endpoint for communication and returns a socket * structure. * * Parameters: * domain (see sys/socket.h) * type (see sys/socket.h) * protocol (see sys/socket.h) * psock A pointer to a user allocated socket structure to be initialized. * * Returned Value: * 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. * * Assumptions: * ****************************************************************************/ int psock_socket(int domain, int type, int protocol, FAR struct socket *psock); /**************************************************************************** * Function: net_close * * Description: * Performs the close operation on socket descriptors * * Parameters: * sockfd Socket descriptor of socket * * Returned Value: * 0 on success; -1 on error with errno set appropriately. * * Assumptions: * ****************************************************************************/ int net_close(int sockfd); /**************************************************************************** * Function: psock_close * * Description: * Performs the close operation on a socket instance * * Parameters: * psock Socket instance * * Returned Value: * 0 on success; -1 on error with errno set appropriately. * * Assumptions: * ****************************************************************************/ int psock_close(FAR struct socket *psock); /**************************************************************************** * Function: psock_bind * * Description: * bind() gives the socket 'psock' 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. * * Parameters: * psock Socket structure of the socket to bind * addr Socket local address * addrlen Length of 'addr' * * Returned Value: * 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. * EINVAL * The socket is already bound to an address. * ENOTSOCK * psock is a descriptor for a file, not a socket. * * Assumptions: * ****************************************************************************/ struct sockaddr; /* Forward reference. Defined in nuttx/include/sys/socket.h */ int psock_bind(FAR struct socket *psock, FAR const struct sockaddr *addr, socklen_t addrlen); /**************************************************************************** * Name: psock_connect * * Description: * connect() connects the socket referred to by the structure 'psock' * 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 'psock'. * * If the socket 'psock' 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. * * Parameters: * psock Pointer to a socket structure initialized by psock_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, 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. * 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. * * Assumptions: * ****************************************************************************/ int psock_connect(FAR struct socket *psock, FAR const struct sockaddr *addr, socklen_t addrlen); /**************************************************************************** * Function: psock_send * * Description: * 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(sockfd,buf,len,flags) is * equivalent to sendto(sockfd,buf,len,flags,NULL,0). * * Parameters: * psock An instance of the internal socket structure. * buf Data to send * len Length of data to send * flags Send flags * * 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. * * Assumptions: * ****************************************************************************/ ssize_t psock_send(FAR struct socket *psock, const void *buf, size_t len, int flags); /**************************************************************************** * Function: psock_sendto * * Description: * 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. * * 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 * * 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. * * Assumptions: * ****************************************************************************/ ssize_t psock_sendto(FAR struct socket *psock, FAR const void *buf, size_t len, int flags, FAR const struct sockaddr *to, socklen_t tolen); /**************************************************************************** * Function: psock_recvfrom * * Description: * 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. * * Parameters: * psock A pointer to a NuttX-specific, internal socket structure * buf Buffer to receive data * len Length of buffer * flags Receive flags * from Address of source (may be NULL) * 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. * * Assumptions: * ****************************************************************************/ ssize_t psock_recvfrom(FAR struct socket *psock, FAR void *buf, size_t len, int flags, FAR struct sockaddr *from, FAR socklen_t *fromlen); /* recv using the underlying socket structure */ #define psock_recv(psock,buf,len,flags) \ psock_recvfrom(psock,buf,len,flags,NULL,0) /**************************************************************************** * Function: psock_getsockopt * * Description: * getsockopt() retrieve thse value for the option specified by the * 'option' argument for the socket specified by the 'psock' 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 a complete list of values for the 'option' argument. * * Parameters: * psock Socket structure of the socket to query * 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: * * EINVAL * The specified option is invalid at the specified socket 'level' or the * socket has been shutdown. * ENOPROTOOPT * The 'option' is not supported by the protocol. * ENOTSOCK * The 'psock' argument does not refer to a socket. * ENOBUFS * Insufficient resources are available in the system to complete the * call. * * Assumptions: * ****************************************************************************/ int psock_getsockopt(FAR struct socket *psock, int level, int option, FAR void *value, FAR socklen_t *value_len); /**************************************************************************** * Function: psock_setsockopt * * Description: * psock_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 on the 'psock' 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 a complete list of values for the 'option' argument. * * Parameters: * psock Socket structure of socket to operate on * 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: * 0 on success; -1 on failure * * EDOM * The send and receive timeout values are too big to fit into the * timeout fields in the socket structure. * EINVAL * The specified option is invalid at the specified socket 'level' or the * socket has been shut down. * EISCONN * The socket is already connected, and a specified option cannot be set * while the socket is connected. * ENOPROTOOPT * The 'option' is not supported by the protocol. * ENOTSOCK * The 'sockfd' argument does not refer to a socket. * ENOMEM * There was insufficient memory available for the operation to complete. * ENOBUFS * Insufficient resources are available in the system to complete the * call. * * Assumptions: * ****************************************************************************/ int psock_setsockopt(FAR struct socket *psock, int level, int option, FAR const void *value, socklen_t value_len); /**************************************************************************** * Name: netdev_ioctl * * Description: * Perform network device specific operations. * * Parameters: * sockfd Socket descriptor of device * cmd The ioctl command * arg The argument of the ioctl cmd * * Return: * >=0 on success (positive non-zero values are cmd-specific) * On a failure, -1 is returned with errno set appropriately * * EBADF * 'sockfd' is not a valid descriptor. * EFAULT * 'arg' references an inaccessible memory area. * ENOTTY * 'cmd' not valid. * EINVAL * 'arg' is not valid. * ENOTTY * 'sockfd' is not associated with a network device. * ENOTTY * The specified request does not apply to the kind of object that the * descriptor 'sockfd' references. * ****************************************************************************/ int netdev_ioctl(int sockfd, int cmd, unsigned long arg); /**************************************************************************** * Function: psock_poll * * Description: * The standard poll() operation redirects operations on socket descriptors * to this function. * * Input Parameters: * psock - An instance of the internal socket structure. * fds - The structure describing the events to be monitored, OR NULL if * this is a request to stop monitoring events. * setup - true: Setup up the poll; false: Teardown the poll * * Returned Value: * 0: Success; Negated errno on failure * ****************************************************************************/ #ifndef CONFIG_DISABLE_POLL struct pollfd; /* Forward reference -- see poll.h */ int psock_poll(FAR struct socket *psock, struct pollfd *fds, bool setup); #endif /**************************************************************************** * Function: net_poll * * Description: * The standard poll() operation redirects operations on socket descriptors * to this function. * * Input Parameters: * fd - The socket descriptor of interest * fds - The structure describing the events to be monitored, OR NULL if * this is a request to stop monitoring events. * setup - true: Setup up the poll; false: Teardown the poll * * Returned Value: * 0: Success; Negated errno on failure * ****************************************************************************/ #ifndef CONFIG_DISABLE_POLL struct pollfd; /* Forward reference -- see poll.h */ int net_poll(int sockfd, struct pollfd *fds, bool setup); #endif /**************************************************************************** * Function: net_dupsd * * Description: * Clone a socket descriptor to an arbitray descriptor number. If file * descriptors are implemented, then this is called by dup() for the case * of socket file descriptors. If file descriptors are not implemented, * then this function IS dup(). * ****************************************************************************/ int net_dupsd(int sockfd, int minsd); /**************************************************************************** * Function: net_dupsd2 * * Description: * Clone a socket descriptor to an arbitray descriptor number. If file * descriptors are implemented, then this is called by dup2() for the case * of socket file descriptors. If file descriptors are not implemented, * then this function IS dup2(). * ****************************************************************************/ int net_dupsd2(int sockfd1, int sockfd2); /**************************************************************************** * Function: net_clone * * Description: * Performs the low level, common portion of net_dupsd() and net_dupsd2() * ****************************************************************************/ int net_clone(FAR struct socket *psock1, FAR struct socket *psock2); /**************************************************************************** * Function: net_sendfile * * Description: * 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(sockfd,buf,len,flags) is * equivalent to sendto(sockfd,buf,len,flags,NULL,0). * * Parameters: * psock An instance of the internal socket structure. * buf Data to send * len Length of data to send * flags Send flags * * 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. * * Assumptions: * ****************************************************************************/ #ifdef CONFIG_NET_SENDFILE struct file; ssize_t net_sendfile(int outfd, struct file *infile, off_t *offset, size_t count); #endif /**************************************************************************** * Name: net_vfcntl * * Description: * Performs fcntl operations on socket * * Input Parameters: * sockfd - Socket descriptor of the socket to operate on * cmd - The fcntl command. * ap - Command-specific arguments * * Returned Value: * Zero (OK) is returned on success; -1 (ERROR) is returned on failure and * the errno value is set appropriately. * ****************************************************************************/ int net_vfcntl(int sockfd, int cmd, va_list ap); /**************************************************************************** * Function: netdev_register * * Description: * Register a network device driver and assign a name to it so that it can * be found in subsequent network ioctl operations on the device. * * Parameters: * dev - The device driver structure to be registered. * lltype - Link level protocol used by the driver (Ethernet, SLIP, PPP, ... * * Returned Value: * 0:Success; negated errno on failure * * Assumptions: * Called during system initialization from normal user mode * ****************************************************************************/ int netdev_register(FAR struct net_driver_s *dev, enum net_lltype_e lltype); /**************************************************************************** * Function: netdev_unregister * * Description: * Unregister a network device driver. * * Parameters: * dev - The device driver structure to un-register * * Returned Value: * 0:Success; negated errno on failure * * Assumptions: * Currently only called for USB networking devices when the device is * physically removed from the slot * ****************************************************************************/ int netdev_unregister(FAR struct net_driver_s *dev); /**************************************************************************** * Function: netdev_foreach * * Description: * Enumerate each registered network device. * * NOTE: netdev semaphore held throughout enumeration. * * Parameters: * callback - Will be called for each registered device * arg - User argument passed to callback() * * Returned Value: * 0:Enumeration completed 1:Enumeration terminated early by callback * * Assumptions: * Called from normal user mode * ****************************************************************************/ int netdev_foreach(netdev_callback_t callback, void *arg); #undef EXTERN #ifdef __cplusplus } #endif #endif /* CONFIG_NET */ #endif /* __INCLUDE_NUTTX_NET_NET_H */