tcp.c File Reference

TCP protocol. More...

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <errno.h>
#include <byteswap.h>
#include <gpxe/timer.h>
#include <gpxe/iobuf.h>
#include <gpxe/malloc.h>
#include <gpxe/retry.h>
#include <gpxe/refcnt.h>
#include <gpxe/xfer.h>
#include <gpxe/open.h>
#include <gpxe/uri.h>
#include <gpxe/tcpip.h>
#include <gpxe/tcp.h>

Go to the source code of this file.

Data Structures
struct	tcp_connection
	A TCP connection. More...
Functions
	FILE_LICENCE (GPL2_OR_LATER)
static	LIST_HEAD (tcp_conns)
	List of registered TCP connections.
static void	tcp_expired (struct retry_timer *timer, int over)
	Retransmission timer expired.
static int	tcp_rx_ack (struct tcp_connection *tcp, uint32_t ack, uint32_t win)
	Handle TCP received ACK.
static const char *	tcp_state (int state)
	Name TCP state.
static void	tcp_dump_state (struct tcp_connection *tcp)
	Dump TCP state transition.
static void	tcp_dump_flags (struct tcp_connection *tcp, unsigned int flags)
	Dump TCP flags.
static int	tcp_bind (struct tcp_connection *tcp, unsigned int port)
	Bind TCP connection to local port.
static int	tcp_open (struct xfer_interface *xfer, struct sockaddr *peer, struct sockaddr *local)
	Open a TCP connection.
static void	tcp_close (struct tcp_connection *tcp, int rc)
	Close TCP connection.
static size_t	tcp_xmit_win (struct tcp_connection *tcp)
	Calculate transmission window.
static size_t	tcp_process_queue (struct tcp_connection *tcp, size_t max_len, struct io_buffer *dest, int remove)
	Process TCP transmit queue.
static int	tcp_xmit (struct tcp_connection *tcp, int force_send)
	Transmit any outstanding data.
static int	tcp_xmit_reset (struct tcp_connection *tcp, struct sockaddr_tcpip *st_dest, struct tcp_header *in_tcphdr)
	Send RST response to incoming packet.
static struct tcp_connection *	tcp_demux (unsigned int local_port)
	Identify TCP connection by local port number.
static void	tcp_rx_opts (struct tcp_connection *tcp, const void *data, size_t len, struct tcp_options *options)
	Parse TCP received options.
static void	tcp_rx_seq (struct tcp_connection *tcp, uint32_t seq_len)
	Consume received sequence space.
static int	tcp_rx_syn (struct tcp_connection *tcp, uint32_t seq, struct tcp_options *options)
	Handle TCP received SYN.
static int	tcp_rx_data (struct tcp_connection *tcp, uint32_t seq, struct io_buffer *iobuf)
	Handle TCP received data.
static int	tcp_rx_fin (struct tcp_connection *tcp, uint32_t seq)
	Handle TCP received FIN.
static int	tcp_rx_rst (struct tcp_connection *tcp, uint32_t seq)
	Handle TCP received RST.
static int	tcp_rx (struct io_buffer *iobuf, struct sockaddr_tcpip *st_src, struct sockaddr_tcpip *st_dest __unused, uint16_t pshdr_csum)
	Process received packet.
static void	tcp_xfer_close (struct xfer_interface *xfer, int rc)
	Close interface.
static size_t	tcp_xfer_window (struct xfer_interface *xfer)
	Check flow control window.
static int	tcp_xfer_deliver_iob (struct xfer_interface *xfer, struct io_buffer *iobuf, struct xfer_metadata *meta __unused)
	Deliver datagram as I/O buffer.
static int	tcp_open_uri (struct xfer_interface *xfer, struct uri *uri)
	Open TCP URI.
Variables
static struct xfer_interface_operations	tcp_xfer_operations
	TCP data transfer interface operations.
struct tcpip_protocol tcp_protocol	__tcpip_protocol
	TCP protocol.
struct socket_opener tcp_socket_opener	__socket_opener
	TCP socket opener.
int	tcp_sock_stream = TCP_SOCK_STREAM
	Linkage hack.
struct uri_opener tcp_uri_opener	__uri_opener
	TCP URI opener.

---

Detailed Description

TCP protocol.

Definition in file tcp.c.

---

Function Documentation

FILE_LICENCE

(

GPL2_OR_LATER

)

static LIST_HEAD

(

tcp_conns

)

[static]

List of registered TCP connections.

static void tcp_expired	(	struct retry_timer *	timer,
		int	over
	)			[static]

Retransmission timer expired.

Parameters:

	timer	Retry timer
	over	Failure indicator

Definition at line 518 of file tcp.c.

References assert, container_of, DBGC, ETIMEDOUT, tcp_connection::rcv_ack, tcp_connection::snd_sent, tcp_connection::snd_seq, tcp_close(), TCP_CLOSE_WAIT, TCP_CLOSED, TCP_CLOSED_GRACEFULLY, TCP_CLOSING_OR_LAST_ACK, tcp_dump_state(), TCP_ESTABLISHED, TCP_FIN_WAIT_1, tcp_state(), tcp_connection::tcp_state, TCP_SYN_RCVD, TCP_SYN_SENT, TCP_TIME_WAIT, and tcp_xmit().

Referenced by tcp_open().

                                                                {
        struct tcp_connection *tcp =
                container_of ( timer, struct tcp_connection, timer );
        int graceful_close = TCP_CLOSED_GRACEFULLY ( tcp->tcp_state );

        DBGC ( tcp, "TCP %p timer %s in %s for %08x..%08x %08x\n", tcp,
               ( over ? "expired" : "fired" ), tcp_state ( tcp->tcp_state ),
               tcp->snd_seq, ( tcp->snd_seq + tcp->snd_sent ), tcp->rcv_ack );

        assert ( ( tcp->tcp_state == TCP_SYN_SENT ) ||
                 ( tcp->tcp_state == TCP_SYN_RCVD ) ||
                 ( tcp->tcp_state == TCP_ESTABLISHED ) ||
                 ( tcp->tcp_state == TCP_FIN_WAIT_1 ) ||
                 ( tcp->tcp_state == TCP_TIME_WAIT ) ||
                 ( tcp->tcp_state == TCP_CLOSE_WAIT ) ||
                 ( tcp->tcp_state == TCP_CLOSING_OR_LAST_ACK ) );

        if ( over || graceful_close ) {
                /* If we have finally timed out and given up, or if
                 * this is the result of a graceful close, terminate
                 * the connection
                 */
                tcp->tcp_state = TCP_CLOSED;
                tcp_dump_state ( tcp );
                tcp_close ( tcp, -ETIMEDOUT );
        } else {
                /* Otherwise, retransmit the packet */
                tcp_xmit ( tcp, 0 );
        }
}

static int tcp_rx_ack	(	struct tcp_connection *	tcp,
		uint32_t	ack,
		uint32_t	win
	)			[static]

Handle TCP received ACK.

Parameters:

	tcp	TCP connection
	ack	ACK value (in host-endian order)
	win	WIN value (in host-endian order)

Return values:

rc

Return status code

Definition at line 723 of file tcp.c.

References DBGC, EINVAL, list_empty(), NULL, tcp_connection::queue, tcp_connection::snd_sent, tcp_connection::snd_seq, tcp_connection::snd_win, stop_timer(), TCP_FIN, TCP_FLAGS_SENDING, TCP_HAS_BEEN_ESTABLISHED, tcp_process_queue(), tcp_connection::tcp_state, TCP_STATE_ACKED, TCP_STATE_SENT, TCP_SYN, tcp_connection::timer, and tcp_connection::xfer_closed.

Referenced by tcp_close(), and tcp_rx().

                                       {
        uint32_t ack_len = ( ack - tcp->snd_seq );
        size_t len;
        unsigned int acked_flags;

        /* Check for out-of-range or old duplicate ACKs */
        if ( ack_len > tcp->snd_sent ) {
                DBGC ( tcp, "TCP %p received ACK for %08x..%08x, "
                       "sent only %08x..%08x\n", tcp, tcp->snd_seq,
                       ( tcp->snd_seq + ack_len ), tcp->snd_seq,
                       ( tcp->snd_seq + tcp->snd_sent ) );

                if ( TCP_HAS_BEEN_ESTABLISHED ( tcp->tcp_state ) ) {
                        /* Just ignore what might be old duplicate ACKs */
                        return 0;
                } else {
                        /* Send RST if an out-of-range ACK is received
                         * on a not-yet-established connection, as per
                         * RFC 793.
                         */
                        return -EINVAL;
                }
        }

        /* Ignore ACKs that don't actually acknowledge any new data.
         * (In particular, do not stop the retransmission timer; this
         * avoids creating a sorceror's apprentice syndrome when a
         * duplicate ACK is received and we still have data in our
         * transmit queue.)
         */
        if ( ack_len == 0 )
                return 0;

        /* Stop the retransmission timer */
        stop_timer ( &tcp->timer );

        /* Determine acknowledged flags and data length */
        len = ack_len;
        acked_flags = ( TCP_FLAGS_SENDING ( tcp->tcp_state ) &
                        ( TCP_SYN | TCP_FIN ) );
        if ( acked_flags )
                len--;

        /* Update SEQ and sent counters, and window size */
        tcp->snd_seq = ack;
        tcp->snd_sent = 0;
        tcp->snd_win = win;

        /* Remove any acknowledged data from transmit queue */
        tcp_process_queue ( tcp, len, NULL, 1 );
                
        /* Mark SYN/FIN as acknowledged if applicable. */
        if ( acked_flags )
                tcp->tcp_state |= TCP_STATE_ACKED ( acked_flags );

        /* Start sending FIN if we've had all possible data ACKed */
        if ( list_empty ( &tcp->queue ) && tcp->xfer_closed )
                tcp->tcp_state |= TCP_STATE_SENT ( TCP_FIN );

        return 0;
}

static const char* tcp_state

(

int

state

)

[inline, static]

Name TCP state.

Parameters:

state

TCP state

Return values:

name

Name of TCP state

Definition at line 107 of file tcp.c.

References TCP_CLOSE_WAIT, TCP_CLOSED, TCP_CLOSING_OR_LAST_ACK, TCP_ESTABLISHED, TCP_FIN_WAIT_1, TCP_FIN_WAIT_2, TCP_LISTEN, TCP_SYN_RCVD, TCP_SYN_SENT, and TCP_TIME_WAIT.

Referenced by tcp_dump_state(), and tcp_expired().

                        {
        switch ( state ) {
        case TCP_CLOSED:                return "CLOSED";
        case TCP_LISTEN:                return "LISTEN";
        case TCP_SYN_SENT:              return "SYN_SENT";
        case TCP_SYN_RCVD:              return "SYN_RCVD";
        case TCP_ESTABLISHED:           return "ESTABLISHED";
        case TCP_FIN_WAIT_1:            return "FIN_WAIT_1";
        case TCP_FIN_WAIT_2:            return "FIN_WAIT_2";
        case TCP_CLOSING_OR_LAST_ACK:   return "CLOSING/LAST_ACK";
        case TCP_TIME_WAIT:             return "TIME_WAIT";
        case TCP_CLOSE_WAIT:            return "CLOSE_WAIT";
        default:                        return "INVALID";
        }
}

static void tcp_dump_state

(

struct tcp_connection *

tcp

)

[inline, static]

Dump TCP state transition.

Parameters:

tcp

TCP connection

Definition at line 129 of file tcp.c.

References DBGC, and tcp_state().

Referenced by tcp_close(), tcp_expired(), tcp_open(), tcp_rx(), and tcp_rx_rst().

                                              {

        if ( tcp->tcp_state != tcp->prev_tcp_state ) {
                DBGC ( tcp, "TCP %p transitioned from %s to %s\n", tcp,
                       tcp_state ( tcp->prev_tcp_state ),
                       tcp_state ( tcp->tcp_state ) );
        }
        tcp->prev_tcp_state = tcp->tcp_state;
}

static void tcp_dump_flags	(	struct tcp_connection *	tcp,
		unsigned int	flags
	)			[inline, static]

Dump TCP flags.

Parameters:

flags

TCP flags

Definition at line 145 of file tcp.c.

References DBGC2, TCP_ACK, TCP_FIN, TCP_PSH, TCP_RST, and TCP_SYN.

Referenced by tcp_rx(), tcp_xmit(), and tcp_xmit_reset().

                                                                  {
        if ( flags & TCP_RST )
                DBGC2 ( tcp, " RST" );
        if ( flags & TCP_SYN )
                DBGC2 ( tcp, " SYN" );
        if ( flags & TCP_PSH )
                DBGC2 ( tcp, " PSH" );
        if ( flags & TCP_FIN )
                DBGC2 ( tcp, " FIN" );
        if ( flags & TCP_ACK )
                DBGC2 ( tcp, " ACK" );
}

static int tcp_bind	(	struct tcp_connection *	tcp,
		unsigned int	port
	)			[static]

Bind TCP connection to local port.

Parameters:

	tcp	TCP connection
	port	Local port number, in network-endian order

Return values:

rc

Return status code

If the port is 0, the connection is assigned an available port between 1024 and 65535.

Definition at line 175 of file tcp.c.

References DBGC, EADDRINUSE, htons, tcp_connection::list, list_for_each_entry, tcp_connection::local_port, and ntohs.

Referenced by tcp_open().

                                                                      {
        struct tcp_connection *existing;
        static uint16_t try_port = 1023;

        /* If no port specified, find the first available port */
        if ( ! port ) {
                while ( try_port ) {
                        try_port++;
                        if ( try_port < 1024 )
                                continue;
                        if ( tcp_bind ( tcp, htons ( try_port ) ) == 0 )
                                return 0;
                }
                DBGC ( tcp, "TCP %p could not bind: no free ports\n", tcp );
                return -EADDRINUSE;
        }

        /* Attempt bind to local port */
        list_for_each_entry ( existing, &tcp_conns, list ) {
                if ( existing->local_port == port ) {
                        DBGC ( tcp, "TCP %p could not bind: port %d in use\n",
                               tcp, ntohs ( port ) );
                        return -EADDRINUSE;
                }
        }
        tcp->local_port = port;

        DBGC ( tcp, "TCP %p bound to port %d\n", tcp, ntohs ( port ) );
        return 0;
}

static int tcp_open	(	struct xfer_interface *	xfer,
		struct sockaddr *	peer,
		struct sockaddr *	local
	)			[static]

Open a TCP connection.

Parameters:

	xfer	Data transfer interface
	peer	Peer socket address
	local	Local socket address, or NULL

Return values:

rc

Return status code

Definition at line 214 of file tcp.c.

References DBGC, ENOMEM, retry_timer::expired, INIT_LIST_HEAD, tcp_connection::list, list_add, memcpy, tcp_connection::peer, tcp_connection::prev_tcp_state, tcp_connection::queue, random(), ref_put(), tcp_connection::refcnt, tcp_connection::snd_seq, sockaddr_tcpip::st_port, start_timer_nodelay(), tcp_bind(), TCP_CLOSED, tcp_dump_state(), tcp_expired(), tcp_connection::tcp_state, TCP_STATE_SENT, TCP_SYN, tcp_xfer_operations, tcp_connection::timer, tcp_connection::xfer, xfer_init(), and zalloc().

                                               {
        struct sockaddr_tcpip *st_peer = ( struct sockaddr_tcpip * ) peer;
        struct sockaddr_tcpip *st_local = ( struct sockaddr_tcpip * ) local;
        struct tcp_connection *tcp;
        unsigned int bind_port;
        int rc;

        /* Allocate and initialise structure */
        tcp = zalloc ( sizeof ( *tcp ) );
        if ( ! tcp )
                return -ENOMEM;
        DBGC ( tcp, "TCP %p allocated\n", tcp );
        xfer_init ( &tcp->xfer, &tcp_xfer_operations, &tcp->refcnt );
        tcp->prev_tcp_state = TCP_CLOSED;
        tcp->tcp_state = TCP_STATE_SENT ( TCP_SYN );
        tcp_dump_state ( tcp );
        tcp->snd_seq = random();
        INIT_LIST_HEAD ( &tcp->queue );
        tcp->timer.expired = tcp_expired;
        memcpy ( &tcp->peer, st_peer, sizeof ( tcp->peer ) );

        /* Bind to local port */
        bind_port = ( st_local ? st_local->st_port : 0 );
        if ( ( rc = tcp_bind ( tcp, bind_port ) ) != 0 )
                goto err;

        /* Start timer to initiate SYN */
        start_timer_nodelay ( &tcp->timer );

        /* Attach parent interface, transfer reference to connection
         * list and return
         */
        xfer_plug_plug ( &tcp->xfer, xfer );
        list_add ( &tcp->list, &tcp_conns );
        return 0;

 err:
        ref_put ( &tcp->refcnt );
        return rc;
}

static void tcp_close	(	struct tcp_connection *	tcp,
		int	rc
	)			[static]

Close TCP connection.

Parameters:

	tcp	TCP connection
	rc	Reason for close

Closes the data transfer interface. If the TCP state machine is in a suitable state, the connection will be deleted.

Definition at line 265 of file tcp.c.

References DBGC, free_iob(), tcp_connection::list, io_buffer::list, list_del, list_empty(), list_for_each_entry_safe, tcp_connection::queue, ref_put(), tcp_connection::refcnt, tcp_connection::snd_seq, stop_timer(), TCP_CLOSED, tcp_dump_state(), TCP_FIN, tcp_rx_ack(), tcp_connection::tcp_state, TCP_STATE_ACKED, TCP_STATE_RCVD, TCP_STATE_SENT, TCP_SYN, tcp_connection::timer, tcp_connection::xfer, xfer_close(), and tcp_connection::xfer_closed.

Referenced by tcp_expired(), tcp_rx_fin(), tcp_rx_rst(), and tcp_xfer_close().

                                                             {
        struct io_buffer *iobuf;
        struct io_buffer *tmp;

        /* Close data transfer interface */
        xfer_nullify ( &tcp->xfer );
        xfer_close ( &tcp->xfer, rc );
        tcp->xfer_closed = 1;

        /* If we are in CLOSED, or have otherwise not yet received a
         * SYN (i.e. we are in LISTEN or SYN_SENT), just delete the
         * connection.
         */
        if ( ! ( tcp->tcp_state & TCP_STATE_RCVD ( TCP_SYN ) ) ) {

                /* Transition to CLOSED for the sake of debugging messages */
                tcp->tcp_state = TCP_CLOSED;
                tcp_dump_state ( tcp );

                /* Free any unsent I/O buffers */
                list_for_each_entry_safe ( iobuf, tmp, &tcp->queue, list ) {
                        list_del ( &iobuf->list );
                        free_iob ( iobuf );
                }

                /* Remove from list and drop reference */
                stop_timer ( &tcp->timer );
                list_del ( &tcp->list );
                ref_put ( &tcp->refcnt );
                DBGC ( tcp, "TCP %p connection deleted\n", tcp );
                return;
        }

        /* If we have not had our SYN acknowledged (i.e. we are in
         * SYN_RCVD), pretend that it has been acknowledged so that we
         * can send a FIN without breaking things.
         */
        if ( ! ( tcp->tcp_state & TCP_STATE_ACKED ( TCP_SYN ) ) )
                tcp_rx_ack ( tcp, ( tcp->snd_seq + 1 ), 0 );

        /* If we have no data remaining to send, start sending FIN */
        if ( list_empty ( &tcp->queue ) ) {
                tcp->tcp_state |= TCP_STATE_SENT ( TCP_FIN );
                tcp_dump_state ( tcp );
        }
}

static size_t tcp_xmit_win

(

struct tcp_connection *

tcp

)

[static]

Calculate transmission window.

Parameters:

tcp

TCP connection

Return values:

len

Maximum length that can be sent in a single packet

Definition at line 325 of file tcp.c.

References tcp_connection::snd_win, TCP_CAN_SEND_DATA, TCP_PATH_MTU, and tcp_connection::tcp_state.

Referenced by tcp_xfer_window(), and tcp_xmit().

                                                          {
        size_t len;

        /* Not ready if we're not in a suitable connection state */
        if ( ! TCP_CAN_SEND_DATA ( tcp->tcp_state ) )
                return 0;

        /* Length is the minimum of the receiver's window and the path MTU */
        len = tcp->snd_win;
        if ( len > TCP_PATH_MTU )
                len = TCP_PATH_MTU;

        return len;
}

static size_t tcp_process_queue	(	struct tcp_connection *	tcp,
		size_t	max_len,
		struct io_buffer *	dest,
		int	remove
	)			[static]

Process TCP transmit queue.

Parameters:

	tcp	TCP connection
	max_len	Maximum length to process
	dest	I/O buffer to fill with data, or NULL
	remove	Remove data from queue

Return values:

len

Length of data processed

This processes at most max_len bytes from the TCP connection's transmit queue. Data will be copied into the dest I/O buffer (if provided) and, if remove is true, removed from the transmit queue.

Definition at line 354 of file tcp.c.

References io_buffer::data, free_iob(), iob_len(), iob_pull, iob_put, io_buffer::list, list_del, list_for_each_entry_safe, memcpy, and tcp_connection::queue.

Referenced by tcp_rx_ack(), and tcp_xmit().

                                                                       {
        struct io_buffer *iobuf;
        struct io_buffer *tmp;
        size_t frag_len;
        size_t len = 0;

        list_for_each_entry_safe ( iobuf, tmp, &tcp->queue, list ) {
                frag_len = iob_len ( iobuf );
                if ( frag_len > max_len )
                        frag_len = max_len;
                if ( dest ) {
                        memcpy ( iob_put ( dest, frag_len ), iobuf->data,
                                 frag_len );
                }
                if ( remove ) {
                        iob_pull ( iobuf, frag_len );
                        if ( ! iob_len ( iobuf ) ) {
                                list_del ( &iobuf->list );
                                free_iob ( iobuf );
                        }
                }
                len += frag_len;
                max_len -= frag_len;
        }
        return len;
}

static int tcp_xmit	(	struct tcp_connection *	tcp,
		int	force_send
	)			[static]

Transmit any outstanding data.

Parameters:

	tcp	TCP connection
	force_send	Force sending of packet

Transmits any outstanding data on the connection.

Note that even if an error is returned, the retransmission timer will have been started if necessary, and so the stack will eventually attempt to retransmit the failed packet.

Definition at line 394 of file tcp.c.

References tcp_header::ack, alloc_iob(), assert, tcp_header::csum, currticks(), io_buffer::data, DBGC, DBGC2, tcp_header::dest, ENOMEM, tcp_header::flags, freemem, tcp_header::hlen, htonl, htons, iob_len(), iob_push, iob_reserve, tcp_timestamp_option::kind, tcp_mss_option::kind, tcp_timestamp_option::length, tcp_mss_option::length, tcp_connection::local_port, MAX_HDR_LEN, memset(), tcp_mss_option::mss, tcp_timestamp_padded_option::nop, ntohl, ntohs, NULL, tcp_connection::peer, tcp_connection::rcv_ack, tcp_connection::rcv_win, tcp_header::seq, tcp_connection::snd_sent, tcp_connection::snd_seq, tcp_header::src, sockaddr_tcpip::st_port, start_timer(), strerror(), TCP_CAN_SEND_DATA, tcp_dump_flags(), TCP_FIN, TCP_FLAGS_SENDING, TCP_MAX_WINDOW_SIZE, TCP_MSS, TCP_OPTION_MSS, TCP_OPTION_NOP, TCP_OPTION_TS, tcp_process_queue(), tcp_protocol, TCP_PSH, tcp_connection::tcp_state, TCP_SYN, tcp_xmit_win(), tcpip_chksum(), tcpip_tx(), tcp_connection::timer, tcp_connection::timestamps, tcp_connection::ts_recent, tcp_timestamp_option::tsecr, tcp_timestamp_padded_option::tsopt, tcp_timestamp_option::tsval, tcp_header::win, tcp_connection::xfer, and xfer_window().

Referenced by tcp_expired(), tcp_rx(), tcp_xfer_close(), and tcp_xfer_deliver_iob().

                                                                   {
        struct io_buffer *iobuf;
        struct tcp_header *tcphdr;
        struct tcp_mss_option *mssopt;
        struct tcp_timestamp_padded_option *tsopt;
        void *payload;
        unsigned int flags;
        size_t len = 0;
        uint32_t seq_len;
        uint32_t app_win;
        uint32_t max_rcv_win;
        int rc;

        /* If retransmission timer is already running, do nothing */
        if ( timer_running ( &tcp->timer ) )
                return 0;

        /* Calculate both the actual (payload) and sequence space
         * lengths that we wish to transmit.
         */
        if ( TCP_CAN_SEND_DATA ( tcp->tcp_state ) ) {
                len = tcp_process_queue ( tcp, tcp_xmit_win ( tcp ),
                                          NULL, 0 );
        }
        seq_len = len;
        flags = TCP_FLAGS_SENDING ( tcp->tcp_state );
        if ( flags & ( TCP_SYN | TCP_FIN ) ) {
                /* SYN or FIN consume one byte, and we can never send both */
                assert ( ! ( ( flags & TCP_SYN ) && ( flags & TCP_FIN ) ) );
                seq_len++;
        }
        tcp->snd_sent = seq_len;

        /* If we have nothing to transmit, stop now */
        if ( ( seq_len == 0 ) && ! force_send )
                return 0;

        /* If we are transmitting anything that requires
         * acknowledgement (i.e. consumes sequence space), start the
         * retransmission timer.  Do this before attempting to
         * allocate the I/O buffer, in case allocation itself fails.
         */
        if ( seq_len )
                start_timer ( &tcp->timer );

        /* Allocate I/O buffer */
        iobuf = alloc_iob ( len + MAX_HDR_LEN );
        if ( ! iobuf ) {
                DBGC ( tcp, "TCP %p could not allocate iobuf for %08x..%08x "
                       "%08x\n", tcp, tcp->snd_seq, ( tcp->snd_seq + seq_len ),
                       tcp->rcv_ack );
                return -ENOMEM;
        }
        iob_reserve ( iobuf, MAX_HDR_LEN );

        /* Fill data payload from transmit queue */
        tcp_process_queue ( tcp, len, iobuf, 0 );

        /* Expand receive window if possible */
        max_rcv_win = ( ( freemem * 3 ) / 4 );
        if ( max_rcv_win > TCP_MAX_WINDOW_SIZE )
                max_rcv_win = TCP_MAX_WINDOW_SIZE;
        app_win = xfer_window ( &tcp->xfer );
        if ( max_rcv_win > app_win )
                max_rcv_win = app_win;
        max_rcv_win &= ~0x03; /* Keep everything dword-aligned */
        if ( tcp->rcv_win < max_rcv_win )
                tcp->rcv_win = max_rcv_win;

        /* Fill up the TCP header */
        payload = iobuf->data;
        if ( flags & TCP_SYN ) {
                mssopt = iob_push ( iobuf, sizeof ( *mssopt ) );
                mssopt->kind = TCP_OPTION_MSS;
                mssopt->length = sizeof ( *mssopt );
                mssopt->mss = htons ( TCP_MSS );
        }
        if ( ( flags & TCP_SYN ) || tcp->timestamps ) {
                tsopt = iob_push ( iobuf, sizeof ( *tsopt ) );
                memset ( tsopt->nop, TCP_OPTION_NOP, sizeof ( tsopt->nop ) );
                tsopt->tsopt.kind = TCP_OPTION_TS;
                tsopt->tsopt.length = sizeof ( tsopt->tsopt );
                tsopt->tsopt.tsval = ntohl ( currticks() );
                tsopt->tsopt.tsecr = ntohl ( tcp->ts_recent );
        }
        if ( ! ( flags & TCP_SYN ) )
                flags |= TCP_PSH;
        tcphdr = iob_push ( iobuf, sizeof ( *tcphdr ) );
        memset ( tcphdr, 0, sizeof ( *tcphdr ) );
        tcphdr->src = tcp->local_port;
        tcphdr->dest = tcp->peer.st_port;
        tcphdr->seq = htonl ( tcp->snd_seq );
        tcphdr->ack = htonl ( tcp->rcv_ack );
        tcphdr->hlen = ( ( payload - iobuf->data ) << 2 );
        tcphdr->flags = flags;
        tcphdr->win = htons ( tcp->rcv_win );
        tcphdr->csum = tcpip_chksum ( iobuf->data, iob_len ( iobuf ) );

        /* Dump header */
        DBGC2 ( tcp, "TCP %p TX %d->%d %08x..%08x           %08x %4zd",
                tcp, ntohs ( tcphdr->src ), ntohs ( tcphdr->dest ),
                ntohl ( tcphdr->seq ), ( ntohl ( tcphdr->seq ) + seq_len ),
                ntohl ( tcphdr->ack ), len );
        tcp_dump_flags ( tcp, tcphdr->flags );
        DBGC2 ( tcp, "\n" );

        /* Transmit packet */
        if ( ( rc = tcpip_tx ( iobuf, &tcp_protocol, NULL, &tcp->peer, NULL,
                               &tcphdr->csum ) ) != 0 ) {
                DBGC ( tcp, "TCP %p could not transmit %08x..%08x %08x: %s\n",
                       tcp, tcp->snd_seq, ( tcp->snd_seq + tcp->snd_sent ),
                       tcp->rcv_ack, strerror ( rc ) );
                return rc;
        }

        return 0;
}

static int tcp_xmit_reset	(	struct tcp_connection *	tcp,
		struct sockaddr_tcpip *	st_dest,
		struct tcp_header *	in_tcphdr
	)			[static]

Send RST response to incoming packet.

Parameters:

in_tcphdr

TCP header of incoming packet

Return values:

rc

Return status code

Definition at line 555 of file tcp.c.

References tcp_header::ack, alloc_iob(), tcp_header::csum, io_buffer::data, DBGC, DBGC2, tcp_header::dest, ENOMEM, tcp_header::flags, tcp_header::hlen, htons, iob_len(), iob_push, iob_reserve, MAX_HDR_LEN, memset(), ntohl, ntohs, NULL, tcp_header::seq, tcp_header::src, strerror(), TCP_ACK, tcp_dump_flags(), TCP_MAX_WINDOW_SIZE, tcp_protocol, TCP_RST, tcpip_chksum(), tcpip_tx(), and tcp_header::win.

Referenced by tcp_rx().

                                                           {
        struct io_buffer *iobuf;
        struct tcp_header *tcphdr;
        int rc;

        /* Allocate space for dataless TX buffer */
        iobuf = alloc_iob ( MAX_HDR_LEN );
        if ( ! iobuf ) {
                DBGC ( tcp, "TCP %p could not allocate iobuf for RST "
                       "%08x..%08x %08x\n", tcp, ntohl ( in_tcphdr->ack ),
                       ntohl ( in_tcphdr->ack ), ntohl ( in_tcphdr->seq ) );
                return -ENOMEM;
        }
        iob_reserve ( iobuf, MAX_HDR_LEN );

        /* Construct RST response */
        tcphdr = iob_push ( iobuf, sizeof ( *tcphdr ) );
        memset ( tcphdr, 0, sizeof ( *tcphdr ) );
        tcphdr->src = in_tcphdr->dest;
        tcphdr->dest = in_tcphdr->src;
        tcphdr->seq = in_tcphdr->ack;
        tcphdr->ack = in_tcphdr->seq;
        tcphdr->hlen = ( ( sizeof ( *tcphdr ) / 4 ) << 4 );
        tcphdr->flags = ( TCP_RST | TCP_ACK );
        tcphdr->win = htons ( TCP_MAX_WINDOW_SIZE );
        tcphdr->csum = tcpip_chksum ( iobuf->data, iob_len ( iobuf ) );

        /* Dump header */
        DBGC2 ( tcp, "TCP %p TX %d->%d %08x..%08x           %08x %4d",
                tcp, ntohs ( tcphdr->src ), ntohs ( tcphdr->dest ),
                ntohl ( tcphdr->seq ), ( ntohl ( tcphdr->seq ) ),
                ntohl ( tcphdr->ack ), 0 );
        tcp_dump_flags ( tcp, tcphdr->flags );
        DBGC2 ( tcp, "\n" );

        /* Transmit packet */
        if ( ( rc = tcpip_tx ( iobuf, &tcp_protocol, NULL, st_dest,
                               NULL, &tcphdr->csum ) ) != 0 ) {
                DBGC ( tcp, "TCP %p could not transmit RST %08x..%08x %08x: "
                       "%s\n", tcp, ntohl ( in_tcphdr->ack ),
                       ntohl ( in_tcphdr->ack ), ntohl ( in_tcphdr->seq ),
                       strerror ( rc ) );
                return rc;
        }

        return 0;
}

static struct tcp_connection* tcp_demux

(

unsigned int

local_port

)

[static, read]

Identify TCP connection by local port number.

Parameters:

local_port

Local port (in network-endian order)

Return values:

tcp

TCP connection, or NULL

Definition at line 618 of file tcp.c.

References tcp_connection::list, list_for_each_entry, tcp_connection::local_port, and NULL.

Referenced by tcp_rx().

                                                                     {
        struct tcp_connection *tcp;

        list_for_each_entry ( tcp, &tcp_conns, list ) {
                if ( tcp->local_port == local_port )
                        return tcp;
        }
        return NULL;
}

static void tcp_rx_opts	(	struct tcp_connection *	tcp,
		const void *	data,
		size_t	len,
		struct tcp_options *	options
	)			[static]

Parse TCP received options.

Parameters:

	tcp	TCP connection
	data	Raw options data
	len	Raw options length
	options	Options structure to fill in

Definition at line 636 of file tcp.c.

References DBGC, tcp_option::kind, tcp_option::length, memset(), tcp_options::mssopt, TCP_OPTION_END, TCP_OPTION_MSS, TCP_OPTION_NOP, TCP_OPTION_TS, and tcp_options::tsopt.

Referenced by tcp_rx().

                                                                    {
        const void *end = ( data + len );
        const struct tcp_option *option;
        unsigned int kind;

        memset ( options, 0, sizeof ( *options ) );
        while ( data < end ) {
                option = data;
                kind = option->kind;
                if ( kind == TCP_OPTION_END )
                        return;
                if ( kind == TCP_OPTION_NOP ) {
                        data++;
                        continue;
                }
                switch ( kind ) {
                case TCP_OPTION_MSS:
                        options->mssopt = data;
                        break;
                case TCP_OPTION_TS:
                        options->tsopt = data;
                        break;
                default:
                        DBGC ( tcp, "TCP %p received unknown option %d\n",
                               tcp, kind );
                        break;
                }
                data += option->length;
        }
}

static void tcp_rx_seq	(	struct tcp_connection *	tcp,
		uint32_t	seq_len
	)			[static]

Consume received sequence space.

Parameters:

	tcp	TCP connection
	seq_len	Sequence space length to consume

Definition at line 674 of file tcp.c.

References tcp_connection::rcv_ack, and tcp_connection::rcv_win.

Referenced by tcp_rx_data(), tcp_rx_fin(), and tcp_rx_syn().

                                                                        {
        tcp->rcv_ack += seq_len;
        if ( tcp->rcv_win > seq_len ) {
                tcp->rcv_win -= seq_len;
        } else {
                tcp->rcv_win = 0;
        }
}

static int tcp_rx_syn	(	struct tcp_connection *	tcp,
		uint32_t	seq,
		struct tcp_options *	options
	)			[static]

Handle TCP received SYN.

Parameters:

	tcp	TCP connection
	seq	SEQ value (in host-endian order)
	options	TCP options

Return values:

rc

Return status code

Definition at line 691 of file tcp.c.

References tcp_connection::rcv_ack, TCP_ACK, tcp_rx_seq(), tcp_connection::tcp_state, TCP_STATE_RCVD, TCP_STATE_SENT, TCP_SYN, tcp_connection::timestamps, and tcp_options::tsopt.

Referenced by tcp_rx().

                                                      {

        /* Synchronise sequence numbers on first SYN */
        if ( ! ( tcp->tcp_state & TCP_STATE_RCVD ( TCP_SYN ) ) ) {
                tcp->rcv_ack = seq;
                if ( options->tsopt )
                        tcp->timestamps = 1;
        }

        /* Ignore duplicate SYN */
        if ( ( tcp->rcv_ack - seq ) > 0 )
                return 0;

        /* Mark SYN as received and start sending ACKs with each packet */
        tcp->tcp_state |= ( TCP_STATE_SENT ( TCP_ACK ) |
                            TCP_STATE_RCVD ( TCP_SYN ) );

        /* Acknowledge SYN */
        tcp_rx_seq ( tcp, 1 );

        return 0;
}

static int tcp_rx_data	(	struct tcp_connection *	tcp,
		uint32_t	seq,
		struct io_buffer *	iobuf
	)			[static]

Handle TCP received data.

Parameters:

	tcp	TCP connection
	seq	SEQ value (in host-endian order)
	iobuf	I/O buffer

Return values:

rc

Return status code

This function takes ownership of the I/O buffer.

Definition at line 796 of file tcp.c.

References DBGC, free_iob(), iob_len(), iob_pull, tcp_connection::rcv_ack, strerror(), tcp_rx_seq(), tcp_connection::xfer, and xfer_deliver_iob().

Referenced by tcp_rx().

                                                   {
        uint32_t already_rcvd;
        uint32_t len;
        int rc;

        /* Ignore duplicate or out-of-order data */
        already_rcvd = ( tcp->rcv_ack - seq );
        len = iob_len ( iobuf );
        if ( already_rcvd >= len ) {
                free_iob ( iobuf );
                return 0;
        }
        iob_pull ( iobuf, already_rcvd );
        len -= already_rcvd;

        /* Deliver data to application */
        if ( ( rc = xfer_deliver_iob ( &tcp->xfer, iobuf ) ) != 0 ) {
                DBGC ( tcp, "TCP %p could not deliver %08x..%08x: %s\n",
                       tcp, seq, ( seq + len ), strerror ( rc ) );
                return rc;
        }

        /* Acknowledge new data */
        tcp_rx_seq ( tcp, len );

        return 0;
}

static int tcp_rx_fin	(	struct tcp_connection *	tcp,
		uint32_t	seq
	)			[static]

Handle TCP received FIN.

Parameters:

	tcp	TCP connection
	seq	SEQ value (in host-endian order)

Return values:

rc

Return status code

Definition at line 832 of file tcp.c.

