/**************************************************************************** * net/recvfrom.c * * Copyright (C) 2007 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. * ****************************************************************************/ /**************************************************************************** * Included Files ****************************************************************************/ #include #ifdef CONFIG_NET #include #include #include #include #include #include #include #include #include "net-internal.h" /**************************************************************************** * Definitions ****************************************************************************/ #define TCP_TIMEO 10 /* Deciseconds after data received before recv() returns */ /**************************************************************************** * Private Types ****************************************************************************/ struct recvfrom_s { #if defined(CONFIG_NET_SOCKOPTS) && !defined(CONFIG_DISABLE_CLOCK) FAR struct socket *rf_sock; /* The parent socket structure */ uint32 rf_starttime; /* rcv start time for determining timeout */ #endif sem_t rf_sem; /* Semaphore signals recv completion */ size_t rf_buflen; /* Length of receive buffer */ char *rf_buffer; /* Pointer to receive buffer */ size_t rf_recvlen; /* The received length */ int rf_result; /* OK on success, otherwise a negated errno. */ }; /**************************************************************************** * Private Functions ****************************************************************************/ /**************************************************************************** * Function: recvfrom_interrupt * * Description: * This function is called from the interrupt level to perform the actual * receive operation via by the uIP layer. * * Parameters: * dev The sructure of the network driver that caused the interrupt * private An instance of struct recvfrom_s cast to void* * * Returned Value: * None * * Assumptions: * Running at the interrupt level * ****************************************************************************/ static void recvfrom_interrupt(struct uip_driver_s *dev, void *private) { struct recvfrom_s *pstate = (struct recvfrom_s *)private; #if defined(CONFIG_NET_SOCKOPTS) && !defined(CONFIG_DISABLE_CLOCK) FAR struct socket *psock; #endif size_t recvlen; vdbg("uip_flags: %02x\n", uip_flags); /* 'private' might be null in some race conditions (?) */ if (pstate) { #if defined(CONFIG_NET_SOCKOPTS) && !defined(CONFIG_DISABLE_CLOCK) /* Get the socket reference from the private data */ psock = pstate->rf_sock; #endif /* If new data is available, then complete the read action. */ if (uip_newdata_event()) { /* Get the length of the data to return */ if (dev->d_len > pstate->rf_buflen) { recvlen = pstate->rf_buflen; } else { recvlen = dev->d_len; } /* Copy the new appdata into the user buffer */ memcpy(pstate->rf_buffer, dev->d_appdata, recvlen); vdbg("Received %d bytes (of %d)\n", recvlen, dev->d_len); /* Update the accumulated size of the data read */ pstate->rf_recvlen += recvlen; pstate->rf_buffer += recvlen; pstate->rf_buflen -= recvlen; /* Are we finished? If this is a UDP socket or if the user * buffer has been filled, then we are finished. */ #ifdef CONFIG_NET_UDP if (psock->s_type == SOCK_DGRAM) { struct uip_udp_conn *udp_conn; vdbg("UDP resume\n"); /* Don't allow any further UDP call backs. */ udp_conn = (struct uip_udp_conn *)psock->s_conn; udp_conn->private = NULL; udp_conn->event = NULL; /* Wake up the waiting thread, returning the number of bytes * actually read. */ sem_post(&pstate->rf_sem); } else #endif if (pstate->rf_buflen == 0) { struct uip_conn *conn; vdbg("TCP resume\n"); /* The TCP receive buffer is full. Return now, perhaps truncating * the received data (need to fix that). * * Don't allow any further TCP call backs. */ conn = (struct uip_conn *)psock->s_conn; conn->data_private = NULL; conn->data_event = NULL; /* Wake up the waiting thread, returning the number of bytes * actually read. */ sem_post(&pstate->rf_sem); } /* Reset the timeout. We will want a short timeout to terminate * the TCP receive. */ #if defined(CONFIG_NET_SOCKOPTS) && !defined(CONFIG_DISABLE_CLOCK) pstate->rf_starttime = g_system_timer; #endif } /* Check for a loss of connection */ else if ((uip_flags & (UIP_CLOSE|UIP_ABORT|UIP_TIMEDOUT)) != 0) { vdbg("error\n"); /* Stop further callbacks */ #ifdef CONFIG_NET_UDP if (psock->s_type == SOCK_DGRAM) { struct uip_udp_conn *udp_conn = (struct uip_udp_conn *)psock->s_conn; udp_conn->private = NULL; udp_conn->event = NULL; } else #endif { struct uip_conn *conn = (struct uip_conn *)psock->s_conn; conn->data_private = NULL; conn->data_event = NULL; } /* Report not connected */ pstate->rf_result = -ENOTCONN; /* Wake up the waiting thread */ sem_post(&pstate->rf_sem); } /* No data has been received -- this is some other event... probably a * poll -- check for a timeout. */ #if defined(CONFIG_NET_SOCKOPTS) && !defined(CONFIG_DISABLE_CLOCK) else { socktimeo_t timeo; /* If this is a TCP socket that has already received some data, * than we will always use a short timeout. */ if (pstate->rf_recvlen > 0) { /* Use the short timeout */ timeo = TCP_TIMEO; } /* No.. check for a timeout configured via setsockopts(SO_RCVTIMEO). * If none... we well let the read hang forever. */ else { timeo = psock->s_rcvtimeo; } /* Is there an effective timeout? */ if (timeo) { /* Yes.. Check if the timeout has elapsed */ if (net_timeo(pstate->rf_starttime, timeo)) { /* Yes.. the timeout has elapsed... do not allow any further * callbacks */ #ifdef CONFIG_NET_UDP if (psock->s_type == SOCK_DGRAM) { struct uip_udp_conn *udp_conn; vdbg("UDP timeout\n"); /* Stop further callbacks */ udp_conn = (struct uip_udp_conn *)psock->s_conn; udp_conn->private = NULL; udp_conn->event = NULL; /* Report a timeout error */ pstate->rf_result = -EAGAIN; } else #endif { struct uip_conn *conn; vdbg("TCP timeout\n"); conn = (struct uip_conn *)psock->s_conn; conn->data_private = NULL; conn->data_event = NULL; /* Report an error only if no data has been received */ if (pstate->rf_recvlen == 0) { /* Report the timeout error */ pstate->rf_result = -EAGAIN; } } /* Wake up the waiting thread, returning either the error -EAGAIN * that signals the timeout event or the data received up to * the point tht the timeout occured (no error). */ sem_post(&pstate->rf_sem); } } } #endif } } /**************************************************************************** * Function: recvfrom_init * * Description: * Initialize the state structure * * Parameters: * psock Pointer to the socket structure for the socket * buf Buffer to receive data * len Length of buffer * pstate A pointer to the state structure to be initialized * * Returned Value: * None * * Assumptions: * ****************************************************************************/ static void recvfrom_init(FAR struct socket *psock, FAR void *buf, size_t len, struct recvfrom_s *pstate) { /* Initialize the state structure. */ memset(pstate, 0, sizeof(struct recvfrom_s)); (void)sem_init(&pstate->rf_sem, 0, 0); /* Doesn't really fail */ pstate->rf_buflen = len; pstate->rf_buffer = buf; #if defined(CONFIG_NET_SOCKOPTS) && !defined(CONFIG_DISABLE_CLOCK) /* Set up the start time for the timeout */ pstate->rf_sock = psock; pstate->rf_starttime = g_system_timer; #endif } /**************************************************************************** * Function: recvfrom_result * * Description: * Evaluate the result of the recv operations * * Parameters: * result The result of the sem_wait operation (may indicate EINTR) * pstate A pointer to the state structure to be initialized * * Returned Value: * The result of the recv operation with errno set appropriately * * Assumptions: * ****************************************************************************/ static ssize_t recvfrom_result(int result, struct recvfrom_s *pstate) { int save_errno = *get_errno_ptr(); /* In case something we do changes it */ /* Release semaphore in the state structure */ sem_destroy(&pstate->rf_sem); /* Check for a error/timeout detected by the interrupt handler. Errors are * signaled by negative errno values for the rcv length */ if (pstate->rf_result < 0) { /* Return EGAIN on a timeout or ENOTCONN on loss of connection */ return pstate->rf_result; } /* If sem_wait failed, then we were probably reawakened by a signal. In * this case, sem_wait will have set errno appropriately. */ if (result < 0) { return -save_errno; } return pstate->rf_recvlen; } /**************************************************************************** * Function: udp_recvfrom * * Description: * Perform the recvfrom operation for a UDP SOCK_DGRAM * * Parameters: * psock Pointer to the socket structure for the SOCK_DRAM socket * buf Buffer to receive data * len Length of buffer * infrom INET ddress of source (may be NULL) * * Returned Value: * On success, returns the number of characters sent. On error, * -errno is returned (see recvfrom for list of errnos). * * Assumptions: * ****************************************************************************/ #ifdef CONFIG_NET_UDP #ifdef CONFIG_NET_IPv6 static ssize_t udp_recvfrom(FAR struct socket *psock, FAR void *buf, size_t len, FAR const struct sockaddr_in6 *infrom ) #else static ssize_t udp_recvfrom(FAR struct socket *psock, FAR void *buf, size_t len, FAR const struct sockaddr_in *infrom ) #endif { struct uip_udp_conn *udp_conn; struct recvfrom_s state; irqstate_t save; int ret; /* Perform the UDP recvfrom() operation */ /* Initialize the state structure. This is done with interrupts * disabled because we don't want anything to happen until we * are ready. */ save = irqsave(); recvfrom_init(psock, buf, len, &state); /* Setup the UDP socket */ ret = uip_udpconnect(psock->s_conn, NULL); if (ret < 0) { irqrestore(save); return ret; } /* Set up the callback in the connection */ udp_conn = (struct uip_udp_conn *)psock->s_conn; udp_conn->private = (void*)&state; udp_conn->event = recvfrom_interrupt; /* Enable the UDP socket */ uip_udpenable(psock->s_conn); /* Wait for either the receive to complete or for an error/timeout to occur. * NOTES: (1) sem_wait will also terminate if a signal is received, (2) * interrupts are disabled! They will be re-enabled while the task sleeps * and automatically re-enabled when the task restarts. */ ret = sem_wait(&state. rf_sem); /* Make sure that no further interrupts are processed */ uip_udpdisable(psock->s_conn); udp_conn->private = NULL; udp_conn->event = NULL; irqrestore(save); #warning "Needs to return server address" return recvfrom_result(ret, &state); } #endif /* CONFIG_NET_UDP */ /**************************************************************************** * Function: tcp_recvfrom * * Description: * Perform the recvfrom operation for a TCP/IP SOCK_STREAM * * Parameters: * psock Pointer to the socket structure for the SOCK_DRAM socket * buf Buffer to receive data * len Length of buffer * infrom INET ddress of source (may be NULL) * * Returned Value: * On success, returns the number of characters sent. On error, * -errno is returned (see recvfrom for list of errnos). * * Assumptions: * ****************************************************************************/ #ifdef CONFIG_NET_IPv6 static ssize_t tcp_recvfrom(FAR struct socket *psock, FAR void *buf, size_t len, FAR const struct sockaddr_in6 *infrom ) #else static ssize_t tcp_recvfrom(FAR struct socket *psock, FAR void *buf, size_t len, FAR const struct sockaddr_in *infrom ) #endif { struct uip_conn *conn; struct recvfrom_s state; irqstate_t save; int ret; /* Verify that the SOCK_STREAM has been connected */ if (!_SS_ISCONNECTED(psock->s_flags)) { /* The SOCK_STREAM must be connected in order to receive */ return -ENOTCONN; } /* Initialize the state structure. This is done with interrupts * disabled because we don't want anything to happen until we * are ready. */ save = irqsave(); recvfrom_init(psock, buf, len, &state); /* Set up the callback in the connection */ conn = (struct uip_conn *)psock->s_conn; conn->data_private = (void*)&state; conn->data_event = recvfrom_interrupt; /* Wait for either the receive to complete or for an error/timeout to occur. * NOTES: (1) sem_wait will also terminate if a signal is received, (2) * interrupts are disabled! They will be re-enabled while the task sleeps * and automatically re-enabled when the task restarts. */ ret = sem_wait(&state.rf_sem); /* Make sure that no further interrupts are processed */ conn->data_private = NULL; conn->data_event = NULL; irqrestore(save); #warning "Needs to return server address" return recvfrom_result(ret, &state); } /**************************************************************************** * Global Functions ****************************************************************************/ /**************************************************************************** * Function: 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: * sockfd Socket descriptor of socket * 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. On error, * -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 recvfrom(int sockfd, FAR void *buf, size_t len, int flags, FAR struct sockaddr *from, FAR socklen_t *fromlen) { FAR struct socket *psock; #ifdef CONFIG_NET_IPv6 FAR const struct sockaddr_in6 *infrom = (const struct sockaddr_in6 *)from; #else FAR const struct sockaddr_in *infrom = (const struct sockaddr_in *)from; #endif ssize_t ret; int err; /* Verify that non-NULL pointers were passed */ if (!buf) { err = EINVAL; goto errout; } /* Get the underlying socket structure */ /* Verify that the sockfd corresponds to valid, allocated socket */ psock = sockfd_socket(sockfd); if (!psock || psock->s_crefs <= 0) { err = EBADF; goto errout; } /* If a 'from' address has been provided, verify that it is valid */ if (from) { #ifdef CONFIG_NET_IPv6 if (from->sa_family != AF_INET6 || *fromlen < sizeof(struct sockaddr_in6)) #else if (from->sa_family != AF_INET || *fromlen < sizeof(struct sockaddr_in)) #endif { err = EBADF; goto errout; } } /* Set the socket state to receiving */ psock->s_flags = _SS_SETSTATE(psock->s_flags, _SF_RECV); /* Perform the TCP/IP or UDP recv() operation */ #ifdef CONFIG_NET_UDP if (psock->s_type == SOCK_STREAM) #endif { ret = tcp_recvfrom(psock, buf, len, infrom); } #ifdef CONFIG_NET_UDP else { ret = udp_recvfrom(psock, buf, len, infrom); } #endif /* Set the socket state to idle */ psock->s_flags = _SS_SETSTATE(psock->s_flags, _SF_IDLE); /* Handle returned errors */ if (ret < 0) { err = -ret; goto errout; } /* Success return */ return ret; errout: *get_errno_ptr() = err; return ERROR; } #endif /* CONFIG_NET */