Newer
Older
/****************************************************************************
* Copyright (C) 2007-2010 Gregory Nutt. All rights reserved.
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
* Author: Gregory Nutt <spudmonkey@racsa.co.cr>
*
* 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 <nuttx/config.h>
#ifdef CONFIG_NET
#include <sys/types.h>
#include <sys/socket.h>
patacongo
committed
#include <stdint.h>
/****************************************************************************
* Private Types
****************************************************************************/
FAR struct uip_conn *tc_conn; /* Reference to TCP connection structure */
FAR struct uip_callback_s *tc_cb; /* Reference to callback instance */
sem_t tc_sem; /* Semaphore signals recv completion */
int tc_result; /* OK on success, otherwise a negated errno. */
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
patacongo
committed
static void connection_event(struct uip_conn *conn, uint16_t flags);
static inline int tcp_setup_callbacks(FAR struct socket *psock,
FAR struct tcp_connect_s *pstate);
static inline void tcp_teardown_callbacks(struct tcp_connect_s *pstate, int status);
patacongo
committed
static uint16_t tcp_connect_interrupt(struct uip_driver_s *dev, void *pvconn,
void *pvpriv, uint16_t flags);
#ifdef CONFIG_NET_IPv6
static inline int tcp_connect(FAR struct socket *psock, const struct sockaddr_in6 *inaddr);
#else
static inline int tcp_connect(FAR struct socket *psock, const struct sockaddr_in *inaddr);
#endif
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Function: connection_event
*
* Description:
* Some connection related event has occurred
*
* Parameters:
* dev The sructure of the network driver that caused the interrupt
* conn The connection structure associated with the socket
* flags Set of events describing why the callback was invoked
*
* Returned Value:
* None
*
* Assumptions:
* Running at the interrupt level
*
****************************************************************************/
patacongo
committed
static void connection_event(struct uip_conn *conn, uint16_t flags)
FAR struct socket *psock = (FAR struct socket *)conn->connection_private;
nllvdbg("flags: %04x s_flags: %02x\n", flags, psock->s_flags);
/* UIP_CLOSE: The remote host has closed the connection
* UIP_ABORT: The remote host has aborted the connection
* UIP_TIMEDOUT: Connection aborted due to too many retransmissions.
*/
if ((flags & (UIP_CLOSE|UIP_ABORT|UIP_TIMEDOUT)) != 0)
psock->s_flags &= ~_SF_CONNECTED;
}
/* UIP_CONNECTED: The socket is successfully connected */
psock->s_flags |= _SF_CONNECTED;
}
}
}
/****************************************************************************
* Function: tcp_setup_callbacks
****************************************************************************/
static inline int tcp_setup_callbacks(FAR struct socket *psock,
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;
pstate->tc_cb = uip_tcpcallbackalloc(conn);
if (pstate->tc_cb)
{
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 to receive callbacks on connection-related events */
conn->connection_private = (void*)psock;
conn->connection_event = connection_event;
ret = OK;
}
return ret;
/****************************************************************************
* Function: tcp_teardown_callbacks
****************************************************************************/
static inline void tcp_teardown_callbacks(struct tcp_connect_s *pstate, int status)
struct uip_conn *conn = pstate->tc_conn;
/* Make sure that no further interrupts are processed */
uip_tcpcallbackfree(conn, pstate->tc_cb);
/* If we successfully connected, we will continue to monitor the connection state
* via callbacks.
*/
if (status < 0)
{
/* Failed to connect */
conn->connection_private = NULL;
conn->connection_event = NULL;
}
}
/****************************************************************************
* Function: tcp_connect_interrupt
*
* Description:
* This function is called from the interrupt level to perform the actual
* connection operation via by the uIP layer.
*
* Parameters:
* dev The sructure of the network driver that caused the interrupt
* pvconn The connection structure associated with the socket
* flags Set of events describing why the callback was invoked
*
* Assumptions:
* Running at the interrupt level
*
****************************************************************************/
patacongo
committed
static uint16_t tcp_connect_interrupt(struct uip_driver_s *dev, void *pvconn,
void *pvpriv, uint16_t flags)
struct tcp_connect_s *pstate = (struct tcp_connect_s *)pvpriv;
nllvdbg("flags: %04x\n", flags);
/* 'priv' might be null in some race conditions (?) */
if (pstate)
{
/* The following errors should be detected here (someday)
*
* ECONNREFUSED
* No one listening on the remote address.
* ENETUNREACH
* Network is unreachable.
* ETIMEDOUT
* Timeout while attempting connection. The server may be too busy
* to accept new connections.
*/
/* UIP_CLOSE: The remote host has closed the connection
* UIP_ABORT: The remote host has aborted the connection
*/
{
/* Indicate that remote host refused the connection */
pstate->tc_result = -ECONNREFUSED;
}
/* UIP_TIMEDOUT: Connection aborted due to too many retransmissions. */
{
/* Indicate that the remote host is unreachable (or should this be timedout?) */
}
/* UIP_CONNECTED: The socket is successfully connected */
{
/* Indicate that the socket is no longer connected */
pstate->tc_result = OK;
}
/* Otherwise, it is not an event of importance to us at the moment */
else
{
/* Drop data received in this state */
dev->d_len = 0;
return flags & ~UIP_NEWDATA;
nllvdbg("Resuming: %d\n", pstate->tc_result);
tcp_teardown_callbacks(pstate, pstate->tc_result);
/* Wake up the waiting thread */
sem_post(&pstate->tc_sem);
}
patacongo
committed
return flags;
/****************************************************************************
* Function: tcp_connect
*
* Description:
* Perform a TCP connection
*
* Parameters:
* psock A reference to the socket structure of the socket to be connected
* inaddr The address of the remote server to connect to
*
* Returned Value:
* None
*
* Assumptions:
* Running at the interrupt level
*
****************************************************************************/
#ifdef CONFIG_NET_IPv6
static inline int tcp_connect(FAR struct socket *psock, const struct sockaddr_in6 *inaddr)
#else
static inline int tcp_connect(FAR struct socket *psock, const struct sockaddr_in *inaddr)
#endif
{
struct tcp_connect_s state;
irqstate_t flags;
int ret = OK;
/* Interrupts must be disabled through all of the following because
* we cannot allow the network callback to occur until we are completely
* setup.
*/
flags = irqsave();
/* Get the connection reference from the socket */
if (!psock->s_conn) /* Should always be non-NULL */
{
ret = -EINVAL;
}
else
{
/* Perform the uIP connection operation */
ret = uip_tcpconnect(psock->s_conn, inaddr);
}
if (ret >= 0)
{
/* Set up the callbacks in the connection */
ret = tcp_setup_callbacks(psock, &state);
if (ret >= 0)
{
/* Wait for either the connect 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-disabled
* when the task restarts.
*/
ret = sem_wait(&state.tc_sem);
/* Uninitialize the state structure */
(void)sem_destroy(&state.tc_sem);
/* If sem_wait failed, recover the negated error (probably -EINTR) */
int err = errno;
if (err >= 0)
{
err = ENOSYS;
}
ret = -err;
else
{
/* If the wait succeeded, then get the new error value from
* the state structure
*/
ret = state.tc_result;
}
/* Make sure that no further interrupts are processed */
tcp_teardown_callbacks(&state, ret);
}
if (ret >= 0)
{
psock->s_flags |= (_SF_BOUND|_SF_CONNECTED);
}
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Function: connect
*
* Description:
* 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
*
* 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:
* 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, 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
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
* 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 connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
FAR struct socket *psock = sockfd_socket(sockfd);
#if defined(CONFIG_NET_TCP) || defined(CONFIG_NET_UDP)
#ifdef CONFIG_NET_IPv6
FAR const struct sockaddr_in6 *inaddr = (const struct sockaddr_in6 *)addr;
#else
FAR const struct sockaddr_in *inaddr = (const struct sockaddr_in *)addr;
#endif
/* Verify that the sockfd corresponds to valid, allocated socket */
if (!psock || psock->s_crefs <= 0)
{
err = EBADF;
goto errout;
}
/* Verify that a valid address has been provided */
#ifdef CONFIG_NET_IPv6
if (addr->sa_family != AF_INET6 || addrlen < sizeof(struct sockaddr_in6))
#else
if (addr->sa_family != AF_INET || addrlen < sizeof(struct sockaddr_in))
#endif
{
err = EBADF;
goto errout;
}
/* Perform the connection depending on the protocol type */
/* Verify that the socket is not already connected */
if (_SS_ISCONNECTED(psock->s_flags))
{
#ifdef CONFIG_NET_UDP
case SOCK_DGRAM:
{
ret = uip_udpconnect(psock->s_conn, inaddr);
if (ret < 0)
{
err = -ret;
goto errout;
}
}
break;
#endif
default:
err = EBADF;
goto errout;
}