Context Navigation

source: bootcd/isolinux/syslinux-6.03/gpxe/src/net/tcp.c

Last change on this file was e16e8f2, checked in by Edwin Eefting <edwin@datux.nl>, 3 years ago
bootstuff
Property mode set to `100644`
File size: 29.8 KB

Rev	Line
[e16e8f2]	1	#include <string.h>
	2	#include <stdlib.h>
	3	#include <stdio.h>
	4	#include <assert.h>
	5	#include <errno.h>
	6	#include <byteswap.h>
	7	#include <gpxe/timer.h>
	8	#include <gpxe/iobuf.h>
	9	#include <gpxe/malloc.h>
	10	#include <gpxe/retry.h>
	11	#include <gpxe/refcnt.h>
	12	#include <gpxe/xfer.h>
	13	#include <gpxe/open.h>
	14	#include <gpxe/uri.h>
	15	#include <gpxe/tcpip.h>
	16	#include <gpxe/tcp.h>
	17
	18	/** @file
	19	*
	20	* TCP protocol
	21	*
	22	*/
	23
	24	FILE_LICENCE ( GPL2_OR_LATER );
	25
	26	/** A TCP connection */
	27	struct tcp_connection {
	28	/** Reference counter */
	29	struct refcnt refcnt;
	30	/** List of TCP connections */
	31	struct list_head list;
	32
	33	/** Data transfer interface */
	34	struct xfer_interface xfer;
	35	/** Data transfer interface closed flag */
	36	int xfer_closed;
	37
	38	/** Remote socket address */
	39	struct sockaddr_tcpip peer;
	40	/** Local port, in network byte order */
	41	unsigned int local_port;
	42
	43	/** Current TCP state */
	44	unsigned int tcp_state;
	45	/** Previous TCP state
	46	*
	47	* Maintained only for debug messages
	48	*/
	49	unsigned int prev_tcp_state;
	50	/** Current sequence number
	51	*
	52	* Equivalent to SND.UNA in RFC 793 terminology.
	53	*/
	54	uint32_t snd_seq;
	55	/** Unacknowledged sequence count
	56	*
	57	* Equivalent to (SND.NXT-SND.UNA) in RFC 793 terminology.
	58	*/
	59	uint32_t snd_sent;
	60	/** Send window
	61	*
	62	* Equivalent to SND.WND in RFC 793 terminology
	63	*/
	64	uint32_t snd_win;
	65	/** Current acknowledgement number
	66	*
	67	* Equivalent to RCV.NXT in RFC 793 terminology.
	68	*/
	69	uint32_t rcv_ack;
	70	/** Receive window
	71	*
	72	* Equivalent to RCV.WND in RFC 793 terminology.
	73	*/
	74	uint32_t rcv_win;
	75	/** Most recent received timestamp
	76	*
	77	* Equivalent to TS.Recent in RFC 1323 terminology.
	78	*/
	79	uint32_t ts_recent;
	80	/** Timestamps enabled */
	81	int timestamps;
	82
	83	/** Transmit queue */
	84	struct list_head queue;
	85	/** Retransmission timer */
	86	struct retry_timer timer;
	87	};
	88
	89	/**
	90	* List of registered TCP connections
	91	*/
	92	static LIST_HEAD ( tcp_conns );
	93
	94	/* Forward declarations */
	95	static struct xfer_interface_operations tcp_xfer_operations;
	96	static void tcp_expired ( struct retry_timer *timer, int over );
	97	static int tcp_rx_ack ( struct tcp_connection *tcp, uint32_t ack,
	98	uint32_t win );
	99
	100	/**
	101	* Name TCP state
	102	*
	103	* @v state TCP state
	104	* @ret name Name of TCP state
	105	*/
	106	static inline __attribute__ (( always_inline )) const char *
	107	tcp_state ( int state ) {
	108	switch ( state ) {
	109	case TCP_CLOSED: return "CLOSED";
	110	case TCP_LISTEN: return "LISTEN";
	111	case TCP_SYN_SENT: return "SYN_SENT";
	112	case TCP_SYN_RCVD: return "SYN_RCVD";
	113	case TCP_ESTABLISHED: return "ESTABLISHED";
	114	case TCP_FIN_WAIT_1: return "FIN_WAIT_1";
	115	case TCP_FIN_WAIT_2: return "FIN_WAIT_2";
	116	case TCP_CLOSING_OR_LAST_ACK: return "CLOSING/LAST_ACK";
	117	case TCP_TIME_WAIT: return "TIME_WAIT";
	118	case TCP_CLOSE_WAIT: return "CLOSE_WAIT";
	119	default: return "INVALID";
	120	}
	121	}
	122
	123	/**
	124	* Dump TCP state transition
	125	*
	126	* @v tcp TCP connection
	127	*/
	128	static inline __attribute__ (( always_inline )) void
	129	tcp_dump_state ( struct tcp_connection *tcp ) {
	130
	131	if ( tcp->tcp_state != tcp->prev_tcp_state ) {
	132	DBGC ( tcp, "TCP %p transitioned from %s to %s\n", tcp,
	133	tcp_state ( tcp->prev_tcp_state ),
	134	tcp_state ( tcp->tcp_state ) );
	135	}
	136	tcp->prev_tcp_state = tcp->tcp_state;
	137	}
	138
	139	/**
	140	* Dump TCP flags
	141	*
	142	* @v flags TCP flags
	143	*/
	144	static inline __attribute__ (( always_inline )) void
	145	tcp_dump_flags ( struct tcp_connection *tcp, unsigned int flags ) {
	146	if ( flags & TCP_RST )
	147	DBGC2 ( tcp, " RST" );
	148	if ( flags & TCP_SYN )
	149	DBGC2 ( tcp, " SYN" );
	150	if ( flags & TCP_PSH )
	151	DBGC2 ( tcp, " PSH" );
	152	if ( flags & TCP_FIN )
	153	DBGC2 ( tcp, " FIN" );
	154	if ( flags & TCP_ACK )
	155	DBGC2 ( tcp, " ACK" );
	156	}
	157
	158	/***************************************************************************
	159	*
	160	* Open and close
	161	*
	162	***************************************************************************
	163	*/
	164
	165	/**
	166	* Bind TCP connection to local port
	167	*
	168	* @v tcp TCP connection
	169	* @v port Local port number, in network-endian order
	170	* @ret rc Return status code
	171	*
	172	* If the port is 0, the connection is assigned an available port
	173	* between 1024 and 65535.
	174	*/
	175	static int tcp_bind ( struct tcp_connection *tcp, unsigned int port ) {
	176	struct tcp_connection *existing;
	177	static uint16_t try_port = 1023;
	178
	179	/* If no port specified, find the first available port */
	180	if ( ! port ) {
	181	while ( try_port ) {
	182	try_port++;
	183	if ( try_port < 1024 )
	184	continue;
	185	if ( tcp_bind ( tcp, htons ( try_port ) ) == 0 )
	186	return 0;
	187	}
	188	DBGC ( tcp, "TCP %p could not bind: no free ports\n", tcp );
	189	return -EADDRINUSE;
	190	}
	191
	192	/* Attempt bind to local port */
	193	list_for_each_entry ( existing, &tcp_conns, list ) {
	194	if ( existing->local_port == port ) {
	195	DBGC ( tcp, "TCP %p could not bind: port %d in use\n",
	196	tcp, ntohs ( port ) );
	197	return -EADDRINUSE;
	198	}
	199	}
	200	tcp->local_port = port;
	201
	202	DBGC ( tcp, "TCP %p bound to port %d\n", tcp, ntohs ( port ) );
	203	return 0;
	204	}
	205
	206	/**
	207	* Open a TCP connection
	208	*
	209	* @v xfer Data transfer interface
	210	* @v peer Peer socket address
	211	* @v local Local socket address, or NULL
	212	* @ret rc Return status code
	213	*/
	214	static int tcp_open ( struct xfer_interface xfer, struct sockaddr peer,
	215	struct sockaddr *local ) {
	216	struct sockaddr_tcpip st_peer = ( struct sockaddr_tcpip ) peer;
	217	struct sockaddr_tcpip st_local = ( struct sockaddr_tcpip ) local;
	218	struct tcp_connection *tcp;
	219	unsigned int bind_port;
	220	int rc;
	221
	222	/* Allocate and initialise structure */
	223	tcp = zalloc ( sizeof ( *tcp ) );
	224	if ( ! tcp )
	225	return -ENOMEM;
	226	DBGC ( tcp, "TCP %p allocated\n", tcp );
	227	xfer_init ( &tcp->xfer, &tcp_xfer_operations, &tcp->refcnt );
	228	tcp->prev_tcp_state = TCP_CLOSED;
	229	tcp->tcp_state = TCP_STATE_SENT ( TCP_SYN );
	230	tcp_dump_state ( tcp );
	231	tcp->snd_seq = random();
	232	INIT_LIST_HEAD ( &tcp->queue );
	233	tcp->timer.expired = tcp_expired;
	234	memcpy ( &tcp->peer, st_peer, sizeof ( tcp->peer ) );
	235
	236	/* Bind to local port */
	237	bind_port = ( st_local ? st_local->st_port : 0 );
	238	if ( ( rc = tcp_bind ( tcp, bind_port ) ) != 0 )
	239	goto err;
	240
	241	/* Start timer to initiate SYN */
	242	start_timer_nodelay ( &tcp->timer );
	243
	244	/* Attach parent interface, transfer reference to connection
	245	* list and return
	246	*/
	247	xfer_plug_plug ( &tcp->xfer, xfer );
	248	list_add ( &tcp->list, &tcp_conns );
	249	return 0;
	250
	251	err:
	252	ref_put ( &tcp->refcnt );
	253	return rc;
	254	}
	255
	256	/**
	257	* Close TCP connection
	258	*
	259	* @v tcp TCP connection
	260	* @v rc Reason for close
	261	*
	262	* Closes the data transfer interface. If the TCP state machine is in
	263	* a suitable state, the connection will be deleted.
	264	*/
	265	static void tcp_close ( struct tcp_connection *tcp, int rc ) {
	266	struct io_buffer *iobuf;
	267	struct io_buffer *tmp;
	268
	269	/* Close data transfer interface */
	270	xfer_nullify ( &tcp->xfer );
	271	xfer_close ( &tcp->xfer, rc );
	272	tcp->xfer_closed = 1;
	273
	274	/* If we are in CLOSED, or have otherwise not yet received a
	275	* SYN (i.e. we are in LISTEN or SYN_SENT), just delete the
	276	* connection.
	277	*/
	278	if ( ! ( tcp->tcp_state & TCP_STATE_RCVD ( TCP_SYN ) ) ) {
	279
	280	/* Transition to CLOSED for the sake of debugging messages */
	281	tcp->tcp_state = TCP_CLOSED;
	282	tcp_dump_state ( tcp );
	283
	284	/* Free any unsent I/O buffers */
	285	list_for_each_entry_safe ( iobuf, tmp, &tcp->queue, list ) {
	286	list_del ( &iobuf->list );
	287	free_iob ( iobuf );
	288	}
	289
	290	/* Remove from list and drop reference */
	291	stop_timer ( &tcp->timer );
	292	list_del ( &tcp->list );
	293	ref_put ( &tcp->refcnt );
	294	DBGC ( tcp, "TCP %p connection deleted\n", tcp );
	295	return;
	296	}
	297
	298	/* If we have not had our SYN acknowledged (i.e. we are in
	299	* SYN_RCVD), pretend that it has been acknowledged so that we
	300	* can send a FIN without breaking things.
	301	*/
	302	if ( ! ( tcp->tcp_state & TCP_STATE_ACKED ( TCP_SYN ) ) )
	303	tcp_rx_ack ( tcp, ( tcp->snd_seq + 1 ), 0 );
	304
	305	/* If we have no data remaining to send, start sending FIN */
	306	if ( list_empty ( &tcp->queue ) ) {
	307	tcp->tcp_state \|= TCP_STATE_SENT ( TCP_FIN );
	308	tcp_dump_state ( tcp );
	309	}
	310	}
	311
	312	/***************************************************************************
	313	*
	314	* Transmit data path
	315	*
	316	***************************************************************************
	317	*/
	318
	319	/**
	320	* Calculate transmission window
	321	*
	322	* @v tcp TCP connection
	323	* @ret len Maximum length that can be sent in a single packet
	324	*/
	325	static size_t tcp_xmit_win ( struct tcp_connection *tcp ) {
	326	size_t len;
	327
	328	/* Not ready if we're not in a suitable connection state */
	329	if ( ! TCP_CAN_SEND_DATA ( tcp->tcp_state ) )
	330	return 0;
	331
	332	/* Length is the minimum of the receiver's window and the path MTU */
	333	len = tcp->snd_win;
	334	if ( len > TCP_PATH_MTU )
	335	len = TCP_PATH_MTU;
	336
	337	return len;
	338	}
	339
	340	/**
	341	* Process TCP transmit queue
	342	*
	343	* @v tcp TCP connection
	344	* @v max_len Maximum length to process
	345	* @v dest I/O buffer to fill with data, or NULL
	346	* @v remove Remove data from queue
	347	* @ret len Length of data processed
	348	*
	349	* This processes at most @c max_len bytes from the TCP connection's
	350	* transmit queue. Data will be copied into the @c dest I/O buffer
	351	* (if provided) and, if @c remove is true, removed from the transmit
	352	* queue.
	353	*/
	354	static size_t tcp_process_queue ( struct tcp_connection *tcp, size_t max_len,
	355	struct io_buffer *dest, int remove ) {
	356	struct io_buffer *iobuf;
	357	struct io_buffer *tmp;
	358	size_t frag_len;
	359	size_t len = 0;
	360
	361	list_for_each_entry_safe ( iobuf, tmp, &tcp->queue, list ) {
	362	frag_len = iob_len ( iobuf );
	363	if ( frag_len > max_len )
	364	frag_len = max_len;
	365	if ( dest ) {
	366	memcpy ( iob_put ( dest, frag_len ), iobuf->data,
	367	frag_len );
	368	}
	369	if ( remove ) {
	370	iob_pull ( iobuf, frag_len );
	371	if ( ! iob_len ( iobuf ) ) {
	372	list_del ( &iobuf->list );
	373	free_iob ( iobuf );
	374	}
	375	}
	376	len += frag_len;
	377	max_len -= frag_len;
	378	}
	379	return len;
	380	}
	381
	382	/**
	383	* Transmit any outstanding data
	384	*
	385	* @v tcp TCP connection
	386	* @v force_send Force sending of packet
	387	*
	388	* Transmits any outstanding data on the connection.
	389	*
	390	* Note that even if an error is returned, the retransmission timer
	391	* will have been started if necessary, and so the stack will
	392	* eventually attempt to retransmit the failed packet.
	393	*/
	394	static int tcp_xmit ( struct tcp_connection *tcp, int force_send ) {
	395	struct io_buffer *iobuf;
	396	struct tcp_header *tcphdr;
	397	struct tcp_mss_option *mssopt;
	398	struct tcp_timestamp_padded_option *tsopt;
	399	void *payload;
	400	unsigned int flags;
	401	size_t len = 0;
	402	uint32_t seq_len;
	403	uint32_t app_win;
	404	uint32_t max_rcv_win;
	405	int rc;
	406
	407	/* If retransmission timer is already running, do nothing */
	408	if ( timer_running ( &tcp->timer ) )
	409	return 0;
	410
	411	/* Calculate both the actual (payload) and sequence space
	412	* lengths that we wish to transmit.
	413	*/
	414	if ( TCP_CAN_SEND_DATA ( tcp->tcp_state ) ) {
	415	len = tcp_process_queue ( tcp, tcp_xmit_win ( tcp ),
	416	NULL, 0 );
	417	}
	418	seq_len = len;
	419	flags = TCP_FLAGS_SENDING ( tcp->tcp_state );
	420	if ( flags & ( TCP_SYN \| TCP_FIN ) ) {
	421	/* SYN or FIN consume one byte, and we can never send both */
	422	assert ( ! ( ( flags & TCP_SYN ) && ( flags & TCP_FIN ) ) );
	423	seq_len++;
	424	}
	425	tcp->snd_sent = seq_len;
	426
	427	/* If we have nothing to transmit, stop now */
	428	if ( ( seq_len == 0 ) && ! force_send )
	429	return 0;
	430
	431	/* If we are transmitting anything that requires
	432	* acknowledgement (i.e. consumes sequence space), start the
	433	* retransmission timer. Do this before attempting to
	434	* allocate the I/O buffer, in case allocation itself fails.
	435	*/
	436	if ( seq_len )
	437	start_timer ( &tcp->timer );
	438
	439	/* Allocate I/O buffer */
	440	iobuf = alloc_iob ( len + MAX_HDR_LEN );
	441	if ( ! iobuf ) {
	442	DBGC ( tcp, "TCP %p could not allocate iobuf for %08x..%08x "
	443	"%08x\n", tcp, tcp->snd_seq, ( tcp->snd_seq + seq_len ),
	444	tcp->rcv_ack );
	445	return -ENOMEM;
	446	}
	447	iob_reserve ( iobuf, MAX_HDR_LEN );
	448
	449	/* Fill data payload from transmit queue */
	450	tcp_process_queue ( tcp, len, iobuf, 0 );
	451
	452	/* Expand receive window if possible */
	453	max_rcv_win = ( ( freemem * 3 ) / 4 );
	454	if ( max_rcv_win > TCP_MAX_WINDOW_SIZE )
	455	max_rcv_win = TCP_MAX_WINDOW_SIZE;
	456	app_win = xfer_window ( &tcp->xfer );
	457	if ( max_rcv_win > app_win )
	458	max_rcv_win = app_win;
	459	max_rcv_win &= ~0x03; /* Keep everything dword-aligned */
	460	if ( tcp->rcv_win < max_rcv_win )
	461	tcp->rcv_win = max_rcv_win;
	462
	463	/* Fill up the TCP header */
	464	payload = iobuf->data;
	465	if ( flags & TCP_SYN ) {
	466	mssopt = iob_push ( iobuf, sizeof ( *mssopt ) );
	467	mssopt->kind = TCP_OPTION_MSS;
	468	mssopt->length = sizeof ( *mssopt );
	469	mssopt->mss = htons ( TCP_MSS );
	470	}
	471	if ( ( flags & TCP_SYN ) \|\| tcp->timestamps ) {
	472	tsopt = iob_push ( iobuf, sizeof ( *tsopt ) );
	473	memset ( tsopt->nop, TCP_OPTION_NOP, sizeof ( tsopt->nop ) );
	474	tsopt->tsopt.kind = TCP_OPTION_TS;
	475	tsopt->tsopt.length = sizeof ( tsopt->tsopt );
	476	tsopt->tsopt.tsval = ntohl ( currticks() );
	477	tsopt->tsopt.tsecr = ntohl ( tcp->ts_recent );
	478	}
	479	if ( ! ( flags & TCP_SYN ) )
	480	flags \|= TCP_PSH;
	481	tcphdr = iob_push ( iobuf, sizeof ( *tcphdr ) );
	482	memset ( tcphdr, 0, sizeof ( *tcphdr ) );
	483	tcphdr->src = tcp->local_port;
	484	tcphdr->dest = tcp->peer.st_port;
	485	tcphdr->seq = htonl ( tcp->snd_seq );
	486	tcphdr->ack = htonl ( tcp->rcv_ack );
	487	tcphdr->hlen = ( ( payload - iobuf->data ) << 2 );
	488	tcphdr->flags = flags;
	489	tcphdr->win = htons ( tcp->rcv_win );
	490	tcphdr->csum = tcpip_chksum ( iobuf->data, iob_len ( iobuf ) );
	491
	492	/* Dump header */
	493	DBGC2 ( tcp, "TCP %p TX %d->%d %08x..%08x %08x %4zd",
	494	tcp, ntohs ( tcphdr->src ), ntohs ( tcphdr->dest ),
	495	ntohl ( tcphdr->seq ), ( ntohl ( tcphdr->seq ) + seq_len ),
	496	ntohl ( tcphdr->ack ), len );
	497	tcp_dump_flags ( tcp, tcphdr->flags );
	498	DBGC2 ( tcp, "\n" );
	499
	500	/* Transmit packet */
	501	if ( ( rc = tcpip_tx ( iobuf, &tcp_protocol, NULL, &tcp->peer, NULL,
	502	&tcphdr->csum ) ) != 0 ) {
	503	DBGC ( tcp, "TCP %p could not transmit %08x..%08x %08x: %s\n",
	504	tcp, tcp->snd_seq, ( tcp->snd_seq + tcp->snd_sent ),
	505	tcp->rcv_ack, strerror ( rc ) );
	506	return rc;
	507	}
	508
	509	return 0;
	510	}
	511
	512	/**
	513	* Retransmission timer expired
	514	*
	515	* @v timer Retry timer
	516	* @v over Failure indicator
	517	*/
	518	static void tcp_expired ( struct retry_timer *timer, int over ) {
	519	struct tcp_connection *tcp =
	520	container_of ( timer, struct tcp_connection, timer );
	521	int graceful_close = TCP_CLOSED_GRACEFULLY ( tcp->tcp_state );
	522
	523	DBGC ( tcp, "TCP %p timer %s in %s for %08x..%08x %08x\n", tcp,
	524	( over ? "expired" : "fired" ), tcp_state ( tcp->tcp_state ),
	525	tcp->snd_seq, ( tcp->snd_seq + tcp->snd_sent ), tcp->rcv_ack );
	526
	527	assert ( ( tcp->tcp_state == TCP_SYN_SENT ) \|\|
	528	( tcp->tcp_state == TCP_SYN_RCVD ) \|\|
	529	( tcp->tcp_state == TCP_ESTABLISHED ) \|\|
	530	( tcp->tcp_state == TCP_FIN_WAIT_1 ) \|\|
	531	( tcp->tcp_state == TCP_TIME_WAIT ) \|\|
	532	( tcp->tcp_state == TCP_CLOSE_WAIT ) \|\|
	533	( tcp->tcp_state == TCP_CLOSING_OR_LAST_ACK ) );
	534
	535	if ( over \|\| graceful_close ) {
	536	/* If we have finally timed out and given up, or if
	537	* this is the result of a graceful close, terminate
	538	* the connection
	539	*/
	540	tcp->tcp_state = TCP_CLOSED;
	541	tcp_dump_state ( tcp );
	542	tcp_close ( tcp, -ETIMEDOUT );
	543	} else {
	544	/* Otherwise, retransmit the packet */
	545	tcp_xmit ( tcp, 0 );
	546	}
	547	}
	548
	549	/**
	550	* Send RST response to incoming packet
	551	*
	552	* @v in_tcphdr TCP header of incoming packet
	553	* @ret rc Return status code
	554	*/
	555	static int tcp_xmit_reset ( struct tcp_connection *tcp,
	556	struct sockaddr_tcpip *st_dest,
	557	struct tcp_header *in_tcphdr ) {
	558	struct io_buffer *iobuf;
	559	struct tcp_header *tcphdr;
	560	int rc;
	561
	562	/* Allocate space for dataless TX buffer */
	563	iobuf = alloc_iob ( MAX_HDR_LEN );
	564	if ( ! iobuf ) {
	565	DBGC ( tcp, "TCP %p could not allocate iobuf for RST "
	566	"%08x..%08x %08x\n", tcp, ntohl ( in_tcphdr->ack ),
	567	ntohl ( in_tcphdr->ack ), ntohl ( in_tcphdr->seq ) );
	568	return -ENOMEM;
	569	}
	570	iob_reserve ( iobuf, MAX_HDR_LEN );
	571
	572	/* Construct RST response */
	573	tcphdr = iob_push ( iobuf, sizeof ( *tcphdr ) );
	574	memset ( tcphdr, 0, sizeof ( *tcphdr ) );
	575	tcphdr->src = in_tcphdr->dest;
	576	tcphdr->dest = in_tcphdr->src;
	577	tcphdr->seq = in_tcphdr->ack;
	578	tcphdr->ack = in_tcphdr->seq;
	579	tcphdr->hlen = ( ( sizeof ( *tcphdr ) / 4 ) << 4 );
	580	tcphdr->flags = ( TCP_RST \| TCP_ACK );
	581	tcphdr->win = htons ( TCP_MAX_WINDOW_SIZE );
	582	tcphdr->csum = tcpip_chksum ( iobuf->data, iob_len ( iobuf ) );
	583
	584	/* Dump header */
	585	DBGC2 ( tcp, "TCP %p TX %d->%d %08x..%08x %08x %4d",
	586	tcp, ntohs ( tcphdr->src ), ntohs ( tcphdr->dest ),
	587	ntohl ( tcphdr->seq ), ( ntohl ( tcphdr->seq ) ),
	588	ntohl ( tcphdr->ack ), 0 );
	589	tcp_dump_flags ( tcp, tcphdr->flags );
	590	DBGC2 ( tcp, "\n" );
	591
	592	/* Transmit packet */
	593	if ( ( rc = tcpip_tx ( iobuf, &tcp_protocol, NULL, st_dest,
	594	NULL, &tcphdr->csum ) ) != 0 ) {
	595	DBGC ( tcp, "TCP %p could not transmit RST %08x..%08x %08x: "
	596	"%s\n", tcp, ntohl ( in_tcphdr->ack ),
	597	ntohl ( in_tcphdr->ack ), ntohl ( in_tcphdr->seq ),
	598	strerror ( rc ) );
	599	return rc;
	600	}
	601
	602	return 0;
	603	}
	604
	605	/***************************************************************************
	606	*
	607	* Receive data path
	608	*
	609	***************************************************************************
	610	*/
	611
	612	/**
	613	* Identify TCP connection by local port number
	614	*
	615	* @v local_port Local port (in network-endian order)
	616	* @ret tcp TCP connection, or NULL
	617	*/
	618	static struct tcp_connection * tcp_demux ( unsigned int local_port ) {
	619	struct tcp_connection *tcp;
	620
	621	list_for_each_entry ( tcp, &tcp_conns, list ) {
	622	if ( tcp->local_port == local_port )
	623	return tcp;
	624	}
	625	return NULL;
	626	}
	627
	628	/**
	629	* Parse TCP received options
	630	*
	631	* @v tcp TCP connection
	632	* @v data Raw options data
	633	* @v len Raw options length
	634	* @v options Options structure to fill in
	635	*/
	636	static void tcp_rx_opts ( struct tcp_connection tcp, const void data,
	637	size_t len, struct tcp_options *options ) {
	638	const void *end = ( data + len );
	639	const struct tcp_option *option;
	640	unsigned int kind;
	641
	642	memset ( options, 0, sizeof ( *options ) );
	643	while ( data < end ) {
	644	option = data;
	645	kind = option->kind;
	646	if ( kind == TCP_OPTION_END )
	647	return;
	648	if ( kind == TCP_OPTION_NOP ) {
	649	data++;
	650	continue;
	651	}
	652	switch ( kind ) {
	653	case TCP_OPTION_MSS:
	654	options->mssopt = data;
	655	break;
	656	case TCP_OPTION_TS:
	657	options->tsopt = data;
	658	break;
	659	default:
	660	DBGC ( tcp, "TCP %p received unknown option %d\n",
	661	tcp, kind );
	662	break;
	663	}
	664	data += option->length;
	665	}
	666	}
	667
	668	/**
	669	* Consume received sequence space
	670	*
	671	* @v tcp TCP connection
	672	* @v seq_len Sequence space length to consume
	673	*/
	674	static void tcp_rx_seq ( struct tcp_connection *tcp, uint32_t seq_len ) {
	675	tcp->rcv_ack += seq_len;
	676	if ( tcp->rcv_win > seq_len ) {
	677	tcp->rcv_win -= seq_len;
	678	} else {
	679	tcp->rcv_win = 0;
	680	}
	681	}
	682
	683	/**
	684	* Handle TCP received SYN
	685	*
	686	* @v tcp TCP connection
	687	* @v seq SEQ value (in host-endian order)
	688	* @v options TCP options
	689	* @ret rc Return status code
	690	*/
	691	static int tcp_rx_syn ( struct tcp_connection *tcp, uint32_t seq,
	692	struct tcp_options *options ) {
	693
	694	/* Synchronise sequence numbers on first SYN */
	695	if ( ! ( tcp->tcp_state & TCP_STATE_RCVD ( TCP_SYN ) ) ) {
	696	tcp->rcv_ack = seq;
	697	if ( options->tsopt )
	698	tcp->timestamps = 1;
	699	}
	700
	701	/* Ignore duplicate SYN */
	702	if ( ( tcp->rcv_ack - seq ) > 0 )
	703	return 0;
	704
	705	/* Mark SYN as received and start sending ACKs with each packet */
	706	tcp->tcp_state \|= ( TCP_STATE_SENT ( TCP_ACK ) \|
	707	TCP_STATE_RCVD ( TCP_SYN ) );
	708
	709	/* Acknowledge SYN */
	710	tcp_rx_seq ( tcp, 1 );
	711
	712	return 0;
	713	}
	714
	715	/**
	716	* Handle TCP received ACK
	717	*
	718	* @v tcp TCP connection
	719	* @v ack ACK value (in host-endian order)
	720	* @v win WIN value (in host-endian order)
	721	* @ret rc Return status code
	722	*/
	723	static int tcp_rx_ack ( struct tcp_connection *tcp, uint32_t ack,
	724	uint32_t win ) {
	725	uint32_t ack_len = ( ack - tcp->snd_seq );
	726	size_t len;
	727	unsigned int acked_flags;
	728
	729	/* Check for out-of-range or old duplicate ACKs */
	730	if ( ack_len > tcp->snd_sent ) {
	731	DBGC ( tcp, "TCP %p received ACK for %08x..%08x, "
	732	"sent only %08x..%08x\n", tcp, tcp->snd_seq,
	733	( tcp->snd_seq + ack_len ), tcp->snd_seq,
	734	( tcp->snd_seq + tcp->snd_sent ) );
	735
	736	if ( TCP_HAS_BEEN_ESTABLISHED ( tcp->tcp_state ) ) {
	737	/* Just ignore what might be old duplicate ACKs */
	738	return 0;
	739	} else {
	740	/* Send RST if an out-of-range ACK is received
	741	* on a not-yet-established connection, as per
	742	* RFC 793.
	743	*/
	744	return -EINVAL;
	745	}
	746	}
	747
	748	/* Ignore ACKs that don't actually acknowledge any new data.
	749	* (In particular, do not stop the retransmission timer; this
	750	* avoids creating a sorceror's apprentice syndrome when a
	751	* duplicate ACK is received and we still have data in our
	752	* transmit queue.)
	753	*/
	754	if ( ack_len == 0 )
	755	return 0;
	756
	757	/* Stop the retransmission timer */
	758	stop_timer ( &tcp->timer );
	759
	760	/* Determine acknowledged flags and data length */
	761	len = ack_len;
	762	acked_flags = ( TCP_FLAGS_SENDING ( tcp->tcp_state ) &
	763	( TCP_SYN \| TCP_FIN ) );
	764	if ( acked_flags )
	765	len--;
	766
	767	/* Update SEQ and sent counters, and window size */
	768	tcp->snd_seq = ack;
	769	tcp->snd_sent = 0;
	770	tcp->snd_win = win;
	771
	772	/* Remove any acknowledged data from transmit queue */
	773	tcp_process_queue ( tcp, len, NULL, 1 );
	774
	775	/* Mark SYN/FIN as acknowledged if applicable. */
	776	if ( acked_flags )
	777	tcp->tcp_state \|= TCP_STATE_ACKED ( acked_flags );
	778
	779	/* Start sending FIN if we've had all possible data ACKed */
	780	if ( list_empty ( &tcp->queue ) && tcp->xfer_closed )
	781	tcp->tcp_state \|= TCP_STATE_SENT ( TCP_FIN );
	782
	783	return 0;
	784	}
	785
	786	/**
	787	* Handle TCP received data
	788	*
	789	* @v tcp TCP connection
	790	* @v seq SEQ value (in host-endian order)
	791	* @v iobuf I/O buffer
	792	* @ret rc Return status code
	793	*
	794	* This function takes ownership of the I/O buffer.
	795	*/
	796	static int tcp_rx_data ( struct tcp_connection *tcp, uint32_t seq,
	797	struct io_buffer *iobuf ) {
	798	uint32_t already_rcvd;
	799	uint32_t len;
	800	int rc;
	801
	802	/* Ignore duplicate or out-of-order data */
	803	already_rcvd = ( tcp->rcv_ack - seq );
	804	len = iob_len ( iobuf );
	805	if ( already_rcvd >= len ) {
	806	free_iob ( iobuf );
	807	return 0;
	808	}
	809	iob_pull ( iobuf, already_rcvd );
	810	len -= already_rcvd;
	811
	812	/* Deliver data to application */
	813	if ( ( rc = xfer_deliver_iob ( &tcp->xfer, iobuf ) ) != 0 ) {
	814	DBGC ( tcp, "TCP %p could not deliver %08x..%08x: %s\n",
	815	tcp, seq, ( seq + len ), strerror ( rc ) );
	816	return rc;
	817	}
	818
	819	/* Acknowledge new data */
	820	tcp_rx_seq ( tcp, len );
	821
	822	return 0;
	823	}
	824
	825	/**
	826	* Handle TCP received FIN
	827	*
	828	* @v tcp TCP connection
	829	* @v seq SEQ value (in host-endian order)
	830	* @ret rc Return status code
	831	*/
	832	static int tcp_rx_fin ( struct tcp_connection *tcp, uint32_t seq ) {
	833
	834	/* Ignore duplicate or out-of-order FIN */
	835	if ( ( tcp->rcv_ack - seq ) > 0 )
	836	return 0;
	837
	838	/* Mark FIN as received and acknowledge it */
	839	tcp->tcp_state \|= TCP_STATE_RCVD ( TCP_FIN );
	840	tcp_rx_seq ( tcp, 1 );
	841
	842	/* Close connection */
	843	tcp_close ( tcp, 0 );
	844
	845	return 0;
	846	}
	847
	848	/**
	849	* Handle TCP received RST
	850	*
	851	* @v tcp TCP connection
	852	* @v seq SEQ value (in host-endian order)
	853	* @ret rc Return status code
	854	*/
	855	static int tcp_rx_rst ( struct tcp_connection *tcp, uint32_t seq ) {
	856
	857	/* Accept RST only if it falls within the window. If we have
	858	* not yet received a SYN, then we have no window to test
	859	* against, so fall back to checking that our SYN has been
	860	* ACKed.
	861	*/
	862	if ( tcp->tcp_state & TCP_STATE_RCVD ( TCP_SYN ) ) {
	863	if ( ( seq - tcp->rcv_ack ) >= tcp->rcv_win )
	864	return 0;
	865	} else {
	866	if ( ! ( tcp->tcp_state & TCP_STATE_ACKED ( TCP_SYN ) ) )
	867	return 0;
	868	}
	869
	870	/* Abort connection */
	871	tcp->tcp_state = TCP_CLOSED;
	872	tcp_dump_state ( tcp );
	873	tcp_close ( tcp, -ECONNRESET );
	874
	875	DBGC ( tcp, "TCP %p connection reset by peer\n", tcp );
	876	return -ECONNRESET;
	877	}
	878
	879	/**
	880	* Process received packet
	881	*
	882	* @v iobuf I/O buffer
	883	* @v st_src Partially-filled source address
	884	* @v st_dest Partially-filled destination address
	885	* @v pshdr_csum Pseudo-header checksum
	886	* @ret rc Return status code
	887	*/
	888	static int tcp_rx ( struct io_buffer *iobuf,
	889	struct sockaddr_tcpip *st_src,
	890	struct sockaddr_tcpip *st_dest __unused,
	891	uint16_t pshdr_csum ) {
	892	struct tcp_header *tcphdr = iobuf->data;
	893	struct tcp_connection *tcp;
	894	struct tcp_options options;
	895	size_t hlen;
	896	uint16_t csum;
	897	uint32_t start_seq;
	898	uint32_t seq;
	899	uint32_t ack;
	900	uint32_t win;
	901	unsigned int flags;
	902	size_t len;
	903	int rc;
	904
	905	/* Sanity check packet */
	906	if ( iob_len ( iobuf ) < sizeof ( *tcphdr ) ) {
	907	DBG ( "TCP packet too short at %zd bytes (min %zd bytes)\n",
	908	iob_len ( iobuf ), sizeof ( *tcphdr ) );
	909	rc = -EINVAL;
	910	goto discard;
	911	}
	912	hlen = ( ( tcphdr->hlen & TCP_MASK_HLEN ) / 16 ) * 4;
	913	if ( hlen < sizeof ( *tcphdr ) ) {
	914	DBG ( "TCP header too short at %zd bytes (min %zd bytes)\n",
	915	hlen, sizeof ( *tcphdr ) );
	916	rc = -EINVAL;
	917	goto discard;
	918	}
	919	if ( hlen > iob_len ( iobuf ) ) {
	920	DBG ( "TCP header too long at %zd bytes (max %zd bytes)\n",
	921	hlen, iob_len ( iobuf ) );
	922	rc = -EINVAL;
	923	goto discard;
	924	}
	925	csum = tcpip_continue_chksum ( pshdr_csum, iobuf->data,
	926	iob_len ( iobuf ) );
	927	if ( csum != 0 ) {
	928	DBG ( "TCP checksum incorrect (is %04x including checksum "
	929	"field, should be 0000)\n", csum );
	930	rc = -EINVAL;
	931	goto discard;
	932	}
	933
	934	/* Parse parameters from header and strip header */
	935	tcp = tcp_demux ( tcphdr->dest );
	936	start_seq = seq = ntohl ( tcphdr->seq );
	937	ack = ntohl ( tcphdr->ack );
	938	win = ntohs ( tcphdr->win );
	939	flags = tcphdr->flags;
	940	tcp_rx_opts ( tcp, ( ( ( void * ) tcphdr ) + sizeof ( *tcphdr ) ),
	941	( hlen - sizeof ( *tcphdr ) ), &options );
	942	iob_pull ( iobuf, hlen );
	943	len = iob_len ( iobuf );
	944
	945	/* Dump header */
	946	DBGC2 ( tcp, "TCP %p RX %d<-%d %08x %08x..%08zx %4zd",
	947	tcp, ntohs ( tcphdr->dest ), ntohs ( tcphdr->src ),
	948	ntohl ( tcphdr->ack ), ntohl ( tcphdr->seq ),
	949	( ntohl ( tcphdr->seq ) + len +
	950	( ( tcphdr->flags & ( TCP_SYN \| TCP_FIN ) ) ? 1 : 0 )), len);
	951	tcp_dump_flags ( tcp, tcphdr->flags );
	952	DBGC2 ( tcp, "\n" );
	953
	954	/* If no connection was found, send RST */
	955	if ( ! tcp ) {
	956	tcp_xmit_reset ( tcp, st_src, tcphdr );
	957	rc = -ENOTCONN;
	958	goto discard;
	959	}
	960
	961	/* Handle ACK, if present */
	962	if ( flags & TCP_ACK ) {
	963	if ( ( rc = tcp_rx_ack ( tcp, ack, win ) ) != 0 ) {
	964	tcp_xmit_reset ( tcp, st_src, tcphdr );
	965	goto discard;
	966	}
	967	}
	968
	969	/* Handle SYN, if present */
	970	if ( flags & TCP_SYN ) {
	971	tcp_rx_syn ( tcp, seq, &options );
	972	seq++;
	973	}
	974
	975	/* Handle RST, if present */
	976	if ( flags & TCP_RST ) {
	977	if ( ( rc = tcp_rx_rst ( tcp, seq ) ) != 0 )
	978	goto discard;
	979	}
	980
	981	/* Handle new data, if any */
	982	tcp_rx_data ( tcp, seq, iobuf );
	983	seq += len;
	984
	985	/* Handle FIN, if present */
	986	if ( flags & TCP_FIN ) {
	987	tcp_rx_fin ( tcp, seq );
	988	seq++;
	989	}
	990
	991	/* Update timestamp, if present and applicable */
	992	if ( ( seq == tcp->rcv_ack ) && options.tsopt )
	993	tcp->ts_recent = ntohl ( options.tsopt->tsval );
	994
	995	/* Dump out any state change as a result of the received packet */
	996	tcp_dump_state ( tcp );
	997
	998	/* Send out any pending data. We force sending a reply if either
	999	*
	1000	* a) the peer is expecting an ACK (i.e. consumed sequence space), or
	1001	* b) either end of the packet was outside the receive window
	1002	*
	1003	* Case (b) enables us to support TCP keepalives using
	1004	* zero-length packets, which we would otherwise ignore. Note
	1005	* that for case (b), we need only consider zero-length
	1006	* packets, since non-zero-length packets will already be
	1007	* caught by case (a).
	1008	*/
	1009	tcp_xmit ( tcp, ( ( start_seq != seq ) \|\|
	1010	( ( seq - tcp->rcv_ack ) > tcp->rcv_win ) ) );
	1011
	1012	/* If this packet was the last we expect to receive, set up
	1013	* timer to expire and cause the connection to be freed.
	1014	*/
	1015	if ( TCP_CLOSED_GRACEFULLY ( tcp->tcp_state ) ) {
	1016	tcp->timer.timeout = ( 2 * TCP_MSL );
	1017	start_timer ( &tcp->timer );
	1018	}
	1019
	1020	return 0;
	1021
	1022	discard:
	1023	/* Free received packet */
	1024	free_iob ( iobuf );
	1025	return rc;
	1026	}
	1027
	1028	/** TCP protocol */
	1029	struct tcpip_protocol tcp_protocol __tcpip_protocol = {
	1030	.name = "TCP",
	1031	.rx = tcp_rx,
	1032	.tcpip_proto = IP_TCP,
	1033	};
	1034
	1035	/***************************************************************************
	1036	*
	1037	* Data transfer interface
	1038	*
	1039	***************************************************************************
	1040	*/
	1041
	1042	/**
	1043	* Close interface
	1044	*
	1045	* @v xfer Data transfer interface
	1046	* @v rc Reason for close
	1047	*/
	1048	static void tcp_xfer_close ( struct xfer_interface *xfer, int rc ) {
	1049	struct tcp_connection *tcp =
	1050	container_of ( xfer, struct tcp_connection, xfer );
	1051
	1052	/* Close data transfer interface */
	1053	tcp_close ( tcp, rc );
	1054
	1055	/* Transmit FIN, if possible */
	1056	tcp_xmit ( tcp, 0 );
	1057	}
	1058
	1059	/**
	1060	* Check flow control window
	1061	*
	1062	* @v xfer Data transfer interface
	1063	* @ret len Length of window
	1064	*/
	1065	static size_t tcp_xfer_window ( struct xfer_interface *xfer ) {
	1066	struct tcp_connection *tcp =
	1067	container_of ( xfer, struct tcp_connection, xfer );
	1068
	1069	/* Not ready if data queue is non-empty. This imposes a limit
	1070	* of only one unACKed packet in the TX queue at any time; we
	1071	* do this to conserve memory usage.
	1072	*/
	1073	if ( ! list_empty ( &tcp->queue ) )
	1074	return 0;
	1075
	1076	/* Return TCP window length */
	1077	return tcp_xmit_win ( tcp );
	1078	}
	1079
	1080	/**
	1081	* Deliver datagram as I/O buffer
	1082	*
	1083	* @v xfer Data transfer interface
	1084	* @v iobuf Datagram I/O buffer
	1085	* @v meta Data transfer metadata
	1086	* @ret rc Return status code
	1087	*/
	1088	static int tcp_xfer_deliver_iob ( struct xfer_interface *xfer,
	1089	struct io_buffer *iobuf,
	1090	struct xfer_metadata *meta __unused ) {
	1091	struct tcp_connection *tcp =
	1092	container_of ( xfer, struct tcp_connection, xfer );
	1093
	1094	/* Enqueue packet */
	1095	list_add_tail ( &iobuf->list, &tcp->queue );
	1096
	1097	/* Transmit data, if possible */
	1098	tcp_xmit ( tcp, 0 );
	1099
	1100	return 0;
	1101	}
	1102
	1103	/** TCP data transfer interface operations */
	1104	static struct xfer_interface_operations tcp_xfer_operations = {
	1105	.close = tcp_xfer_close,
	1106	.vredirect = ignore_xfer_vredirect,
	1107	.window = tcp_xfer_window,
	1108	.alloc_iob = default_xfer_alloc_iob,
	1109	.deliver_iob = tcp_xfer_deliver_iob,
	1110	.deliver_raw = xfer_deliver_as_iob,
	1111	};
	1112
	1113	/***************************************************************************
	1114	*
	1115	* Openers
	1116	*
	1117	***************************************************************************
	1118	*/
	1119
	1120	/** TCP socket opener */
	1121	struct socket_opener tcp_socket_opener __socket_opener = {
	1122	.semantics = TCP_SOCK_STREAM,
	1123	.family = AF_INET,
	1124	.open = tcp_open,
	1125	};
	1126
	1127	/** Linkage hack */
	1128	int tcp_sock_stream = TCP_SOCK_STREAM;
	1129
	1130	/**
	1131	* Open TCP URI
	1132	*
	1133	* @v xfer Data transfer interface
	1134	* @v uri URI
	1135	* @ret rc Return status code
	1136	*/
	1137	static int tcp_open_uri ( struct xfer_interface xfer, struct uri uri ) {
	1138	struct sockaddr_tcpip peer;
	1139
	1140	/* Sanity check */
	1141	if ( ! uri->host )
	1142	return -EINVAL;
	1143
	1144	memset ( &peer, 0, sizeof ( peer ) );
	1145	peer.st_port = htons ( uri_port ( uri, 0 ) );
	1146	return xfer_open_named_socket ( xfer, SOCK_STREAM,
	1147	( struct sockaddr * ) &peer,
	1148	uri->host, NULL );
	1149	}
	1150
	1151	/** TCP URI opener */
	1152	struct uri_opener tcp_uri_opener __uri_opener = {
	1153	.scheme = "tcp",
	1154	.open = tcp_open_uri,
	1155	};
	1156

Note: See TracBrowser for help on using the repository browser.

Download in other formats: