static inline int tcp_setup_callbacks(FAR struct socket *psock,
FAR struct tcp_connect_s *pstate)
{
FAR struct uip_conn *conn = psock->s_conn;
int ret = -EBUSY;
/* Initialize the TCP state structure */
(void)sem_init(&pstate->tc_sem, 0, 0); /* Doesn't really fail */
pstate->tc_conn = conn;
pstate->tc_result = -EAGAIN;
/* Set up the callbacks in the connection */
pstate->tc_cb = uip_tcpcallbackalloc(conn);
if (pstate->tc_cb)
{
/* Set up the connection "interrupt" handler */
pstate->tc_cb->flags = UIP_NEWDATA|UIP_CLOSE|UIP_ABORT|UIP_TIMEDOUT|UIP_CONNECTED;
pstate->tc_cb->priv = (void*)pstate;
pstate->tc_cb->event = tcp_connect_interrupt;
/* Set up the connection event monitor */
net_startmonitor(psock);
ret = OK;
}
return ret;
}
static inline void netclose_disconnect(FAR struct socket *psock)
{
struct tcp_close_s state;
uip_lock_t flags;
/* Interrupts are disabled here to avoid race conditions */
flags = uip_lock();
/* Is the TCP socket in a connected state? */
if (_SS_ISCONNECTED(psock->s_flags))
{
struct uip_conn *conn = (struct uip_conn*)psock->s_conn;
/* Check for the case where the host beat us and disconnected first */
if (conn->tcpstateflags == UIP_ESTABLISHED)
{
/* Set up to receive TCP data event callbacks */
state.cl_cb = uip_tcpcallbackalloc(conn);
if (state.cl_cb)
{
state.cl_psock = psock;
sem_init(&state.cl_sem, 0, 0);
state.cl_cb->flags = UIP_NEWDATA|UIP_POLL|UIP_CLOSE|UIP_ABORT;
state.cl_cb->priv = (void*)&state;
state.cl_cb->event = netclose_interrupt;
/* Notify the device driver of the availaibilty of TX data */
netdev_txnotify(&conn->ripaddr);
/* Wait for the disconnect event */
(void)uip_lockedwait(&state.cl_sem);
/* We are now disconnected */
sem_destroy(&state.cl_sem);
uip_tcpcallbackfree(conn, state.cl_cb);
}
}
}
uip_unlock(flags);
}
static inline int net_pollsetup(FAR struct socket *psock,
FAR struct pollfd *fds)
{
FAR struct uip_conn *conn = psock->s_conn;
FAR struct net_poll_s *info;
FAR struct uip_callback_s *cb;
uip_lock_t flags;
int ret;
/* Sanity check */
#ifdef CONFIG_DEBUG
if (!conn || !fds)
{
return -EINVAL;
}
#endif
/* Allocate a container to hold the poll information */
info = (FAR struct net_poll_s *)kmalloc(sizeof(struct net_poll_s));
if (!info)
{
return -ENOMEM;
}
/* Some of the following must be atomic */
flags = uip_lock();
/* Allocate a TCP/IP callback structure */
cb = uip_tcpcallbackalloc(conn);
if (!cb)
{
ret = -EBUSY;
goto errout_with_lock;
}
/* Initialize the poll info container */
info->psock = psock;
info->fds = fds;
info->cb = cb;
/* Initialize the callback structure. Save the reference to the info
* structure as callback private data so that it will be available during
* callback processing.
*/
cb->flags = (UIP_NEWDATA|UIP_BACKLOG|UIP_POLL|UIP_CLOSE|UIP_ABORT|UIP_TIMEDOUT);
cb->priv = (FAR void *)info;
cb->event = poll_interrupt;
/* Save the reference in the poll info structure as fds private as well
* for use durring poll teardown as well.
*/
fds->priv = (FAR void *)info;
#ifdef CONFIG_NET_TCPBACKLOG
/* Check for read data or backlogged connection availability now */
if (!sq_empty(&conn->readahead) || uip_backlogavailable(conn))
#else
/* Check for read data availability now */
if (!sq_empty(&conn->readahead))
#endif
{
fds->revents |= (POLLOUT & fds->events);
}
/* Check for a loss of connection events */
if (!_SS_ISCONNECTED(psock->s_flags))
{
fds->revents |= (POLLERR | POLLHUP);
}
/* Check if any requested events are already in effect */
if (fds->revents != 0)
{
/* Yes.. then signal the poll logic */
sem_post(fds->sem);
}
uip_unlock(flags);
return OK;
errout_with_lock:
kfree(info);
uip_unlock(flags);
return ret;
}
ssize_t send(int sockfd, const void *buf, size_t len, int flags)
{
FAR struct socket *psock = sockfd_socket(sockfd);
struct send_s state;
uip_lock_t save;
int err;
int ret = OK;
/* Verify that the sockfd corresponds to valid, allocated socket */
if (!psock || psock->s_crefs <= 0)
{
err = EBADF;
goto errout;
}
/* If this is an un-connected socket, then return ENOTCONN */
if (psock->s_type != SOCK_STREAM || !_SS_ISCONNECTED(psock->s_flags))
{
err = ENOTCONN;
goto errout;
}
/* Set the socket state to sending */
psock->s_flags = _SS_SETSTATE(psock->s_flags, _SF_SEND);
/* Perform the TCP send operation */
/* Initialize the state structure. This is done with interrupts
* disabled because we don't want anything to happen until we
* are ready.
*/
save = uip_lock();
memset(&state, 0, sizeof(struct send_s));
(void)sem_init(&state. snd_sem, 0, 0); /* Doesn't really fail */
state.snd_sock = psock; /* Socket descriptor to use */
state.snd_buflen = len; /* Number of bytes to send */
state.snd_buffer = buf; /* Buffer to send from */
if (len > 0)
{
struct uip_conn *conn = (struct uip_conn*)psock->s_conn;
/* Allocate resources to receive a callback */
state.snd_cb = uip_tcpcallbackalloc(conn);
if (state.snd_cb)
{
/* Get the initial sequence number that will be used */
state.snd_isn = uip_tcpgetsequence(conn->sndseq);
/* There is no outstanding, unacknowledged data after this
* initial sequence number.
*/
conn->unacked = 0;
/* Update the initial time for calculating timeouts */
#if defined(CONFIG_NET_SOCKOPTS) && !defined(CONFIG_DISABLE_CLOCK)
state.snd_time = clock_systimer();
#endif
/* Set up the callback in the connection */
state.snd_cb->flags = UIP_ACKDATA|UIP_REXMIT|UIP_POLL|UIP_CLOSE|UIP_ABORT|UIP_TIMEDOUT;
state.snd_cb->priv = (void*)&state;
state.snd_cb->event = send_interrupt;
/* Notify the device driver of the availaibilty of TX data */
netdev_txnotify(&conn->ripaddr);
/* Wait for the send to complete or an error to occur: NOTES: (1)
* uip_lockedwait will also terminate if a signal is received, (2) interrupts
* may be disabled! They will be re-enabled while the task sleeps and
* automatically re-enabled when the task restarts.
*/
ret = uip_lockedwait(&state. snd_sem);
/* Make sure that no further interrupts are processed */
uip_tcpcallbackfree(conn, state.snd_cb);
}
}
sem_destroy(&state. snd_sem);
uip_unlock(save);
/* Set the socket state to idle */
psock->s_flags = _SS_SETSTATE(psock->s_flags, _SF_IDLE);
/* Check for a errors. Errors are signaled by negative errno values
* for the send length
*/
if (state.snd_sent < 0)
{
err = state.snd_sent;
goto errout;
}
/* If uip_lockedwait failed, then we were probably reawakened by a signal. In
* this case, uip_lockedwait will have set errno appropriately.
*/
if (ret < 0)
{
err = -ret;
goto errout;
}
/* Return the number of bytes actually sent */
return state.snd_sent;
errout:
*get_errno_ptr() = err;
return ERROR;
}
static ssize_t tcp_recvfrom(FAR struct socket *psock, FAR void *buf, size_t len,
FAR struct sockaddr_in *infrom )
#endif
{
struct recvfrom_s state;
uip_lock_t save;
int ret;
/* Initialize the state structure. This is done with interrupts
* disabled because we don't want anything to happen until we
* are ready.
*/
save = uip_lock();
recvfrom_init(psock, buf, len, infrom, &state);
/* Handle any any TCP data already buffered in a read-ahead buffer. NOTE
* that there may be read-ahead data to be retrieved even after the
* socket has been disconnected.
*/
#if CONFIG_NET_NTCP_READAHEAD_BUFFERS > 0
recvfrom_readahead(&state);
/* The default return value is the number of bytes that we just copied into
* the user buffer. We will return this if the socket has become disconnected
* or if the user request was completely satisfied with data from the readahead
* buffers.
*/
ret = state.rf_recvlen;
#else
/* Otherwise, the default return value of zero is used (only for the case
* where len == state.rf_buflen is zero).
*/
ret = 0;
#endif
/* Verify that the SOCK_STREAM has been and still is connected */
if (!_SS_ISCONNECTED(psock->s_flags))
{
/* Was any data transferred from the readahead buffer after we were
* disconnected? If so, then return the number of bytes received. We
* will wait to return end disconnection indications the next time that
* recvfrom() is called.
*
* If no data was received (i.e., ret == 0 -- it will not be negative)
* and the connection was gracefully closed by the remote peer, then return
* success. If rf_recvlen is zero, the caller of recvfrom() will get an
* end-of-file indication.
*/
#if CONFIG_NET_NTCP_READAHEAD_BUFFERS > 0
if (ret <= 0 && !_SS_ISCLOSED(psock->s_flags))
#else
if (!_SS_ISCLOSED(psock->s_flags))
#endif
{
/* Nothing was previously received from the readahead buffers.
* The SOCK_STREAM must be (re-)connected in order to receive any
* additional data.
*/
ret = -ENOTCONN;
}
}
/* In general, this uIP-based implementation will not support non-blocking
* socket operations... except in a few cases: Here for TCP receive with read-ahead
* enabled. If this socket is configured as non-blocking then return EAGAIN
* if no data was obtained from the read-ahead buffers.
*/
else
#if CONFIG_NET_NTCP_READAHEAD_BUFFERS > 0
if (_SS_ISNONBLOCK(psock->s_flags))
{
/* Return the number of bytes read from the read-ahead buffer if
* something was received (already in 'ret'); EAGAIN if not.
*/
if (ret <= 0)
{
/* Nothing was received */
ret = -EAGAIN;
}
}
/* It is okay to block if we need to. If there is space to receive anything
* more, then we will wait to receive the data. Otherwise return the number
* of bytes read from the read-ahead buffer (already in 'ret').
*/
else
#endif
/* We get here when we we decide that we need to setup the wait for incoming
* TCP/IP data. Just a few more conditions to check:
*
* 1) Make sure thet there is buffer space to receive additional data
* (state.rf_buflen > 0). This could be zero, for example, if read-ahead
* buffering was enabled and we filled the user buffer with data from
* the read-ahead buffers. Aand
* 2) if read-ahead buffering is enabled (CONFIG_NET_NTCP_READAHEAD_BUFFERS > 0)
* and delay logic is disabled (CONFIG_NET_TCP_RECVDELAY == 0), then we
* not want to wait if we already obtained some data from the read-ahead
* buffer. In that case, return now with what we have (don't want for more
* because there may be no timeout).
*/
#if CONFIG_NET_TCP_RECVDELAY == 0 && CONFIG_NET_NTCP_READAHEAD_BUFFERS > 0
if (state.rf_recvlen == 0 && state.rf_buflen > 0)
#else
if (state.rf_buflen > 0)
#endif
{
struct uip_conn *conn = (struct uip_conn *)psock->s_conn;
/* Set up the callback in the connection */
state.rf_cb = uip_tcpcallbackalloc(conn);
if (state.rf_cb)
{
state.rf_cb->flags = UIP_NEWDATA|UIP_POLL|UIP_CLOSE|UIP_ABORT|UIP_TIMEDOUT;
state.rf_cb->priv = (void*)&state;
state.rf_cb->event = recvfrom_tcpinterrupt;
/* Wait for either the receive to complete or for an error/timeout to occur.
* NOTES: (1) uip_lockedwait will also terminate if a signal is received, (2)
* interrupts may be disabled! They will be re-enabled while the task sleeps
* and automatically re-enabled when the task restarts.
*/
ret = uip_lockedwait(&state.rf_sem);
/* Make sure that no further interrupts are processed */
uip_tcpcallbackfree(conn, state.rf_cb);
ret = recvfrom_result(ret, &state);
}
else
{
ret = -EBUSY;
}
}
uip_unlock(save);
recvfrom_uninit(&state);
return (ssize_t)ret;
}
static inline int net_pollsetup(FAR struct socket *psock, struct pollfd *fds)
{
FAR struct uip_conn *conn = psock->s_conn;
FAR struct uip_callback_s *cb;
uip_lock_t flags;
int ret;
/* Sanity check */
#ifdef CONFIG_DEBUG
if (!conn || !fds)
{
return -EINVAL;
}
#endif
/* Some of the following must be atomic */
flags = uip_lock();
/* Allocate a TCP/IP callback structure */
cb = uip_tcpcallbackalloc(conn);
if (!cb)
{
ret = -EBUSY;
goto errout_with_irq;
}
/* Initialize the callbcack structure */
cb->flags = UIP_NEWDATA|UIP_BACKLOG|UIP_POLL|UIP_CLOSE|UIP_ABORT|UIP_TIMEDOUT;
cb->priv = (FAR void *)fds;
cb->event = poll_interrupt;
/* Save the nps reference in the poll structure for use at teardown as well */
fds->priv = (FAR void *)cb;
#ifdef CONFIG_NET_TCPBACKLOG
/* Check for read data or backlogged connection availability now */
if (!sq_empty(&conn->readahead) || uip_backlogavailable(conn))
#else
/* Check for read data availability now */
if (!sq_empty(&conn->readahead))
#endif
{
fds->revents = fds->events & POLLIN;
if (fds->revents != 0)
{
/* If data is available now, the signal the poll logic */
sem_post(fds->sem);
}
}
uip_unlock(flags);
return OK;
errout_with_irq:
uip_unlock(flags);
return ret;
}
ssize_t psock_send(FAR struct socket *psock, FAR const void *buf, size_t len,
int flags)
{
uip_lock_t save;
size_t completed = 0;
int err;
int ret = OK;
if (!psock || psock->s_crefs <= 0)
{
err = EBADF;
goto errout;
}
if (psock->s_type != SOCK_STREAM || !_SS_ISCONNECTED(psock->s_flags))
{
err = ENOTCONN;
goto errout;
}
/* Set the socket state to sending */
psock->s_flags = _SS_SETSTATE(psock->s_flags, _SF_SEND);
save = uip_lock();
if (len > 0)
{
struct uip_conn *conn = (struct uip_conn*)psock->s_conn;
if (!psock->s_sndcb)
{
psock->s_sndcb = uip_tcpcallbackalloc(conn);
/* Set up the callback in the connection */
psock->s_sndcb->flags = (UIP_ACKDATA | UIP_REXMIT |UIP_POLL | \
UIP_CLOSE | UIP_ABORT | UIP_TIMEDOUT);
psock->s_sndcb->priv = (void*)psock;
psock->s_sndcb->event = send_interrupt;
}
/* Allocate resources to receive a callback */
while (completed < len)
{
FAR struct uip_wrbuffer_s *segment = uip_tcpwrbuffer_alloc(NULL);
if (segment)
{
size_t cnt;
segment->wb_seqno = (unsigned)-1;
segment->wb_nrtx = 0;
if (len - completed > CONFIG_NET_TCP_WRITE_BUFSIZE)
{
cnt = CONFIG_NET_TCP_WRITE_BUFSIZE;
}
else
{
cnt = len - completed;
}
segment->wb_nbytes = cnt;
memcpy(segment->wb_buffer, (char*)buf + completed, cnt);
completed += cnt;
/* send_interrupt() will refer to all the write buffer by
* conn->writebuff
*/
sq_addlast(&segment->wb_node, &conn->write_q);
/* Notify the device driver of the availability of TX data */
netdev_txnotify(conn->ripaddr);
}
}
}
uip_unlock(save);
/* Set the socket state to idle */
psock->s_flags = _SS_SETSTATE(psock->s_flags, _SF_IDLE);
/* Check for a errors. Errors are signaled by negative errno values
* for the send length
*/
if (completed < 0)
{
err = completed;
goto errout;
}
/* If uip_lockedwait failed, then we were probably reawakened by a signal.
* In this case, uip_lockedwait will have set errno appropriately.
*/
if (ret < 0)
{
err = -ret;
goto errout;
}
/* Return the number of bytes actually sent */
return completed;
errout:
set_errno(err);
return ERROR;
}