References tcp_connection::rcv_ack, tcp_close(), TCP_FIN, tcp_rx_seq(), tcp_connection::tcp_state, and TCP_STATE_RCVD.

Referenced by tcp_rx().

                                                                   {

        /* Ignore duplicate or out-of-order FIN */
        if ( ( tcp->rcv_ack - seq ) > 0 )
                return 0;

        /* Mark FIN as received and acknowledge it */
        tcp->tcp_state |= TCP_STATE_RCVD ( TCP_FIN );
        tcp_rx_seq ( tcp, 1 );

        /* Close connection */
        tcp_close ( tcp, 0 );

        return 0;
}

static int tcp_rx_rst	(	struct tcp_connection *	tcp,
		uint32_t	seq
	)			[static]

Handle TCP received RST.

Parameters:

	tcp	TCP connection
	seq	SEQ value (in host-endian order)

Return values:

rc

Return status code

Definition at line 855 of file tcp.c.

References DBGC, ECONNRESET, tcp_connection::rcv_ack, tcp_connection::rcv_win, tcp_close(), TCP_CLOSED, tcp_dump_state(), tcp_connection::tcp_state, TCP_STATE_ACKED, TCP_STATE_RCVD, and TCP_SYN.

Referenced by tcp_rx().

                                                                   {

        /* Accept RST only if it falls within the window.  If we have
         * not yet received a SYN, then we have no window to test
         * against, so fall back to checking that our SYN has been
         * ACKed.
         */
        if ( tcp->tcp_state & TCP_STATE_RCVD ( TCP_SYN ) ) {
                if ( ( seq - tcp->rcv_ack ) >= tcp->rcv_win )
                        return 0;
        } else {
                if ( ! ( tcp->tcp_state & TCP_STATE_ACKED ( TCP_SYN ) ) )
                        return 0;
        }

        /* Abort connection */
        tcp->tcp_state = TCP_CLOSED;
        tcp_dump_state ( tcp );
        tcp_close ( tcp, -ECONNRESET );

        DBGC ( tcp, "TCP %p connection reset by peer\n", tcp );
        return -ECONNRESET;
}

static int tcp_rx	(	struct io_buffer *	iobuf,
		struct sockaddr_tcpip *	st_src,
		struct sockaddr_tcpip *st_dest	__unused,
		uint16_t	pshdr_csum
	)			[static]

Process received packet.

Parameters:

	iobuf	I/O buffer
	st_src	Partially-filled source address
	st_dest	Partially-filled destination address
	pshdr_csum	Pseudo-header checksum

Return values:

rc

Return status code

Definition at line 888 of file tcp.c.

References tcp_header::ack, io_buffer::data, DBG, DBGC2, tcp_header::dest, EINVAL, ENOTCONN, tcp_header::flags, free_iob(), tcp_header::hlen, iob_len(), iob_pull, ntohl, ntohs, tcp_connection::rcv_ack, tcp_connection::rcv_win, tcp_header::seq, start_timer(), TCP_ACK, TCP_CLOSED_GRACEFULLY, tcp_demux(), tcp_dump_flags(), tcp_dump_state(), TCP_FIN, TCP_MASK_HLEN, TCP_MSL, TCP_RST, tcp_rx_ack(), tcp_rx_data(), tcp_rx_fin(), tcp_rx_opts(), tcp_rx_rst(), tcp_rx_syn(), tcp_connection::tcp_state, TCP_SYN, tcp_xmit(), tcp_xmit_reset(), tcpip_continue_chksum(), retry_timer::timeout, tcp_connection::timer, tcp_connection::ts_recent, tcp_options::tsopt, tcp_timestamp_option::tsval, and tcp_header::win.

                                          {
        struct tcp_header *tcphdr = iobuf->data;
        struct tcp_connection *tcp;
        struct tcp_options options;
        size_t hlen;
        uint16_t csum;
        uint32_t start_seq;
        uint32_t seq;
        uint32_t ack;
        uint32_t win;
        unsigned int flags;
        size_t len;
        int rc;

        /* Sanity check packet */
        if ( iob_len ( iobuf ) < sizeof ( *tcphdr ) ) {
                DBG ( "TCP packet too short at %zd bytes (min %zd bytes)\n",
                      iob_len ( iobuf ), sizeof ( *tcphdr ) );
                rc = -EINVAL;
                goto discard;
        }
        hlen = ( ( tcphdr->hlen & TCP_MASK_HLEN ) / 16 ) * 4;
        if ( hlen < sizeof ( *tcphdr ) ) {
                DBG ( "TCP header too short at %zd bytes (min %zd bytes)\n",
                      hlen, sizeof ( *tcphdr ) );
                rc = -EINVAL;
                goto discard;
        }
        if ( hlen > iob_len ( iobuf ) ) {
                DBG ( "TCP header too long at %zd bytes (max %zd bytes)\n",
                      hlen, iob_len ( iobuf ) );
                rc = -EINVAL;
                goto discard;
        }
        csum = tcpip_continue_chksum ( pshdr_csum, iobuf->data,
                                       iob_len ( iobuf ) );
        if ( csum != 0 ) {
                DBG ( "TCP checksum incorrect (is %04x including checksum "
                      "field, should be 0000)\n", csum );
                rc = -EINVAL;
                goto discard;
        }
        
        /* Parse parameters from header and strip header */
        tcp = tcp_demux ( tcphdr->dest );
        start_seq = seq = ntohl ( tcphdr->seq );
        ack = ntohl ( tcphdr->ack );
        win = ntohs ( tcphdr->win );
        flags = tcphdr->flags;
        tcp_rx_opts ( tcp, ( ( ( void * ) tcphdr ) + sizeof ( *tcphdr ) ),
                      ( hlen - sizeof ( *tcphdr ) ), &options );
        iob_pull ( iobuf, hlen );
        len = iob_len ( iobuf );

        /* Dump header */
        DBGC2 ( tcp, "TCP %p RX %d<-%d           %08x %08x..%08zx %4zd",
                tcp, ntohs ( tcphdr->dest ), ntohs ( tcphdr->src ),
                ntohl ( tcphdr->ack ), ntohl ( tcphdr->seq ),
                ( ntohl ( tcphdr->seq ) + len +
                  ( ( tcphdr->flags & ( TCP_SYN | TCP_FIN ) ) ? 1 : 0 )), len);
        tcp_dump_flags ( tcp, tcphdr->flags );
        DBGC2 ( tcp, "\n" );

        /* If no connection was found, send RST */
        if ( ! tcp ) {
                tcp_xmit_reset ( tcp, st_src, tcphdr );
                rc = -ENOTCONN;
                goto discard;
        }

        /* Handle ACK, if present */
        if ( flags & TCP_ACK ) {
                if ( ( rc = tcp_rx_ack ( tcp, ack, win ) ) != 0 ) {
                        tcp_xmit_reset ( tcp, st_src, tcphdr );
                        goto discard;
                }
        }

        /* Handle SYN, if present */
        if ( flags & TCP_SYN ) {
                tcp_rx_syn ( tcp, seq, &options );
                seq++;
        }

        /* Handle RST, if present */
        if ( flags & TCP_RST ) {
                if ( ( rc = tcp_rx_rst ( tcp, seq ) ) != 0 )
                        goto discard;
        }

        /* Handle new data, if any */
        tcp_rx_data ( tcp, seq, iobuf );
        seq += len;

        /* Handle FIN, if present */
        if ( flags & TCP_FIN ) {
                tcp_rx_fin ( tcp, seq );
                seq++;
        }

        /* Update timestamp, if present and applicable */
        if ( ( seq == tcp->rcv_ack ) && options.tsopt )
                tcp->ts_recent = ntohl ( options.tsopt->tsval );

        /* Dump out any state change as a result of the received packet */
        tcp_dump_state ( tcp );

        /* Send out any pending data.  We force sending a reply if either
         *
         *  a) the peer is expecting an ACK (i.e. consumed sequence space), or
         *  b) either end of the packet was outside the receive window
         *
         * Case (b) enables us to support TCP keepalives using
         * zero-length packets, which we would otherwise ignore.  Note
         * that for case (b), we need *only* consider zero-length
         * packets, since non-zero-length packets will already be
         * caught by case (a).
         */
        tcp_xmit ( tcp, ( ( start_seq != seq ) ||
                          ( ( seq - tcp->rcv_ack ) > tcp->rcv_win ) ) );

        /* If this packet was the last we expect to receive, set up
         * timer to expire and cause the connection to be freed.
         */
        if ( TCP_CLOSED_GRACEFULLY ( tcp->tcp_state ) ) {
                tcp->timer.timeout = ( 2 * TCP_MSL );
                start_timer ( &tcp->timer );
        }

        return 0;

 discard:
        /* Free received packet */
        free_iob ( iobuf );
        return rc;
}

static void tcp_xfer_close	(	struct xfer_interface *	xfer,
		int	rc
	)			[static]

Close interface.

Parameters:

	xfer	Data transfer interface
	rc	Reason for close

Definition at line 1048 of file tcp.c.

References container_of, tcp_close(), and tcp_xmit().

                                                                   {
        struct tcp_connection *tcp =
                container_of ( xfer, struct tcp_connection, xfer );

        /* Close data transfer interface */
        tcp_close ( tcp, rc );

        /* Transmit FIN, if possible */
        tcp_xmit ( tcp, 0 );
}

static size_t tcp_xfer_window

(

struct xfer_interface *

xfer

)

[static]

Check flow control window.

Parameters:

xfer

Data transfer interface

Return values:

len

Length of window

Definition at line 1065 of file tcp.c.

References container_of, list_empty(), tcp_connection::queue, and tcp_xmit_win().

                                                              {
        struct tcp_connection *tcp =
                container_of ( xfer, struct tcp_connection, xfer );

        /* Not ready if data queue is non-empty.  This imposes a limit
         * of only one unACKed packet in the TX queue at any time; we
         * do this to conserve memory usage.
         */
        if ( ! list_empty ( &tcp->queue ) )
                return 0;

        /* Return TCP window length */
        return tcp_xmit_win ( tcp );
}

static int tcp_xfer_deliver_iob	(	struct xfer_interface *	xfer,
		struct io_buffer *	iobuf,
		struct xfer_metadata *meta	__unused
	)			[static]

Deliver datagram as I/O buffer.

Parameters:

	xfer	Data transfer interface
	iobuf	Datagram I/O buffer
	meta	Data transfer metadata

Return values:

rc

Return status code

Definition at line 1088 of file tcp.c.

References container_of, io_buffer::list, list_add_tail, tcp_connection::queue, and tcp_xmit().

                                                                        {
        struct tcp_connection *tcp =
                container_of ( xfer, struct tcp_connection, xfer );

        /* Enqueue packet */
        list_add_tail ( &iobuf->list, &tcp->queue );

        /* Transmit data, if possible */
        tcp_xmit ( tcp, 0 );

        return 0;
}

static int tcp_open_uri	(	struct xfer_interface *	xfer,
		struct uri *	uri
	)			[static]

Open TCP URI.

Parameters:

	xfer	Data transfer interface
	uri	URI

Return values:

rc

Return status code

Definition at line 1137 of file tcp.c.

References EINVAL, uri::host, htons, memset(), NULL, SOCK_STREAM, sockaddr_tcpip::st_port, uri_port(), and xfer_open_named_socket().

                                                                         {
        struct sockaddr_tcpip peer;

        /* Sanity check */
        if ( ! uri->host )
                return -EINVAL;

        memset ( &peer, 0, sizeof ( peer ) );
        peer.st_port = htons ( uri_port ( uri, 0 ) );
        return xfer_open_named_socket ( xfer, SOCK_STREAM,
                                        ( struct sockaddr * ) &peer,
                                        uri->host, NULL );
}

---

Variable Documentation

static struct xfer_interface_operations tcp_xfer_operations [static, read]

Initial value:

 {
        .close          = tcp_xfer_close,
        .vredirect      = ignore_xfer_vredirect,
        .window         = tcp_xfer_window,
        .alloc_iob      = default_xfer_alloc_iob,
        .deliver_iob    = tcp_xfer_deliver_iob,
        .deliver_raw    = xfer_deliver_as_iob,
}

TCP data transfer interface operations.

Definition at line 95 of file tcp.c.

Referenced by tcp_open().

struct tcpip_protocol tcp_protocol __tcpip_protocol

Initial value:

 {
        .name = "TCP",
        .rx = tcp_rx,
        .tcpip_proto = IP_TCP,
}

TCP protocol.

Definition at line 1029 of file tcp.c.

struct socket_opener tcp_socket_opener __socket_opener

Initial value:

 {
        .semantics      = TCP_SOCK_STREAM,
        .family         = AF_INET,
        .open           = tcp_open,
}

TCP socket opener.

Definition at line 1121 of file tcp.c.

struct uri_opener tcp_uri_opener __uri_opener

Initial value:

 {
        .scheme         = "tcp",
        .open           = tcp_open_uri,
}

TCP URI opener.

Definition at line 1152 of file tcp.c.