PicoTCP - Free (GPLv2) TCP/IP stack developed by TASS Belgi…

Users » daniele » Code » PicoTCP

Free (GPLv2) TCP/IP stack developed by TASS Belgium

Dependents: lpc1768-picotcp-demo ZeroMQ_PicoTCP_Publisher_demo TCPSocket_HelloWorld_PicoTCP Pico_TCP_UDP_Test ... more

PicoTCP. Copyright (c) 2013 TASS Belgium NV.

Released under the GNU General Public License, version 2.

Different licensing models may exist, at the sole discretion of the Copyright holders.

Official homepage: http://www.picotcp.com

Bug tracker: https://github.com/tass-belgium/picotcp/issues

Development steps:

~~initial integration with mbed RTOS~~
~~generic mbed Ethernet driver~~
~~high performance NXP LPC1768 specific Ethernet driver~~
~~Multi-threading support for mbed RTOS~~
~~Berkeley sockets and integration with the New Socket API~~
~~Fork of the apps running on top of the New Socket API~~
~~Scheduling optimizations~~
Debugging/benchmarking/testing

Demo application (measuring TCP sender performance):

Import program lpc1768-picotcp-demo

A PicoTCP demo app testing the ethernet throughput on the lpc1768 mbed board.

modules/pico_tcp.c@117:b853bfe76990, 2013-11-12 (annotated)

Committer:: tass
Date:: Tue Nov 12 13:31:02 2013 +0000
Revision:: 117:b853bfe76990
Parent:: 116:34b8859c5537
Parent:: 115:c8bcc739ed53
Child:: 122:5b1e9de8bf7f

merge branches, disabled memory tools and prescaler by default

Who changed what in which revision?

User	Revision	Line number	New contents of line
daniele	29:1a47b7151851	1	/*********************************************************************
daniele	29:1a47b7151851	2	PicoTCP. Copyright (c) 2012 TASS Belgium NV. Some rights reserved.
daniele	29:1a47b7151851	3	See LICENSE and COPYING for usage.
daniele	29:1a47b7151851	4
daniele	29:1a47b7151851	5	.
daniele	29:1a47b7151851	6
daniele	29:1a47b7151851	7	Authors: Daniele Lacamera, Philippe Mariman
daniele	29:1a47b7151851	8	*********************************************************************/
daniele	29:1a47b7151851	9
daniele	29:1a47b7151851	10	#include "pico_tcp.h"
daniele	29:1a47b7151851	11	#include "pico_config.h"
daniele	29:1a47b7151851	12	#include "pico_eth.h"
daniele	29:1a47b7151851	13	#include "pico_socket.h"
daniele	29:1a47b7151851	14	#include "pico_stack.h"
daniele	29:1a47b7151851	15	#include "pico_socket.h"
daniele	29:1a47b7151851	16	#include "pico_queue.h"
daniele	29:1a47b7151851	17	#include "pico_tree.h"
daniele	29:1a47b7151851	18
tass	68:0847e35d08a6	19	#define TCP_IS_STATE(s,st) (s->state & st)
daniele	29:1a47b7151851	20	#define TCP_SOCK(s) ((struct pico_socket_tcp *)s)
tass	110:0ece1bbbd36e	21	#define SEQN(f) ((f)?(long_be(((struct pico_tcp_hdr *)((f)->transport_hdr))->seq)):0)
tass	110:0ece1bbbd36e	22	#define ACKN(f) ((f)?(long_be(((struct pico_tcp_hdr *)((f)->transport_hdr))->ack)):0)
daniele	29:1a47b7151851	23
daniele	29:1a47b7151851	24	#define PICO_TCP_RTO_MIN 10
daniele	29:1a47b7151851	25	#define PICO_TCP_RTO_MAX 120000
tass	68:0847e35d08a6	26	#define PICO_TCP_IW 2
tass	70:cd218dd180e5	27	#define PICO_TCP_SYN_TO 1000u
tass	48:40fc4462265c	28	#define PICO_TCP_ZOMBIE_TO 30000
daniele	29:1a47b7151851	29
tass	97:e73b01cb3147	30	#define PICO_TCP_MAX_RETRANS 10
daniele	29:1a47b7151851	31	#define PICO_TCP_MAX_CONNECT_RETRIES 7
daniele	29:1a47b7151851	32
daniele	29:1a47b7151851	33	#define PICO_TCP_LOOKAHEAD 0x00
daniele	29:1a47b7151851	34	#define PICO_TCP_FIRST_DUPACK 0x01
daniele	29:1a47b7151851	35	#define PICO_TCP_SECOND_DUPACK 0x02
daniele	29:1a47b7151851	36	#define PICO_TCP_RECOVER 0x03
daniele	29:1a47b7151851	37	#define PICO_TCP_BLACKOUT 0x04
daniele	29:1a47b7151851	38	#define PICO_TCP_UNREACHABLE 0x05
daniele	29:1a47b7151851	39	#define PICO_TCP_WINDOW_FULL 0x06
daniele	29:1a47b7151851	40
daniele	29:1a47b7151851	41	/* check if the Nagle algorithm is enabled on the socket */
daniele	29:1a47b7151851	42	#define IS_NAGLE_ENABLED(s) (!(!(!(s->opt_flags & (1 << PICO_SOCKET_OPT_TCPNODELAY)))))
daniele	29:1a47b7151851	43	/* check if tcp connection is "idle" according to Nagle (RFC 896) */
daniele	29:1a47b7151851	44	#define IS_TCP_IDLE(t) ((t->in_flight == 0) && (t->tcpq_out.size == 0))
daniele	29:1a47b7151851	45	/* check if the hold queue contains data (again Nagle) */
daniele	29:1a47b7151851	46	#define IS_TCP_HOLDQ_EMPTY(t) (t->tcpq_hold.size == 0)
daniele	29:1a47b7151851	47
tass	110:0ece1bbbd36e	48	#define IS_INPUT_QUEUE(q) (q->pool.compare==input_segment_compare)
tass	110:0ece1bbbd36e	49	#define TCP_INPUT_OVERHEAD (sizeof(struct tcp_input_segment)+sizeof(struct pico_tree_node))
tass	110:0ece1bbbd36e	50
daniele	29:1a47b7151851	51	#ifdef PICO_SUPPORT_TCP
tass	45:ca30069e49bb	52	#define tcp_dbg_nagle(...) do{}while(0)
tass	45:ca30069e49bb	53	#define tcp_dbg_options(...) do{}while(0)
tass	45:ca30069e49bb	54
tass	45:ca30069e49bb	55
tass	68:0847e35d08a6	56	#define tcp_dbg(...) do{}while(0)
tass	68:0847e35d08a6	57	//#define tcp_dbg dbg
daniele	29:1a47b7151851	58
daniele	29:1a47b7151851	59	#ifdef PICO_SUPPORT_MUTEX
daniele	29:1a47b7151851	60	static void * Mutex = NULL;
daniele	29:1a47b7151851	61	#define LOCK(x) {\
daniele	29:1a47b7151851	62	if (x == NULL) \
daniele	29:1a47b7151851	63	x = pico_mutex_init(); \
daniele	29:1a47b7151851	64	pico_mutex_lock(x); \
daniele	29:1a47b7151851	65	}
daniele	29:1a47b7151851	66	#define UNLOCK(x) pico_mutex_unlock(x);
daniele	29:1a47b7151851	67
daniele	29:1a47b7151851	68	#else
daniele	29:1a47b7151851	69	#define LOCK(x) do{}while(0)
daniele	29:1a47b7151851	70	#define UNLOCK(x) do{}while(0)
daniele	29:1a47b7151851	71	#endif
daniele	29:1a47b7151851	72
daniele	29:1a47b7151851	73
daniele	29:1a47b7151851	74	static inline int seq_compare(uint32_t a, uint32_t b)
daniele	29:1a47b7151851	75	{
daniele	29:1a47b7151851	76	uint32_t thresh = ((uint32_t)(-1))>>1;
daniele	29:1a47b7151851	77	if (((a > thresh) && (b > thresh)) \|\| ((a <= thresh) && (b <= thresh))) {
daniele	29:1a47b7151851	78	if (a > b)
daniele	29:1a47b7151851	79	return 1;
daniele	29:1a47b7151851	80	if (b > a)
daniele	29:1a47b7151851	81	return -1;
daniele	29:1a47b7151851	82	} else {
daniele	29:1a47b7151851	83	if (a > b)
daniele	29:1a47b7151851	84	return -2;
daniele	29:1a47b7151851	85	if (b > a)
daniele	29:1a47b7151851	86	return 2;
daniele	29:1a47b7151851	87	}
daniele	29:1a47b7151851	88	return 0;
daniele	29:1a47b7151851	89	}
daniele	29:1a47b7151851	90
tass	110:0ece1bbbd36e	91	// Input segment, used to keep only needed data, not the full frame
tass	110:0ece1bbbd36e	92	struct tcp_input_segment
tass	110:0ece1bbbd36e	93	{
tass	110:0ece1bbbd36e	94	uint32_t seq;
tass	110:0ece1bbbd36e	95	/* Pointer to payload */
tass	110:0ece1bbbd36e	96	unsigned char *payload;
tass	110:0ece1bbbd36e	97	uint16_t payload_len;
tass	110:0ece1bbbd36e	98	};
tass	110:0ece1bbbd36e	99
tass	110:0ece1bbbd36e	100	// Function to compare input segments
tass	110:0ece1bbbd36e	101	static int input_segment_compare(void ka, void kb)
tass	110:0ece1bbbd36e	102	{
tass	110:0ece1bbbd36e	103	struct tcp_input_segment a = ka, b = kb;
tass	110:0ece1bbbd36e	104	return seq_compare(a->seq,b->seq);
tass	110:0ece1bbbd36e	105	}
tass	110:0ece1bbbd36e	106
tass	110:0ece1bbbd36e	107	static struct tcp_input_segment * segment_from_frame(struct pico_frame * f)
tass	110:0ece1bbbd36e	108	{
tass	110:0ece1bbbd36e	109	struct tcp_input_segment * seg = pico_zalloc(sizeof(struct tcp_input_segment));
tass	110:0ece1bbbd36e	110	if(!seg)
tass	110:0ece1bbbd36e	111	return NULL;
tass	110:0ece1bbbd36e	112	seg->payload = pico_zalloc(f->payload_len);
tass	110:0ece1bbbd36e	113	if(!seg->payload)
tass	110:0ece1bbbd36e	114	{
tass	110:0ece1bbbd36e	115	pico_free(seg);
tass	110:0ece1bbbd36e	116	return NULL;
tass	110:0ece1bbbd36e	117	}
tass	110:0ece1bbbd36e	118	seg->seq = SEQN(f);
tass	110:0ece1bbbd36e	119	seg->payload_len = f->payload_len;
tass	110:0ece1bbbd36e	120	memcpy(seg->payload,f->payload,seg->payload_len);
tass	110:0ece1bbbd36e	121	return seg;
tass	110:0ece1bbbd36e	122	}
tass	110:0ece1bbbd36e	123
daniele	29:1a47b7151851	124	static int segment_compare(void * ka, void * kb)
daniele	29:1a47b7151851	125	{
daniele	29:1a47b7151851	126	struct pico_frame a = ka, b = kb;
daniele	29:1a47b7151851	127	return seq_compare(SEQN(a), SEQN(b));
daniele	29:1a47b7151851	128	}
daniele	29:1a47b7151851	129
daniele	29:1a47b7151851	130	struct pico_tcp_queue
daniele	29:1a47b7151851	131	{
daniele	29:1a47b7151851	132	struct pico_tree pool;
daniele	29:1a47b7151851	133	uint32_t max_size;
daniele	29:1a47b7151851	134	uint32_t size;
daniele	29:1a47b7151851	135	uint32_t frames;
tass	111:4003cf17bc15	136	uint16_t overhead;
daniele	29:1a47b7151851	137	};
tass	97:e73b01cb3147	138	static void tcp_discard_all_segments(struct pico_tcp_queue *tq);
tass	110:0ece1bbbd36e	139	static void peek_segment(struct pico_tcp_queue tq, uint32_t seq)
daniele	29:1a47b7151851	140	{
tass	110:0ece1bbbd36e	141	if(!IS_INPUT_QUEUE(tq))
tass	110:0ece1bbbd36e	142	{
tass	110:0ece1bbbd36e	143	struct pico_tcp_hdr H;
tass	110:0ece1bbbd36e	144	struct pico_frame f = {0};
tass	110:0ece1bbbd36e	145	f.transport_hdr = (uint8_t *) (&H);
tass	110:0ece1bbbd36e	146	H.seq = long_be(seq);
daniele	29:1a47b7151851	147
tass	110:0ece1bbbd36e	148	return pico_tree_findKey(&tq->pool,&f);
tass	110:0ece1bbbd36e	149	}
tass	110:0ece1bbbd36e	150	else
tass	110:0ece1bbbd36e	151	{
tass	110:0ece1bbbd36e	152	struct tcp_input_segment dummy={.seq=long_be(seq)};
tass	110:0ece1bbbd36e	153	// TODO: Check if long_be(seq) is needed
tass	110:0ece1bbbd36e	154	return pico_tree_findKey(&tq->pool,&dummy);
tass	110:0ece1bbbd36e	155	}
tass	110:0ece1bbbd36e	156
daniele	29:1a47b7151851	157	}
daniele	29:1a47b7151851	158
tass	110:0ece1bbbd36e	159	static void first_segment(struct pico_tcp_queue tq)
daniele	29:1a47b7151851	160	{
daniele	29:1a47b7151851	161	return pico_tree_first(&tq->pool);
daniele	29:1a47b7151851	162	}
daniele	29:1a47b7151851	163
tass	110:0ece1bbbd36e	164	static void next_segment(struct pico_tcp_queue tq, void *cur)
daniele	29:1a47b7151851	165	{
daniele	29:1a47b7151851	166	if (!cur)
daniele	29:1a47b7151851	167	return NULL;
tass	110:0ece1bbbd36e	168	if(IS_INPUT_QUEUE(tq))
tass	110:0ece1bbbd36e	169	{
tass	110:0ece1bbbd36e	170	return peek_segment(tq,((struct tcp_input_segment )cur)->seq + ((struct tcp_input_segment )cur)->payload_len);
tass	110:0ece1bbbd36e	171	}
tass	110:0ece1bbbd36e	172	else
tass	110:0ece1bbbd36e	173	{
tass	110:0ece1bbbd36e	174	return peek_segment(tq, SEQN((struct pico_frame )cur) + ((struct pico_frame )cur)->payload_len);
tass	110:0ece1bbbd36e	175	}
daniele	29:1a47b7151851	176	}
daniele	29:1a47b7151851	177
tass	110:0ece1bbbd36e	178	static int32_t pico_enqueue_segment(struct pico_tcp_queue tq, void f)
daniele	29:1a47b7151851	179	{
tass	110:0ece1bbbd36e	180	int32_t ret = -1;
tass	110:0ece1bbbd36e	181	uint16_t payload_len = (uint16_t)(IS_INPUT_QUEUE(tq) ?
tass	111:4003cf17bc15	182	((struct tcp_input_segment *)f)->payload_len:
tass	111:4003cf17bc15	183	((struct pico_frame *)f)->buffer_len);
tass	110:0ece1bbbd36e	184
tass	110:0ece1bbbd36e	185	if (payload_len <= 0) {
daniele	29:1a47b7151851	186	tcp_dbg("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! TRIED TO ENQUEUE INVALID SEGMENT!\n");
daniele	29:1a47b7151851	187	//abort();
daniele	29:1a47b7151851	188	return -1;
daniele	29:1a47b7151851	189	}
tass	68:0847e35d08a6	190	LOCK(Mutex);
tass	110:0ece1bbbd36e	191	if ((tq->size + payload_len) > tq->max_size)
daniele	29:1a47b7151851	192	{
daniele	29:1a47b7151851	193	ret = 0;
daniele	29:1a47b7151851	194	goto out;
daniele	29:1a47b7151851	195	}
daniele	29:1a47b7151851	196	if (pico_tree_insert(&tq->pool,f) != 0)
daniele	29:1a47b7151851	197	{
daniele	29:1a47b7151851	198	ret = 0;
daniele	29:1a47b7151851	199	goto out;
daniele	29:1a47b7151851	200	}
tass	111:4003cf17bc15	201	tq->size += (uint16_t)(payload_len + tq->overhead);
tass	110:0ece1bbbd36e	202	if (payload_len > 0)
daniele	29:1a47b7151851	203	tq->frames++;
tass	110:0ece1bbbd36e	204	ret = (int32_t)payload_len;
daniele	29:1a47b7151851	205
daniele	29:1a47b7151851	206	out :
daniele	29:1a47b7151851	207	UNLOCK(Mutex);
daniele	29:1a47b7151851	208	return ret;
daniele	29:1a47b7151851	209	}
daniele	29:1a47b7151851	210
tass	110:0ece1bbbd36e	211	static void pico_discard_segment(struct pico_tcp_queue tq, void f)
daniele	29:1a47b7151851	212	{
tass	110:0ece1bbbd36e	213	void *f1;
tass	110:0ece1bbbd36e	214	uint16_t payload_len = (uint16_t)(IS_INPUT_QUEUE(tq)?
tass	111:4003cf17bc15	215	((struct tcp_input_segment *)f)->payload_len:
tass	111:4003cf17bc15	216	((struct pico_frame *)f)->buffer_len);
daniele	29:1a47b7151851	217	LOCK(Mutex);
daniele	29:1a47b7151851	218	f1 = pico_tree_delete(&tq->pool,f);
daniele	29:1a47b7151851	219	if (f1) {
tass	111:4003cf17bc15	220	tq->size -= (uint16_t)(payload_len + tq->overhead);
tass	110:0ece1bbbd36e	221	if (payload_len > 0)
daniele	29:1a47b7151851	222	tq->frames--;
daniele	29:1a47b7151851	223	}
tass	110:0ece1bbbd36e	224	if(IS_INPUT_QUEUE(tq))
tass	110:0ece1bbbd36e	225	{
tass	110:0ece1bbbd36e	226	struct tcp_input_segment * inp = f1;
tass	110:0ece1bbbd36e	227	pico_free(inp->payload);
tass	110:0ece1bbbd36e	228	pico_free(inp);
tass	110:0ece1bbbd36e	229	}
tass	110:0ece1bbbd36e	230	else
tass	110:0ece1bbbd36e	231	pico_frame_discard(f);
daniele	29:1a47b7151851	232	UNLOCK(Mutex);
daniele	29:1a47b7151851	233	}
daniele	29:1a47b7151851	234
daniele	29:1a47b7151851	235	/* Structure for TCP socket */
daniele	29:1a47b7151851	236	struct tcp_sack_block {
daniele	29:1a47b7151851	237	uint32_t left;
daniele	29:1a47b7151851	238	uint32_t right;
daniele	29:1a47b7151851	239	struct tcp_sack_block *next;
daniele	29:1a47b7151851	240	};
daniele	29:1a47b7151851	241
daniele	29:1a47b7151851	242	struct pico_socket_tcp {
daniele	29:1a47b7151851	243	struct pico_socket sock;
daniele	29:1a47b7151851	244
daniele	29:1a47b7151851	245	/* Tree/queues */
tass	110:0ece1bbbd36e	246	struct pico_tcp_queue tcpq_in; // updated the input queue to hold input segments not the full frame.
daniele	29:1a47b7151851	247	struct pico_tcp_queue tcpq_out;
daniele	29:1a47b7151851	248	struct pico_tcp_queue tcpq_hold; /* buffer to hold delayed frames according to Nagle */
daniele	29:1a47b7151851	249
daniele	29:1a47b7151851	250	/* tcp_output */
daniele	29:1a47b7151851	251	uint32_t snd_nxt;
daniele	29:1a47b7151851	252	uint32_t snd_last;
daniele	29:1a47b7151851	253	uint32_t snd_old_ack;
daniele	29:1a47b7151851	254	uint32_t snd_retry;
daniele	29:1a47b7151851	255	uint32_t snd_last_out;
daniele	29:1a47b7151851	256
daniele	29:1a47b7151851	257	/* congestion control */
daniele	29:1a47b7151851	258	uint32_t avg_rtt;
daniele	29:1a47b7151851	259	uint32_t rttvar;
daniele	29:1a47b7151851	260	uint32_t rto;
daniele	29:1a47b7151851	261	uint32_t in_flight;
daniele	29:1a47b7151851	262	uint8_t timer_running;
tass	70:cd218dd180e5	263	struct pico_timer * retrans_tmr;
daniele	29:1a47b7151851	264	uint8_t keepalive_timer_running;
daniele	29:1a47b7151851	265	uint16_t cwnd_counter;
daniele	29:1a47b7151851	266	uint16_t cwnd;
daniele	29:1a47b7151851	267	uint16_t ssthresh;
daniele	29:1a47b7151851	268	uint16_t recv_wnd;
daniele	29:1a47b7151851	269	uint16_t recv_wnd_scale;
daniele	29:1a47b7151851	270
daniele	29:1a47b7151851	271	/* tcp_input */
daniele	29:1a47b7151851	272	uint32_t rcv_nxt;
daniele	29:1a47b7151851	273	uint32_t rcv_ackd;
daniele	29:1a47b7151851	274	uint32_t rcv_processed;
daniele	29:1a47b7151851	275	uint16_t wnd;
daniele	29:1a47b7151851	276	uint16_t wnd_scale;
daniele	29:1a47b7151851	277
daniele	29:1a47b7151851	278	/* options */
daniele	29:1a47b7151851	279	uint32_t ts_nxt;
daniele	29:1a47b7151851	280	uint16_t mss;
daniele	29:1a47b7151851	281	uint8_t sack_ok;
daniele	29:1a47b7151851	282	uint8_t ts_ok;
daniele	29:1a47b7151851	283	uint8_t mss_ok;
daniele	29:1a47b7151851	284	uint8_t scale_ok;
daniele	29:1a47b7151851	285	struct tcp_sack_block *sacks;
daniele	29:1a47b7151851	286	uint8_t jumbo;
daniele	29:1a47b7151851	287
daniele	29:1a47b7151851	288	/* Transmission */
daniele	29:1a47b7151851	289	uint8_t x_mode;
daniele	29:1a47b7151851	290	uint8_t dupacks;
daniele	29:1a47b7151851	291	uint8_t backoff;
tass	75:a9abf10138d6	292	uint8_t localZeroWindow;
daniele	29:1a47b7151851	293	};
daniele	29:1a47b7151851	294
daniele	29:1a47b7151851	295	/* Queues */
tass	68:0847e35d08a6	296	static struct pico_queue tcp_in = {0};
tass	68:0847e35d08a6	297	static struct pico_queue tcp_out = {0};
daniele	29:1a47b7151851	298
daniele	29:1a47b7151851	299	/* If Nagle enabled, this function can make 1 new segment from smaller segments in hold queue */
daniele	29:1a47b7151851	300	static struct pico_frame * pico_hold_segment_make(struct pico_socket_tcp *t);
daniele	29:1a47b7151851	301
daniele	29:1a47b7151851	302	/* checks if tcpq_in is empty */
daniele	29:1a47b7151851	303	int pico_tcp_queue_in_is_empty(struct pico_socket *s)
daniele	29:1a47b7151851	304	{
daniele	29:1a47b7151851	305	struct pico_socket_tcp t = (struct pico_socket_tcp ) s;
daniele	29:1a47b7151851	306
daniele	29:1a47b7151851	307	if (t->tcpq_in.frames == 0)
daniele	29:1a47b7151851	308	return 1;
daniele	29:1a47b7151851	309	else
daniele	29:1a47b7151851	310	return 0;
daniele	29:1a47b7151851	311	}
daniele	29:1a47b7151851	312
daniele	29:1a47b7151851	313	/* Useful for getting rid of the beginning of the buffer (read() op) */
daniele	29:1a47b7151851	314	static int release_until(struct pico_tcp_queue *q, uint32_t seq)
daniele	29:1a47b7151851	315	{
tass	110:0ece1bbbd36e	316	void *head = first_segment(q);
daniele	29:1a47b7151851	317	int ret = 0;
tass	110:0ece1bbbd36e	318	int seq_result = 0;
tass	110:0ece1bbbd36e	319	if(head)
tass	110:0ece1bbbd36e	320	seq_result = IS_INPUT_QUEUE(q) ?
tass	110:0ece1bbbd36e	321	seq_compare( ((struct tcp_input_segment )head)->seq + ((struct tcp_input_segment )head)->payload_len, seq) :
tass	110:0ece1bbbd36e	322	seq_compare(SEQN((struct pico_frame )head) + ((struct pico_frame )head)->payload_len, seq);
tass	110:0ece1bbbd36e	323
tass	110:0ece1bbbd36e	324	while (head && (seq_result <= 0)) {
tass	110:0ece1bbbd36e	325	void *cur = head;
daniele	29:1a47b7151851	326	head = next_segment(q, cur);
tass	37:bdf736327c71	327	tcp_dbg("Releasing %p\n", q);
daniele	29:1a47b7151851	328	pico_discard_segment(q, cur);
daniele	29:1a47b7151851	329	ret++;
tass	110:0ece1bbbd36e	330	if(head)
tass	110:0ece1bbbd36e	331	seq_result = IS_INPUT_QUEUE(q) ?
tass	110:0ece1bbbd36e	332	seq_compare( ((struct tcp_input_segment )head)->seq + ((struct tcp_input_segment )head)->payload_len, seq) :
tass	110:0ece1bbbd36e	333	seq_compare(SEQN((struct pico_frame )head) + ((struct pico_frame )head)->payload_len, seq);
daniele	29:1a47b7151851	334	}
daniele	29:1a47b7151851	335	return ret;
daniele	29:1a47b7151851	336	}
daniele	29:1a47b7151851	337
daniele	29:1a47b7151851	338	static int release_all_until(struct pico_tcp_queue *q, uint32_t seq)
daniele	29:1a47b7151851	339	{
tass	110:0ece1bbbd36e	340	void f = NULL, tmp __attribute__((unused));
daniele	29:1a47b7151851	341	struct pico_tree_node * idx, * temp;
tass	110:0ece1bbbd36e	342	int seq_result;
daniele	29:1a47b7151851	343	int ret = 0;
daniele	29:1a47b7151851	344
daniele	29:1a47b7151851	345	pico_tree_foreach_safe(idx,&q->pool,temp){
daniele	29:1a47b7151851	346	f = idx->keyValue;
tass	110:0ece1bbbd36e	347	seq_result = IS_INPUT_QUEUE(q) ?
tass	110:0ece1bbbd36e	348	seq_compare( ((struct tcp_input_segment )f)->seq + ((struct tcp_input_segment )f)->payload_len, seq):
tass	110:0ece1bbbd36e	349	seq_compare(SEQN((struct pico_frame )f) + ((struct pico_frame )f)->payload_len, seq);
tass	110:0ece1bbbd36e	350	if (seq_result<= 0) {
tass	37:bdf736327c71	351	tcp_dbg("Releasing %p\n", f);
daniele	29:1a47b7151851	352	pico_discard_segment(q, f);
daniele	29:1a47b7151851	353	ret++;
daniele	29:1a47b7151851	354	} else
daniele	29:1a47b7151851	355	return ret;
daniele	29:1a47b7151851	356	}
daniele	29:1a47b7151851	357	return ret;
daniele	29:1a47b7151851	358	}
daniele	29:1a47b7151851	359
daniele	29:1a47b7151851	360	/* API calls */
daniele	29:1a47b7151851	361
daniele	29:1a47b7151851	362	uint16_t pico_tcp_checksum_ipv4(struct pico_frame *f)
daniele	29:1a47b7151851	363	{
daniele	29:1a47b7151851	364	struct pico_ipv4_hdr hdr = (struct pico_ipv4_hdr ) f->net_hdr;
daniele	29:1a47b7151851	365	struct pico_tcp_hdr tcp_hdr = (struct pico_tcp_hdr ) f->transport_hdr;
daniele	29:1a47b7151851	366	struct pico_socket *s = f->sock;
daniele	29:1a47b7151851	367	struct pico_ipv4_pseudo_hdr pseudo;
daniele	29:1a47b7151851	368
daniele	29:1a47b7151851	369	if (s) {
daniele	29:1a47b7151851	370	/* Case of outgoing frame */
daniele	29:1a47b7151851	371	//dbg("TCP CRC: on outgoing frame\n");
daniele	29:1a47b7151851	372	pseudo.src.addr = s->local_addr.ip4.addr;
daniele	29:1a47b7151851	373	pseudo.dst.addr = s->remote_addr.ip4.addr;
daniele	29:1a47b7151851	374	} else {
daniele	29:1a47b7151851	375	/* Case of incomming frame */
daniele	29:1a47b7151851	376	//dbg("TCP CRC: on incomming frame\n");
daniele	29:1a47b7151851	377	pseudo.src.addr = hdr->src.addr;
daniele	29:1a47b7151851	378	pseudo.dst.addr = hdr->dst.addr;
daniele	29:1a47b7151851	379	}
daniele	29:1a47b7151851	380	pseudo.zeros = 0;
daniele	29:1a47b7151851	381	pseudo.proto = PICO_PROTO_TCP;
tass	70:cd218dd180e5	382	pseudo.len = (uint16_t)short_be(f->transport_len);
daniele	29:1a47b7151851	383
daniele	29:1a47b7151851	384	return pico_dualbuffer_checksum(&pseudo, sizeof(struct pico_ipv4_pseudo_hdr), tcp_hdr, f->transport_len);
daniele	29:1a47b7151851	385	}
daniele	29:1a47b7151851	386
tass	32:865c101e0874	387	static void tcp_send_fin(struct pico_socket_tcp *t);
daniele	29:1a47b7151851	388	static int pico_tcp_process_out(struct pico_protocol self, struct pico_frame f)
daniele	29:1a47b7151851	389	{
daniele	29:1a47b7151851	390	struct pico_tcp_hdr *hdr;
daniele	29:1a47b7151851	391	struct pico_socket_tcp t = (struct pico_socket_tcp )f->sock;
tass	68:0847e35d08a6	392	IGNORE_PARAMETER(self);
daniele	29:1a47b7151851	393	hdr = (struct pico_tcp_hdr *)f->transport_hdr;
tass	68:0847e35d08a6	394	f->sock->timestamp = PICO_TIME_MS();
daniele	29:1a47b7151851	395	if (f->payload_len > 0) {
daniele	29:1a47b7151851	396	tcp_dbg("Process out: sending %p (%d bytes)\n",f, f->payload_len);
daniele	29:1a47b7151851	397	} else {
daniele	29:1a47b7151851	398	tcp_dbg("Sending empty packet\n");
daniele	29:1a47b7151851	399	}
daniele	29:1a47b7151851	400
daniele	29:1a47b7151851	401	if (f->payload_len > 0) {
daniele	29:1a47b7151851	402	if (seq_compare(SEQN(f) + f->payload_len, t->snd_nxt) > 0) {
daniele	29:1a47b7151851	403	t->snd_nxt = SEQN(f) + f->payload_len;
daniele	29:1a47b7151851	404	tcp_dbg("%s: snd_nxt is now %08x\n", __FUNCTION__, t->snd_nxt);
daniele	29:1a47b7151851	405	}
daniele	29:1a47b7151851	406	} else if (hdr->flags == PICO_TCP_ACK) { /* pure ack */
tass	40:c8ab0d2bba0b	407	//hdr->seq = long_be(t->snd_nxt); /* XXX disabled this to not to mess with seq nrs of ACKs anymore */
daniele	29:1a47b7151851	408	} else {
daniele	29:1a47b7151851	409	tcp_dbg("%s: non-pure ACK with len=0, fl:%04x\n", __FUNCTION__, hdr->flags);
daniele	29:1a47b7151851	410	}
tass	32:865c101e0874	411
daniele	29:1a47b7151851	412	pico_network_send(f);
daniele	29:1a47b7151851	413	return 0;
daniele	29:1a47b7151851	414	}
daniele	29:1a47b7151851	415
tass	95:f4ca916a26fe	416	int32_t pico_tcp_push(struct pico_protocol self, struct pico_frame data);
daniele	29:1a47b7151851	417
daniele	29:1a47b7151851	418	/* Interface: protocol definition */
daniele	29:1a47b7151851	419	struct pico_protocol pico_proto_tcp = {
daniele	29:1a47b7151851	420	.name = "tcp",
daniele	29:1a47b7151851	421	.proto_number = PICO_PROTO_TCP,
daniele	29:1a47b7151851	422	.layer = PICO_LAYER_TRANSPORT,
daniele	29:1a47b7151851	423	.process_in = pico_transport_process_in,
daniele	29:1a47b7151851	424	.process_out = pico_tcp_process_out,
daniele	29:1a47b7151851	425	.push = pico_tcp_push,
daniele	29:1a47b7151851	426	.q_in = &tcp_in,
daniele	29:1a47b7151851	427	.q_out = &tcp_out,
daniele	29:1a47b7151851	428	};
daniele	29:1a47b7151851	429
daniele	29:1a47b7151851	430	static uint32_t pico_paws(void)
daniele	29:1a47b7151851	431	{
tass	74:c146c4e346c4	432	static uint32_t _paws = 0;
daniele	29:1a47b7151851	433	_paws = pico_rand();
daniele	29:1a47b7151851	434	return long_be(_paws); /XXX: implement paws /
daniele	29:1a47b7151851	435	}
daniele	29:1a47b7151851	436
tass	70:cd218dd180e5	437	static void tcp_add_options(struct pico_socket_tcp ts, struct pico_frame f, uint16_t flags, uint16_t optsiz)
daniele	29:1a47b7151851	438	{
daniele	29:1a47b7151851	439	uint32_t tsval = long_be(pico_tick);
daniele	29:1a47b7151851	440	uint32_t tsecr = long_be(ts->ts_nxt);
tass	70:cd218dd180e5	441	uint32_t i = 0;
daniele	29:1a47b7151851	442	f->start = f->transport_hdr + PICO_SIZE_TCPHDR;
daniele	29:1a47b7151851	443
daniele	29:1a47b7151851	444	memset(f->start, PICO_TCP_OPTION_NOOP, optsiz); /* fill blanks with noop */
daniele	29:1a47b7151851	445
daniele	29:1a47b7151851	446	if (flags & PICO_TCP_SYN) {
daniele	29:1a47b7151851	447	f->start[i++] = PICO_TCP_OPTION_MSS;
daniele	29:1a47b7151851	448	f->start[i++] = PICO_TCPOPTLEN_MSS;
tass	70:cd218dd180e5	449	f->start[i++] = (uint8_t)((ts->mss >> 8) & 0xFF);
tass	70:cd218dd180e5	450	f->start[i++] = (uint8_t)(ts->mss & 0xFF);
daniele	29:1a47b7151851	451	f->start[i++] = PICO_TCP_OPTION_SACK_OK;
daniele	29:1a47b7151851	452	f->start[i++] = PICO_TCPOPTLEN_SACK_OK;
daniele	29:1a47b7151851	453	}
daniele	29:1a47b7151851	454
daniele	29:1a47b7151851	455	f->start[i++] = PICO_TCP_OPTION_WS;
daniele	29:1a47b7151851	456	f->start[i++] = PICO_TCPOPTLEN_WS;
tass	70:cd218dd180e5	457	f->start[i++] = (uint8_t)(ts->wnd_scale);
daniele	29:1a47b7151851	458
daniele	29:1a47b7151851	459	if (optsiz >= 12) {
daniele	29:1a47b7151851	460	f->start[i++] = PICO_TCP_OPTION_TIMESTAMP;
daniele	29:1a47b7151851	461	f->start[i++] = PICO_TCPOPTLEN_TIMESTAMP;
daniele	29:1a47b7151851	462	memcpy(f->start + i, &tsval, 4);
daniele	29:1a47b7151851	463	i += 4;
daniele	29:1a47b7151851	464	memcpy(f->start + i, &tsecr, 4);
daniele	29:1a47b7151851	465	i += 4;
daniele	29:1a47b7151851	466	}
daniele	29:1a47b7151851	467
daniele	29:1a47b7151851	468	if (flags & PICO_TCP_ACK) {
daniele	29:1a47b7151851	469	struct tcp_sack_block *sb;
tass	70:cd218dd180e5	470	uint32_t len_off;
daniele	29:1a47b7151851	471
daniele	29:1a47b7151851	472	if (ts->sack_ok && ts->sacks) {
daniele	29:1a47b7151851	473	f->start[i++] = PICO_TCP_OPTION_SACK;
daniele	29:1a47b7151851	474	len_off = i;
daniele	29:1a47b7151851	475	f->start[i++] = PICO_TCPOPTLEN_SACK;
daniele	29:1a47b7151851	476	while(ts->sacks) {
daniele	29:1a47b7151851	477	sb = ts->sacks;
daniele	29:1a47b7151851	478	ts->sacks = sb->next;
daniele	29:1a47b7151851	479	memcpy(f->start + i, sb, 2 * sizeof(uint32_t));
tass	74:c146c4e346c4	480	i += (2 * (uint32_t)sizeof(uint32_t));
tass	73:dfb737147f6e	481	f->start[len_off] = (uint8_t)(f->start[len_off] + (2 * sizeof(uint32_t)));
daniele	29:1a47b7151851	482	pico_free(sb);
daniele	29:1a47b7151851	483	}
daniele	29:1a47b7151851	484	}
daniele	29:1a47b7151851	485	}
daniele	29:1a47b7151851	486	if (i < optsiz)
daniele	29:1a47b7151851	487	f->start[ optsiz - 1 ] = PICO_TCP_OPTION_END;
daniele	29:1a47b7151851	488	}
daniele	29:1a47b7151851	489
daniele	29:1a47b7151851	490	static void tcp_send_ack(struct pico_socket_tcp *t);
tass	75:a9abf10138d6	491	#define tcp_send_windowUpdate(t) (tcp_send_ack(t))
daniele	29:1a47b7151851	492
daniele	29:1a47b7151851	493	static void tcp_set_space(struct pico_socket_tcp *t)
daniele	29:1a47b7151851	494	{
tass	70:cd218dd180e5	495	uint32_t mtu;
tass	70:cd218dd180e5	496	int32_t space;
tass	70:cd218dd180e5	497	uint32_t shift = 0;
daniele	29:1a47b7151851	498
daniele	29:1a47b7151851	499	mtu = t->mss + PICO_SIZE_TCPHDR + PICO_SIZE_TCPOPT_SYN ;
daniele	29:1a47b7151851	500	if (t->tcpq_in.max_size == 0) {
daniele	29:1a47b7151851	501	space = 1024 * 1024 * 1024; /* One Gigabyte, for unlimited sockets. */
daniele	29:1a47b7151851	502	} else {
tass	70:cd218dd180e5	503	space = (int32_t)(((t->tcpq_in.max_size - t->tcpq_in.size) / mtu) * t->mss);
daniele	29:1a47b7151851	504	}
daniele	29:1a47b7151851	505	if (space < 0)
daniele	29:1a47b7151851	506	space = 0;
daniele	29:1a47b7151851	507	while(space > 0xFFFF) {
daniele	29:1a47b7151851	508	space >>= 1;
daniele	29:1a47b7151851	509	shift++;
daniele	29:1a47b7151851	510	}
daniele	29:1a47b7151851	511	if ((space != t->wnd) \|\| (shift != t->wnd_scale) \|\| ((space - t->wnd) > (space>>2))) {
tass	70:cd218dd180e5	512	t->wnd = (uint16_t)space;
tass	70:cd218dd180e5	513	t->wnd_scale = (uint16_t)shift;
tass	75:a9abf10138d6	514
tass	75:a9abf10138d6	515	if(t->wnd == 0) // mark the entering to zero window state
tass	75:a9abf10138d6	516	t->localZeroWindow = 1u;
tass	75:a9abf10138d6	517	else if(t->localZeroWindow)
tass	75:a9abf10138d6	518	{
tass	75:a9abf10138d6	519	t->localZeroWindow = 0u;
tass	75:a9abf10138d6	520	tcp_send_windowUpdate(t);
tass	75:a9abf10138d6	521	}
daniele	29:1a47b7151851	522	}
daniele	29:1a47b7151851	523	}
daniele	29:1a47b7151851	524
daniele	29:1a47b7151851	525	/* Return 32-bit aligned option size */
tass	70:cd218dd180e5	526	static uint16_t tcp_options_size(struct pico_socket_tcp *t, uint16_t flags)
daniele	29:1a47b7151851	527	{
tass	70:cd218dd180e5	528	uint16_t size = 0;
daniele	29:1a47b7151851	529	struct tcp_sack_block *sb = t->sacks;
daniele	29:1a47b7151851	530
daniele	29:1a47b7151851	531	if (flags & PICO_TCP_SYN) { /* Full options */
daniele	29:1a47b7151851	532	size = PICO_TCPOPTLEN_MSS + PICO_TCP_OPTION_SACK_OK + PICO_TCPOPTLEN_WS + PICO_TCPOPTLEN_TIMESTAMP;
daniele	29:1a47b7151851	533	} else {
daniele	29:1a47b7151851	534
daniele	29:1a47b7151851	535	/* Always update window scale. */
tass	73:dfb737147f6e	536	size = (uint16_t)(size + PICO_TCPOPTLEN_WS);
daniele	29:1a47b7151851	537
daniele	29:1a47b7151851	538	if (t->ts_ok)
tass	73:dfb737147f6e	539	size = (uint16_t)(size + PICO_TCPOPTLEN_TIMESTAMP);
daniele	29:1a47b7151851	540
tass	73:dfb737147f6e	541	size= (uint16_t)(size + PICO_TCPOPTLEN_END);
daniele	29:1a47b7151851	542	}
daniele	29:1a47b7151851	543	if ((flags & PICO_TCP_ACK) && (t->sack_ok && sb)) {
tass	73:dfb737147f6e	544	size = (uint16_t)(size + 2);
daniele	29:1a47b7151851	545	while(sb) {
tass	73:dfb737147f6e	546	size = (uint16_t)(size + (2 * sizeof(uint32_t)));
daniele	29:1a47b7151851	547	sb = sb->next;
daniele	29:1a47b7151851	548	}
daniele	29:1a47b7151851	549	}
tass	70:cd218dd180e5	550	size = (uint16_t)(((size + 3) >> 2) << 2);
daniele	29:1a47b7151851	551	return size;
daniele	29:1a47b7151851	552	}
daniele	29:1a47b7151851	553
tass	70:cd218dd180e5	554	uint16_t pico_tcp_overhead(struct pico_socket *s)
daniele	29:1a47b7151851	555	{
daniele	29:1a47b7151851	556	if (!s)
daniele	29:1a47b7151851	557	return 0;
daniele	29:1a47b7151851	558
tass	70:cd218dd180e5	559	return (uint16_t)(PICO_SIZE_TCPHDR + tcp_options_size((struct pico_socket_tcp )s, (uint16_t)0)); / hdr + Options size for data pkt */
daniele	29:1a47b7151851	560
daniele	29:1a47b7151851	561	}
daniele	29:1a47b7151851	562
daniele	29:1a47b7151851	563	static void tcp_process_sack(struct pico_socket_tcp *t, uint32_t start, uint32_t end)
daniele	29:1a47b7151851	564	{
daniele	29:1a47b7151851	565	struct pico_frame *f;
daniele	29:1a47b7151851	566	struct pico_tree_node * index, * temp;
daniele	29:1a47b7151851	567	int cmp;
tass	68:0847e35d08a6	568	uint16_t count = 0;
daniele	29:1a47b7151851	569
daniele	29:1a47b7151851	570	pico_tree_foreach_safe(index,&t->tcpq_out.pool,temp){
daniele	29:1a47b7151851	571	f = index->keyValue;
daniele	29:1a47b7151851	572	cmp = seq_compare(SEQN(f), start);
daniele	29:1a47b7151851	573	if (cmp > 0)
daniele	29:1a47b7151851	574	goto done;
daniele	29:1a47b7151851	575
daniele	29:1a47b7151851	576	if (cmp == 0) {
daniele	29:1a47b7151851	577	cmp = seq_compare(SEQN(f) + f->payload_len, end);
daniele	29:1a47b7151851	578	if (cmp > 0) {
daniele	29:1a47b7151851	579	tcp_dbg("Invalid SACK: ignoring.\n");
daniele	29:1a47b7151851	580	}
daniele	29:1a47b7151851	581
daniele	29:1a47b7151851	582	tcp_dbg("Marking (by SACK) segment %08x BLK:[%08x::%08x]\n", SEQN(f), start, end);
daniele	29:1a47b7151851	583	f->flags \|= PICO_FRAME_FLAG_SACKED;
daniele	29:1a47b7151851	584	count++;
daniele	29:1a47b7151851	585
daniele	29:1a47b7151851	586	if (cmp == 0) {
daniele	29:1a47b7151851	587	/* that was last segment sacked. Job done */
daniele	29:1a47b7151851	588	goto done;
daniele	29:1a47b7151851	589	}
daniele	29:1a47b7151851	590	}
daniele	29:1a47b7151851	591	}
daniele	29:1a47b7151851	592
daniele	29:1a47b7151851	593	done:
daniele	29:1a47b7151851	594	if (t->x_mode > PICO_TCP_LOOKAHEAD) {
daniele	29:1a47b7151851	595	if (t->in_flight > (count))
daniele	29:1a47b7151851	596	t->in_flight -= (count);
daniele	29:1a47b7151851	597	else
daniele	29:1a47b7151851	598	t->in_flight = 0;
daniele	29:1a47b7151851	599	}
daniele	29:1a47b7151851	600	}
daniele	29:1a47b7151851	601
tass	70:cd218dd180e5	602	inline static void tcp_add_header(struct pico_socket_tcp t, struct pico_frame f)
tass	70:cd218dd180e5	603	{
tass	70:cd218dd180e5	604	struct pico_tcp_hdr * hdr = (struct pico_tcp_hdr *)f->transport_hdr;
tass	70:cd218dd180e5	605	f->timestamp = pico_tick;
tass	70:cd218dd180e5	606	tcp_add_options(t, f, 0, (uint16_t)(f->transport_len - f->payload_len - (uint16_t)PICO_SIZE_TCPHDR));
tass	70:cd218dd180e5	607	hdr->rwnd = short_be(t->wnd);
tass	70:cd218dd180e5	608	hdr->flags \|= PICO_TCP_PSH;
tass	70:cd218dd180e5	609	hdr->ack = long_be(t->rcv_nxt);
tass	70:cd218dd180e5	610	hdr->crc = 0;
tass	70:cd218dd180e5	611	hdr->crc = short_be(pico_tcp_checksum_ipv4(f));
tass	70:cd218dd180e5	612	}
tass	70:cd218dd180e5	613
daniele	29:1a47b7151851	614	static void tcp_rcv_sack(struct pico_socket_tcp t, uint8_t opt, int len)
daniele	29:1a47b7151851	615	{
daniele	29:1a47b7151851	616	uint32_t start, end;
daniele	29:1a47b7151851	617	int i = 0;
daniele	29:1a47b7151851	618	if (len % 8) {
daniele	29:1a47b7151851	619	tcp_dbg("SACK: Invalid len.\n");
daniele	29:1a47b7151851	620	return;
daniele	29:1a47b7151851	621	}
daniele	29:1a47b7151851	622	while (i < len) {
daniele	29:1a47b7151851	623	start = long_from(opt + i);
daniele	29:1a47b7151851	624	i += 4;
daniele	29:1a47b7151851	625	end = long_from(opt + i);
daniele	29:1a47b7151851	626	i += 4;
daniele	29:1a47b7151851	627	tcp_process_sack(t, long_be(start), long_be(end));
daniele	29:1a47b7151851	628	}
daniele	29:1a47b7151851	629	}
daniele	29:1a47b7151851	630
daniele	29:1a47b7151851	631	static void tcp_parse_options(struct pico_frame *f)
daniele	29:1a47b7151851	632	{
daniele	29:1a47b7151851	633	struct pico_socket_tcp t = (struct pico_socket_tcp )f->sock;
daniele	29:1a47b7151851	634	uint8_t *opt = f->transport_hdr + PICO_SIZE_TCPHDR;
tass	68:0847e35d08a6	635	uint32_t i = 0;
tass	45:ca30069e49bb	636	f->timestamp = 0;
daniele	29:1a47b7151851	637	while (i < (f->transport_len - PICO_SIZE_TCPHDR)) {
daniele	29:1a47b7151851	638	uint8_t type = opt[i++];
daniele	29:1a47b7151851	639	uint8_t len;
daniele	29:1a47b7151851	640	if(i < (f->transport_len - PICO_SIZE_TCPHDR) && (type > 1))
daniele	29:1a47b7151851	641	len = opt[i++];
daniele	29:1a47b7151851	642	else
daniele	29:1a47b7151851	643	len = 1;
daniele	29:1a47b7151851	644	if (f->payload && ((opt + i) > f->payload))
daniele	29:1a47b7151851	645	break;
tass	45:ca30069e49bb	646	tcp_dbg_options("Received option '%d', len = %d \n", type, len);
daniele	29:1a47b7151851	647	switch (type) {
daniele	29:1a47b7151851	648	case PICO_TCP_OPTION_NOOP:
daniele	29:1a47b7151851	649	case PICO_TCP_OPTION_END:
daniele	29:1a47b7151851	650	break;
daniele	29:1a47b7151851	651	case PICO_TCP_OPTION_WS:
daniele	29:1a47b7151851	652	if (len != PICO_TCPOPTLEN_WS) {
tass	45:ca30069e49bb	653	tcp_dbg_options("TCP Window scale: bad len received (%d).\n", len);
tass	73:dfb737147f6e	654	i = i + len - 2;
daniele	29:1a47b7151851	655	break;
daniele	29:1a47b7151851	656	}
daniele	29:1a47b7151851	657	t->recv_wnd_scale = opt[i++];
tass	45:ca30069e49bb	658	tcp_dbg_options("TCP Window scale: received %d\n", t->recv_wnd_scale);
daniele	29:1a47b7151851	659	break;
daniele	29:1a47b7151851	660	case PICO_TCP_OPTION_SACK_OK:
daniele	29:1a47b7151851	661	if (len != PICO_TCPOPTLEN_SACK_OK) {
tass	45:ca30069e49bb	662	tcp_dbg_options("TCP option sack: bad len received.\n");
tass	73:dfb737147f6e	663	i = i + len - 2;
daniele	29:1a47b7151851	664	break;
daniele	29:1a47b7151851	665	}
daniele	29:1a47b7151851	666	t->sack_ok = 1;
daniele	29:1a47b7151851	667	break;
daniele	29:1a47b7151851	668	case PICO_TCP_OPTION_MSS: {
daniele	29:1a47b7151851	669	uint16_t mss;
daniele	29:1a47b7151851	670	if (len != PICO_TCPOPTLEN_MSS) {
tass	45:ca30069e49bb	671	tcp_dbg_options("TCP option mss: bad len received.\n");
tass	73:dfb737147f6e	672	i = i + len - 2;
daniele	29:1a47b7151851	673	break;
daniele	29:1a47b7151851	674	}
daniele	29:1a47b7151851	675	t->mss_ok = 1;
daniele	29:1a47b7151851	676	mss = short_from(opt + i);
tass	74:c146c4e346c4	677	i += (uint32_t)sizeof(uint16_t);
daniele	29:1a47b7151851	678	if (t->mss > short_be(mss))
daniele	29:1a47b7151851	679	t->mss = short_be(mss);
daniele	29:1a47b7151851	680	break;
daniele	29:1a47b7151851	681	}
daniele	29:1a47b7151851	682	case PICO_TCP_OPTION_TIMESTAMP: {
daniele	29:1a47b7151851	683	uint32_t tsval, tsecr;
daniele	29:1a47b7151851	684	if (len != PICO_TCPOPTLEN_TIMESTAMP) {
tass	45:ca30069e49bb	685	tcp_dbg_options("TCP option timestamp: bad len received.\n");
tass	73:dfb737147f6e	686	i = i + len - 2;
daniele	29:1a47b7151851	687	break;
daniele	29:1a47b7151851	688	}
daniele	29:1a47b7151851	689	t->ts_ok = 1;
daniele	29:1a47b7151851	690	tsval = long_from(opt + i);
tass	74:c146c4e346c4	691	i += (uint32_t)sizeof(uint32_t);
daniele	29:1a47b7151851	692	tsecr = long_from(opt + i);
daniele	29:1a47b7151851	693	f->timestamp = long_be(tsecr);
tass	74:c146c4e346c4	694	i += (uint32_t)sizeof(uint32_t);
daniele	29:1a47b7151851	695	t->ts_nxt = long_be(tsval);
daniele	29:1a47b7151851	696	break;
daniele	29:1a47b7151851	697	}
daniele	29:1a47b7151851	698	case PICO_TCP_OPTION_SACK:
daniele	29:1a47b7151851	699	{
daniele	29:1a47b7151851	700	tcp_rcv_sack(t, opt + i, len - 2);
tass	73:dfb737147f6e	701	i = i + len - 2;
daniele	29:1a47b7151851	702	break;
daniele	29:1a47b7151851	703	}
daniele	29:1a47b7151851	704	default:
tass	45:ca30069e49bb	705	tcp_dbg_options("TCP: received unsupported option %u\n", type);
tass	73:dfb737147f6e	706	i = i + len - 2;
daniele	29:1a47b7151851	707	}
daniele	29:1a47b7151851	708	}
daniele	29:1a47b7151851	709	}
daniele	29:1a47b7151851	710
daniele	29:1a47b7151851	711	static int tcp_send(struct pico_socket_tcp ts, struct pico_frame f)
daniele	29:1a47b7151851	712	{
daniele	29:1a47b7151851	713	struct pico_tcp_hdr hdr= (struct pico_tcp_hdr ) f->transport_hdr;
daniele	29:1a47b7151851	714	struct pico_frame *cpy;
daniele	29:1a47b7151851	715	hdr->trans.sport = ts->sock.local_port;
daniele	29:1a47b7151851	716	hdr->trans.dport = ts->sock.remote_port;
daniele	29:1a47b7151851	717	if (!hdr->seq)
daniele	29:1a47b7151851	718	hdr->seq = long_be(ts->snd_nxt);
daniele	29:1a47b7151851	719
daniele	29:1a47b7151851	720	if (ts->rcv_nxt != 0) {
daniele	29:1a47b7151851	721	if ( (ts->rcv_ackd == 0) \|\| (seq_compare(ts->rcv_ackd, ts->rcv_nxt) != 0) \|\| (hdr->flags & PICO_TCP_ACK)) {
daniele	29:1a47b7151851	722	hdr->flags \|= PICO_TCP_ACK;
daniele	29:1a47b7151851	723	hdr->ack = long_be(ts->rcv_nxt);
daniele	29:1a47b7151851	724	ts->rcv_ackd = ts->rcv_nxt;
daniele	29:1a47b7151851	725	}
daniele	29:1a47b7151851	726	}
daniele	29:1a47b7151851	727
daniele	29:1a47b7151851	728	if (hdr->flags & PICO_TCP_SYN) {
daniele	29:1a47b7151851	729	ts->snd_nxt++;
daniele	29:1a47b7151851	730	}
daniele	29:1a47b7151851	731	if (f->payload_len > 0) {
daniele	29:1a47b7151851	732	hdr->flags \|= PICO_TCP_PSH \| PICO_TCP_ACK;
daniele	29:1a47b7151851	733	hdr->ack = long_be(ts->rcv_nxt);
daniele	29:1a47b7151851	734	ts->rcv_ackd = ts->rcv_nxt;
tass	40:c8ab0d2bba0b	735	ts->keepalive_timer_running = 2; /* XXX TODO check fix: added 1 to counter to postpone sending keepalive, ACK is in data segments */
daniele	29:1a47b7151851	736	}
daniele	29:1a47b7151851	737
daniele	29:1a47b7151851	738	f->start = f->transport_hdr + PICO_SIZE_TCPHDR;
daniele	29:1a47b7151851	739	hdr->rwnd = short_be(ts->wnd);
daniele	29:1a47b7151851	740	hdr->crc = 0;
daniele	29:1a47b7151851	741	hdr->crc = short_be(pico_tcp_checksum_ipv4(f));
daniele	29:1a47b7151851	742
daniele	29:1a47b7151851	743	/* TCP: ENQUEUE to PROTO ( Transmit ) */
daniele	29:1a47b7151851	744	cpy = pico_frame_copy(f);
tass	40:c8ab0d2bba0b	745	if ((pico_enqueue(&tcp_out, cpy) > 0)) {
tass	40:c8ab0d2bba0b	746	if (f->payload_len > 0) {
daniele	29:1a47b7151851	747	ts->in_flight++;
tass	40:c8ab0d2bba0b	748	ts->snd_nxt += f->payload_len; /* update next pointer here to prevent sending same segment twice when called twice in same tick */
tass	40:c8ab0d2bba0b	749	}
daniele	29:1a47b7151851	750	tcp_dbg("DBG> [tcp output] state: %02x --> local port:%d remote port: %d seq: %08x ack: %08x flags: %02x = t_len: %d, hdr: %u payload: %d\n",
daniele	29:1a47b7151851	751	TCPSTATE(&ts->sock) >> 8, short_be(hdr->trans.sport), short_be(hdr->trans.dport), SEQN(f), ACKN(f), hdr->flags, f->transport_len, (hdr->len & 0xf0) >> 2 , f->payload_len );
daniele	29:1a47b7151851	752	} else {
daniele	29:1a47b7151851	753	pico_frame_discard(cpy);
daniele	29:1a47b7151851	754	}
daniele	29:1a47b7151851	755	return 0;
daniele	29:1a47b7151851	756	}
daniele	29:1a47b7151851	757
daniele	29:1a47b7151851	758	//#define PICO_TCP_SUPPORT_SOCKET_STATS
daniele	29:1a47b7151851	759
daniele	29:1a47b7151851	760	#ifdef PICO_TCP_SUPPORT_SOCKET_STATS
tass	73:dfb737147f6e	761	static void sock_stats(uint32_t when, void *arg)
daniele	29:1a47b7151851	762	{
daniele	29:1a47b7151851	763	struct pico_socket_tcp t = (struct pico_socket_tcp )arg;
daniele	29:1a47b7151851	764	tcp_dbg("STATISTIC> [%lu] socket state: %02x --> local port:%d remote port: %d queue size: %d snd_una: %08x snd_nxt: %08x timer: %d cwnd: %d\n",
daniele	29:1a47b7151851	765	when, t->sock.state, short_be(t->sock.local_port), short_be(t->sock.remote_port), t->tcpq_out.size, SEQN(first_segment(&t->tcpq_out)), t->snd_nxt, t->timer_running, t->cwnd);
daniele	29:1a47b7151851	766	pico_timer_add(2000, sock_stats, t);
daniele	29:1a47b7151851	767	}
daniele	29:1a47b7151851	768	#endif
daniele	29:1a47b7151851	769
daniele	29:1a47b7151851	770	struct pico_socket *pico_tcp_open(void)
daniele	29:1a47b7151851	771	{
daniele	29:1a47b7151851	772	struct pico_socket_tcp *t = pico_zalloc(sizeof(struct pico_socket_tcp));
daniele	29:1a47b7151851	773	if (!t)
daniele	29:1a47b7151851	774	return NULL;
tass	68:0847e35d08a6	775	t->sock.timestamp = PICO_TIME_MS();
daniele	29:1a47b7151851	776	t->mss = PICO_TCP_DEFAULT_MSS;
daniele	29:1a47b7151851	777
daniele	29:1a47b7151851	778	t->tcpq_in.pool.root = t->tcpq_hold.pool.root = t->tcpq_out.pool.root = &LEAF;
tass	110:0ece1bbbd36e	779	t->tcpq_hold.pool.compare = t->tcpq_out.pool.compare = segment_compare;
tass	110:0ece1bbbd36e	780	t->tcpq_in.pool.compare = input_segment_compare;
daniele	29:1a47b7151851	781	t->tcpq_in.max_size = PICO_DEFAULT_SOCKETQ;
daniele	29:1a47b7151851	782	t->tcpq_out.max_size = PICO_DEFAULT_SOCKETQ;
daniele	29:1a47b7151851	783	t->tcpq_hold.max_size = 2*PICO_TCP_DEFAULT_MSS;
tass	111:4003cf17bc15	784	t->tcpq_in.overhead=(sizeof(struct tcp_input_segment)+sizeof(struct pico_tree_node));
tass	111:4003cf17bc15	785	t->tcpq_out.overhead=t->tcpq_hold.overhead=sizeof(struct pico_frame)+sizeof(struct pico_tree_node);
tass	40:c8ab0d2bba0b	786	/* disable Nagle by default */
tass	68:0847e35d08a6	787	//t->sock.opt_flags \|= (1 << PICO_SOCKET_OPT_TCPNODELAY);
tass	68:0847e35d08a6	788	/* Nagle is enabled by default */
tass	73:dfb737147f6e	789	t->sock.opt_flags &= (uint16_t)~(1 << PICO_SOCKET_OPT_TCPNODELAY);
daniele	29:1a47b7151851	790
daniele	29:1a47b7151851	791	#ifdef PICO_TCP_SUPPORT_SOCKET_STATS
daniele	29:1a47b7151851	792	pico_timer_add(2000, sock_stats, t);
daniele	29:1a47b7151851	793	#endif
daniele	29:1a47b7151851	794	tcp_set_space(t);
daniele	29:1a47b7151851	795
daniele	29:1a47b7151851	796	return &t->sock;
daniele	29:1a47b7151851	797	}
daniele	29:1a47b7151851	798
tass	70:cd218dd180e5	799	uint32_t pico_tcp_read(struct pico_socket s, void buf, uint32_t len)
daniele	29:1a47b7151851	800	{
daniele	29:1a47b7151851	801	struct pico_socket_tcp *t = TCP_SOCK(s);
tass	110:0ece1bbbd36e	802	struct tcp_input_segment *f;
daniele	29:1a47b7151851	803	uint32_t in_frame_off, in_frame_len;
tass	70:cd218dd180e5	804	uint32_t tot_rd_len = 0;
daniele	29:1a47b7151851	805
daniele	29:1a47b7151851	806	while (tot_rd_len < len) {
daniele	29:1a47b7151851	807	/* To be sure we don't have garbage at the beginning */
daniele	29:1a47b7151851	808	release_until(&t->tcpq_in, t->rcv_processed);
daniele	29:1a47b7151851	809	f = first_segment(&t->tcpq_in);
daniele	29:1a47b7151851	810	if (!f) {
daniele	29:1a47b7151851	811	tcp_set_space(t);
daniele	29:1a47b7151851	812	goto out;
daniele	29:1a47b7151851	813	}
daniele	29:1a47b7151851	814
daniele	29:1a47b7151851	815	/* Hole at the beginning of data, awaiting retransmissions. */
tass	110:0ece1bbbd36e	816	if (seq_compare(t->rcv_processed, f->seq) < 0) {
tass	110:0ece1bbbd36e	817	tcp_dbg("TCP> read hole beginning of data, %08x - %08x. rcv_nxt is %08x\n",t->rcv_processed, f->seq, t->rcv_nxt);
daniele	29:1a47b7151851	818	goto out;
daniele	29:1a47b7151851	819	}
daniele	29:1a47b7151851	820
tass	110:0ece1bbbd36e	821	if(seq_compare(t->rcv_processed, f->seq) > 0) {
tass	110:0ece1bbbd36e	822	in_frame_off = t->rcv_processed - f->seq;
daniele	29:1a47b7151851	823	in_frame_len = f->payload_len - in_frame_off;
daniele	29:1a47b7151851	824	} else {
daniele	29:1a47b7151851	825	in_frame_off = 0;
daniele	29:1a47b7151851	826	in_frame_len = f->payload_len;
daniele	29:1a47b7151851	827	}
tass	68:0847e35d08a6	828	if ((in_frame_len + tot_rd_len) > (uint32_t)len) {
daniele	29:1a47b7151851	829	in_frame_len = len - tot_rd_len;
daniele	29:1a47b7151851	830	}
daniele	29:1a47b7151851	831
daniele	29:1a47b7151851	832	if (in_frame_len > f->payload_len - in_frame_off)
daniele	29:1a47b7151851	833	in_frame_len = f->payload_len - in_frame_off;
daniele	29:1a47b7151851	834
daniele	29:1a47b7151851	835	memcpy((uint8_t *)buf + tot_rd_len, f->payload + in_frame_off, in_frame_len);
daniele	29:1a47b7151851	836	tot_rd_len += in_frame_len;
daniele	29:1a47b7151851	837	t->rcv_processed += in_frame_len;
daniele	29:1a47b7151851	838
tass	68:0847e35d08a6	839	if ((in_frame_len == 0u) \|\| (in_frame_len == (uint32_t)f->payload_len)) {
daniele	29:1a47b7151851	840	pico_discard_segment(&t->tcpq_in, f);
daniele	29:1a47b7151851	841	}
daniele	29:1a47b7151851	842	}
daniele	29:1a47b7151851	843
daniele	29:1a47b7151851	844	out:
daniele	29:1a47b7151851	845	tcp_set_space(t);
daniele	29:1a47b7151851	846	if (t->tcpq_in.size == 0) {
tass	70:cd218dd180e5	847	s->ev_pending &= (uint16_t)(~PICO_SOCK_EV_RD);
daniele	29:1a47b7151851	848	}
daniele	29:1a47b7151851	849	return tot_rd_len;
daniele	29:1a47b7151851	850	}
daniele	29:1a47b7151851	851
daniele	29:1a47b7151851	852	int pico_tcp_initconn(struct pico_socket *s);
tass	73:dfb737147f6e	853	static void initconn_retry(uint32_t when, void *arg)
daniele	29:1a47b7151851	854	{
daniele	29:1a47b7151851	855	struct pico_socket_tcp t = (struct pico_socket_tcp )arg;
tass	68:0847e35d08a6	856	IGNORE_PARAMETER(when);
daniele	29:1a47b7151851	857	if (TCPSTATE(&t->sock) == PICO_SOCKET_STATE_TCP_SYN_SENT) {
daniele	29:1a47b7151851	858	if (t->backoff > PICO_TCP_MAX_CONNECT_RETRIES) {
daniele	29:1a47b7151851	859	tcp_dbg("TCP> Connection timeout. \n");
daniele	29:1a47b7151851	860	if (t->sock.wakeup)
daniele	29:1a47b7151851	861	t->sock.wakeup(PICO_SOCK_EV_ERR, &t->sock);
daniele	29:1a47b7151851	862	return;
daniele	29:1a47b7151851	863	}
daniele	29:1a47b7151851	864	tcp_dbg("TCP> SYN retry %d...\n", t->backoff);
daniele	29:1a47b7151851	865	t->backoff++;
daniele	29:1a47b7151851	866	pico_tcp_initconn(&t->sock);
daniele	29:1a47b7151851	867	} else {
daniele	29:1a47b7151851	868	tcp_dbg("TCP> Connection is already established: no retry needed. good.\n");
daniele	29:1a47b7151851	869	}
daniele	29:1a47b7151851	870	}
daniele	29:1a47b7151851	871
daniele	29:1a47b7151851	872	int pico_tcp_initconn(struct pico_socket *s)
daniele	29:1a47b7151851	873	{
daniele	29:1a47b7151851	874	struct pico_socket_tcp *ts = TCP_SOCK(s);
daniele	29:1a47b7151851	875	struct pico_frame *syn;
daniele	29:1a47b7151851	876	struct pico_tcp_hdr *hdr;
tass	70:cd218dd180e5	877	uint16_t opt_len = tcp_options_size(ts, PICO_TCP_SYN);
daniele	29:1a47b7151851	878
tass	70:cd218dd180e5	879	syn = s->net->alloc(s->net, (uint16_t)(PICO_SIZE_TCPHDR + opt_len));
daniele	29:1a47b7151851	880	if (!syn)
daniele	29:1a47b7151851	881	return -1;
daniele	29:1a47b7151851	882	hdr = (struct pico_tcp_hdr *) syn->transport_hdr;
daniele	29:1a47b7151851	883
daniele	29:1a47b7151851	884	if (!ts->snd_nxt)
daniele	29:1a47b7151851	885	ts->snd_nxt = long_be(pico_paws());
daniele	29:1a47b7151851	886	ts->snd_last = ts->snd_nxt;
daniele	29:1a47b7151851	887	ts->cwnd = PICO_TCP_IW;
daniele	29:1a47b7151851	888	ts->ssthresh = 40;
daniele	29:1a47b7151851	889	syn->sock = s;
daniele	29:1a47b7151851	890	hdr->seq = long_be(ts->snd_nxt);
tass	70:cd218dd180e5	891	hdr->len = (uint8_t)((PICO_SIZE_TCPHDR + opt_len) << 2 \| ts->jumbo);
daniele	29:1a47b7151851	892	hdr->flags = PICO_TCP_SYN;
daniele	29:1a47b7151851	893	tcp_set_space(ts);
daniele	29:1a47b7151851	894	hdr->rwnd = short_be(ts->wnd);
daniele	29:1a47b7151851	895	tcp_add_options(ts,syn, PICO_TCP_SYN, opt_len);
daniele	29:1a47b7151851	896	hdr->trans.sport = ts->sock.local_port;
daniele	29:1a47b7151851	897	hdr->trans.dport = ts->sock.remote_port;
daniele	29:1a47b7151851	898
daniele	29:1a47b7151851	899	hdr->crc = 0;
daniele	29:1a47b7151851	900	hdr->crc = short_be(pico_tcp_checksum_ipv4(syn));
daniele	29:1a47b7151851	901
daniele	29:1a47b7151851	902	/* TCP: ENQUEUE to PROTO ( SYN ) */
daniele	29:1a47b7151851	903	tcp_dbg("Sending SYN... (ports: %d - %d) size: %d\n", short_be(ts->sock.local_port), short_be(ts->sock.remote_port), syn->buffer_len);
daniele	29:1a47b7151851	904	pico_enqueue(&tcp_out, syn);
tass	37:bdf736327c71	905	pico_timer_add(PICO_TCP_SYN_TO << ts->backoff, initconn_retry, ts);
daniele	29:1a47b7151851	906	return 0;
daniele	29:1a47b7151851	907	}
daniele	29:1a47b7151851	908
daniele	29:1a47b7151851	909	static int tcp_send_synack(struct pico_socket *s)
daniele	29:1a47b7151851	910	{
daniele	29:1a47b7151851	911	struct pico_socket_tcp *ts = TCP_SOCK(s);
daniele	29:1a47b7151851	912	struct pico_frame *synack;
daniele	29:1a47b7151851	913	struct pico_tcp_hdr *hdr;
tass	70:cd218dd180e5	914	uint16_t opt_len = tcp_options_size(ts, PICO_TCP_SYN \| PICO_TCP_ACK);
daniele	29:1a47b7151851	915
tass	70:cd218dd180e5	916	synack = s->net->alloc(s->net, (uint16_t)(PICO_SIZE_TCPHDR + opt_len));
daniele	29:1a47b7151851	917	if (!synack)
daniele	29:1a47b7151851	918	return -1;
daniele	29:1a47b7151851	919	hdr = (struct pico_tcp_hdr *) synack->transport_hdr;
daniele	29:1a47b7151851	920
daniele	29:1a47b7151851	921	synack->sock = s;
tass	70:cd218dd180e5	922	hdr->len = (uint8_t)((PICO_SIZE_TCPHDR + opt_len) << 2 \| ts->jumbo);
daniele	29:1a47b7151851	923	hdr->flags = PICO_TCP_SYN \| PICO_TCP_ACK;
daniele	29:1a47b7151851	924	hdr->rwnd = short_be(ts->wnd);
daniele	29:1a47b7151851	925	hdr->seq = long_be(ts->snd_nxt);
daniele	29:1a47b7151851	926	ts->rcv_processed = long_be(hdr->seq);
daniele	29:1a47b7151851	927	ts->snd_last = ts->snd_nxt;
daniele	29:1a47b7151851	928	tcp_set_space(ts);
daniele	29:1a47b7151851	929	tcp_add_options(ts,synack, hdr->flags, opt_len);
daniele	29:1a47b7151851	930	synack->payload_len = 0;
daniele	29:1a47b7151851	931	synack->timestamp = pico_tick;
daniele	29:1a47b7151851	932	tcp_send(ts, synack);
daniele	29:1a47b7151851	933	pico_frame_discard(synack);
daniele	29:1a47b7151851	934	return 0;
daniele	29:1a47b7151851	935	}
daniele	29:1a47b7151851	936
daniele	29:1a47b7151851	937	static void tcp_send_empty(struct pico_socket_tcp *t, uint16_t flags)
daniele	29:1a47b7151851	938	{
daniele	29:1a47b7151851	939	struct pico_frame *f;
daniele	29:1a47b7151851	940	struct pico_tcp_hdr *hdr;
tass	70:cd218dd180e5	941	uint16_t opt_len = tcp_options_size(t, flags);
tass	70:cd218dd180e5	942	f = t->sock.net->alloc(t->sock.net, (uint16_t)(PICO_SIZE_TCPHDR + opt_len));
daniele	29:1a47b7151851	943	if (!f) {
daniele	29:1a47b7151851	944	return;
daniele	29:1a47b7151851	945	}
daniele	29:1a47b7151851	946	f->sock = &t->sock;
daniele	29:1a47b7151851	947	hdr = (struct pico_tcp_hdr *) f->transport_hdr;
tass	70:cd218dd180e5	948	hdr->len = (uint8_t)((PICO_SIZE_TCPHDR + opt_len) << 2 \| t->jumbo);
tass	70:cd218dd180e5	949	hdr->flags = (uint8_t)flags;
daniele	29:1a47b7151851	950	hdr->rwnd = short_be(t->wnd);
daniele	29:1a47b7151851	951	tcp_set_space(t);
daniele	29:1a47b7151851	952	tcp_add_options(t,f, flags, opt_len);
daniele	29:1a47b7151851	953	hdr->trans.sport = t->sock.local_port;
daniele	29:1a47b7151851	954	hdr->trans.dport = t->sock.remote_port;
daniele	29:1a47b7151851	955	hdr->seq = long_be(t->snd_nxt);
daniele	29:1a47b7151851	956	if ((flags & PICO_TCP_ACK) != 0)
daniele	29:1a47b7151851	957	hdr->ack = long_be(t->rcv_nxt);
daniele	29:1a47b7151851	958	t->rcv_ackd = t->rcv_nxt;
daniele	29:1a47b7151851	959
daniele	29:1a47b7151851	960	f->start = f->transport_hdr + PICO_SIZE_TCPHDR;
daniele	29:1a47b7151851	961	hdr->rwnd = short_be(t->wnd);
daniele	29:1a47b7151851	962	hdr->crc = 0;
daniele	29:1a47b7151851	963	hdr->crc = short_be(pico_tcp_checksum_ipv4(f));
daniele	29:1a47b7151851	964
daniele	29:1a47b7151851	965	/* TCP: ENQUEUE to PROTO */
daniele	29:1a47b7151851	966	pico_enqueue(&tcp_out, f);
daniele	29:1a47b7151851	967	}
daniele	29:1a47b7151851	968
daniele	29:1a47b7151851	969	static void tcp_send_ack(struct pico_socket_tcp *t)
daniele	29:1a47b7151851	970	{
daniele	29:1a47b7151851	971	return tcp_send_empty(t, PICO_TCP_ACK);
daniele	29:1a47b7151851	972	}
daniele	29:1a47b7151851	973
daniele	29:1a47b7151851	974	static int tcp_send_rst(struct pico_socket s, struct pico_frame fr)
daniele	29:1a47b7151851	975	{
daniele	29:1a47b7151851	976	struct pico_socket_tcp t = (struct pico_socket_tcp ) s;
daniele	29:1a47b7151851	977	struct pico_frame *f;
daniele	29:1a47b7151851	978	struct pico_tcp_hdr hdr, hdr_rcv;
tass	70:cd218dd180e5	979	uint16_t opt_len = tcp_options_size(t, PICO_TCP_RST);
daniele	29:1a47b7151851	980	int close;
daniele	29:1a47b7151851	981
daniele	29:1a47b7151851	982	tcp_dbg("TCP SEND_RST >>>>>>>>>>>>>>> START\n");
daniele	29:1a47b7151851	983
tass	70:cd218dd180e5	984	f = t->sock.net->alloc(t->sock.net, (uint16_t)(PICO_SIZE_TCPHDR + opt_len));
daniele	29:1a47b7151851	985
daniele	29:1a47b7151851	986	if (!f) {
daniele	29:1a47b7151851	987	return -1;
daniele	29:1a47b7151851	988	}
daniele	29:1a47b7151851	989
daniele	29:1a47b7151851	990	hdr_rcv = (struct pico_tcp_hdr *) fr->transport_hdr;
daniele	29:1a47b7151851	991
daniele	29:1a47b7151851	992	f->sock = &t->sock;
daniele	29:1a47b7151851	993	hdr = (struct pico_tcp_hdr *) f->transport_hdr;
tass	70:cd218dd180e5	994	hdr->len = (uint8_t)((PICO_SIZE_TCPHDR + opt_len) << 2 \| t->jumbo);
daniele	29:1a47b7151851	995	hdr->flags = PICO_TCP_RST;
daniele	29:1a47b7151851	996	hdr->rwnd = short_be(t->wnd);
daniele	29:1a47b7151851	997	tcp_set_space(t);
daniele	29:1a47b7151851	998	tcp_add_options(t,f, PICO_TCP_RST, opt_len);
daniele	29:1a47b7151851	999	hdr->trans.sport = t->sock.local_port;
daniele	29:1a47b7151851	1000	hdr->trans.dport = t->sock.remote_port;
daniele	29:1a47b7151851	1001	hdr->seq = long_be(t->snd_nxt);
daniele	29:1a47b7151851	1002
daniele	29:1a47b7151851	1003	/* check if state is synchronized */
daniele	29:1a47b7151851	1004	if (((s->state & PICO_SOCKET_STATE_TCP) > PICO_SOCKET_STATE_TCP_SYN_RECV)) {
daniele	29:1a47b7151851	1005	/* in synchronized state: send RST with seq = ack from previous segment */
daniele	29:1a47b7151851	1006	hdr->seq = hdr_rcv->ack;
daniele	29:1a47b7151851	1007	close = 0;
daniele	29:1a47b7151851	1008	} else {
daniele	29:1a47b7151851	1009	/* non-synchronized state */
daniele	29:1a47b7151851	1010	/* go to CLOSED here to prevent timer callback to go on after timeout */
daniele	29:1a47b7151851	1011	(t->sock).state &= 0x00FFU;
daniele	29:1a47b7151851	1012	(t->sock).state \|= PICO_SOCKET_STATE_TCP_CLOSED;
daniele	29:1a47b7151851	1013	close = 1;
daniele	29:1a47b7151851	1014	}
daniele	29:1a47b7151851	1015
daniele	29:1a47b7151851	1016	hdr->ack = long_be(t->rcv_nxt);
daniele	29:1a47b7151851	1017	t->rcv_ackd = t->rcv_nxt;
daniele	29:1a47b7151851	1018	f->start = f->transport_hdr + PICO_SIZE_TCPHDR;
daniele	29:1a47b7151851	1019	hdr->rwnd = short_be(t->wnd);
daniele	29:1a47b7151851	1020	hdr->crc = 0;
daniele	29:1a47b7151851	1021	hdr->crc = short_be(pico_tcp_checksum_ipv4(f));
daniele	29:1a47b7151851	1022
daniele	29:1a47b7151851	1023	/* TCP: ENQUEUE to PROTO */
daniele	29:1a47b7151851	1024	pico_enqueue(&tcp_out, f);
daniele	29:1a47b7151851	1025
daniele	29:1a47b7151851	1026	/* goto CLOSED */
daniele	29:1a47b7151851	1027	if (close) {
daniele	29:1a47b7151851	1028	(t->sock).state &= 0xFF00U;
daniele	29:1a47b7151851	1029	(t->sock).state \|= PICO_SOCKET_STATE_CLOSED;
daniele	29:1a47b7151851	1030
daniele	29:1a47b7151851	1031	/* call EV_FIN wakeup before deleting */
daniele	29:1a47b7151851	1032	if ((t->sock).wakeup)
daniele	29:1a47b7151851	1033	(t->sock).wakeup(PICO_SOCK_EV_FIN, &(t->sock));
daniele	29:1a47b7151851	1034
daniele	29:1a47b7151851	1035	/* delete socket */
daniele	29:1a47b7151851	1036	pico_socket_del(&t->sock);
daniele	29:1a47b7151851	1037
daniele	29:1a47b7151851	1038	tcp_dbg("TCP SEND_RST >>>>>>>>>>>>>>> DONE, deleted socket\n");
daniele	29:1a47b7151851	1039	}
daniele	29:1a47b7151851	1040
daniele	29:1a47b7151851	1041	return 0;
daniele	29:1a47b7151851	1042	}
daniele	29:1a47b7151851	1043
daniele	29:1a47b7151851	1044	int pico_tcp_reply_rst(struct pico_frame *fr)
daniele	29:1a47b7151851	1045	{
daniele	29:1a47b7151851	1046	struct pico_tcp_hdr *hdr;
daniele	29:1a47b7151851	1047	struct pico_frame *f;
tass	70:cd218dd180e5	1048	uint16_t size = PICO_SIZE_TCPHDR;
daniele	29:1a47b7151851	1049
daniele	29:1a47b7151851	1050	tcp_dbg("TCP>>>>>>>>>>>>>>>> sending RST ... <<<<<<<<<<<<<<<<<<\n");
daniele	29:1a47b7151851	1051
daniele	29:1a47b7151851	1052	f = fr->sock->net->alloc(fr->sock->net, size);
daniele	29:1a47b7151851	1053
daniele	29:1a47b7151851	1054	/* fill in IP data from original frame */
daniele	29:1a47b7151851	1055	// TODO if IPv4
daniele	29:1a47b7151851	1056	((struct pico_ipv4_hdr )(f->net_hdr))->dst.addr = ((struct pico_ipv4_hdr )(fr->net_hdr))->src.addr;
daniele	29:1a47b7151851	1057	((struct pico_ipv4_hdr )(f->net_hdr))->src.addr = ((struct pico_ipv4_hdr )(fr->net_hdr))->dst.addr;
daniele	29:1a47b7151851	1058
daniele	29:1a47b7151851	1059	/* fill in TCP data from original frame */
daniele	29:1a47b7151851	1060	((struct pico_tcp_hdr )(f->transport_hdr))->trans.dport = ((struct pico_tcp_hdr )(fr->transport_hdr))->trans.sport;
daniele	29:1a47b7151851	1061	((struct pico_tcp_hdr )(f->transport_hdr))->trans.sport = ((struct pico_tcp_hdr )(fr->transport_hdr))->trans.dport;
daniele	29:1a47b7151851	1062	hdr = (struct pico_tcp_hdr *) f->transport_hdr;
tass	70:cd218dd180e5	1063	hdr->len = (uint8_t)(size << 2);
daniele	29:1a47b7151851	1064	hdr->flags = PICO_TCP_RST \| PICO_TCP_ACK;
daniele	29:1a47b7151851	1065	hdr->rwnd = 0;
daniele	29:1a47b7151851	1066	if (((struct pico_tcp_hdr *)(fr->transport_hdr))->flags & PICO_TCP_ACK) {
daniele	29:1a47b7151851	1067	hdr->seq = ((struct pico_tcp_hdr *)(fr->transport_hdr))->ack;
daniele	29:1a47b7151851	1068	} else {
daniele	29:1a47b7151851	1069	hdr->seq = 0U;
daniele	29:1a47b7151851	1070	}
daniele	29:1a47b7151851	1071
tass	116:34b8859c5537	1072	hdr->ack = long_be(long_be(((struct pico_tcp_hdr *)(fr->transport_hdr))->seq) + fr->payload_len);
tass	107:841ae542f96c	1073	hdr->crc = short_be(pico_tcp_checksum_ipv4(f));
daniele	29:1a47b7151851	1074	/* enqueue for transmission */
daniele	29:1a47b7151851	1075	pico_ipv4_frame_push(f,&(((struct pico_ipv4_hdr *)(f->net_hdr))->dst),PICO_PROTO_TCP);
daniele	29:1a47b7151851	1076
daniele	29:1a47b7151851	1077	return 0;
daniele	29:1a47b7151851	1078	}
daniele	29:1a47b7151851	1079
daniele	29:1a47b7151851	1080	static int tcp_nosync_rst(struct pico_socket s, struct pico_frame fr)
daniele	29:1a47b7151851	1081	{
daniele	29:1a47b7151851	1082	struct pico_socket_tcp t = (struct pico_socket_tcp ) s;
daniele	29:1a47b7151851	1083	struct pico_frame *f;
daniele	29:1a47b7151851	1084	struct pico_tcp_hdr hdr, hdr_rcv;
tass	70:cd218dd180e5	1085	uint16_t opt_len = tcp_options_size(t, PICO_TCP_RST \| PICO_TCP_ACK);
daniele	29:1a47b7151851	1086
daniele	29:1a47b7151851	1087	tcp_dbg("TCP SEND RST (NON-SYNC) >>>>>>>>>>>>>>>>>> state %x\n",(s->state & PICO_SOCKET_STATE_TCP));
daniele	29:1a47b7151851	1088	if (((s->state & PICO_SOCKET_STATE_TCP) == PICO_SOCKET_STATE_TCP_LISTEN)) {
daniele	29:1a47b7151851	1089	/* XXX TODO NOTE: to prevent the parent socket from trying to send, because this socket has no knowledge of dst IP !!! */
daniele	29:1a47b7151851	1090	return pico_tcp_reply_rst(fr);
daniele	29:1a47b7151851	1091	}
daniele	29:1a47b7151851	1092
daniele	29:1a47b7151851	1093	/***************************************************************************/
daniele	29:1a47b7151851	1094	/* sending RST */
tass	70:cd218dd180e5	1095	f = t->sock.net->alloc(t->sock.net, (uint16_t)(PICO_SIZE_TCPHDR + opt_len));
daniele	29:1a47b7151851	1096
daniele	29:1a47b7151851	1097	if (!f) {
daniele	29:1a47b7151851	1098	return -1;
daniele	29:1a47b7151851	1099	}
daniele	29:1a47b7151851	1100
daniele	29:1a47b7151851	1101	hdr_rcv = (struct pico_tcp_hdr *) fr->transport_hdr;
daniele	29:1a47b7151851	1102
daniele	29:1a47b7151851	1103	f->sock = &t->sock;
daniele	29:1a47b7151851	1104	hdr = (struct pico_tcp_hdr *) f->transport_hdr;
tass	70:cd218dd180e5	1105	hdr->len = (uint8_t)((PICO_SIZE_TCPHDR + opt_len) << 2 \| t->jumbo);
daniele	29:1a47b7151851	1106	hdr->flags = PICO_TCP_RST \| PICO_TCP_ACK;
daniele	29:1a47b7151851	1107	hdr->rwnd = short_be(t->wnd);
daniele	29:1a47b7151851	1108	tcp_set_space(t);
daniele	29:1a47b7151851	1109	tcp_add_options(t,f, PICO_TCP_RST \| PICO_TCP_ACK, opt_len);
daniele	29:1a47b7151851	1110	hdr->trans.sport = t->sock.local_port;
daniele	29:1a47b7151851	1111	hdr->trans.dport = t->sock.remote_port;
daniele	29:1a47b7151851	1112
daniele	29:1a47b7151851	1113	/* non-synchronized state */
daniele	29:1a47b7151851	1114	if (hdr_rcv->flags & PICO_TCP_ACK) {
daniele	29:1a47b7151851	1115	hdr->seq = hdr_rcv->ack;
daniele	29:1a47b7151851	1116	} else {
daniele	29:1a47b7151851	1117	hdr->seq = 0U;
daniele	29:1a47b7151851	1118	}
daniele	29:1a47b7151851	1119
tass	93:e7a58195bfb7	1120	hdr->ack = hdr_rcv->seq + long_be(fr->payload_len);
daniele	29:1a47b7151851	1121
daniele	29:1a47b7151851	1122	t->rcv_ackd = t->rcv_nxt;
daniele	29:1a47b7151851	1123	f->start = f->transport_hdr + PICO_SIZE_TCPHDR;
daniele	29:1a47b7151851	1124	hdr->rwnd = short_be(t->wnd);
daniele	29:1a47b7151851	1125	hdr->crc = 0;
daniele	29:1a47b7151851	1126	hdr->crc = short_be(pico_tcp_checksum_ipv4(f));
daniele	29:1a47b7151851	1127
daniele	29:1a47b7151851	1128	/* TCP: ENQUEUE to PROTO */
daniele	29:1a47b7151851	1129	pico_enqueue(&tcp_out, f);
daniele	29:1a47b7151851	1130
daniele	29:1a47b7151851	1131	/***************************************************************************/
daniele	29:1a47b7151851	1132
daniele	29:1a47b7151851	1133	tcp_dbg("TCP SEND_RST (NON_SYNC) >>>>>>>>>>>>>>> DONE, ...\n");
daniele	29:1a47b7151851	1134
daniele	29:1a47b7151851	1135	return 0;
daniele	29:1a47b7151851	1136	}
daniele	29:1a47b7151851	1137
daniele	29:1a47b7151851	1138	static void tcp_send_fin(struct pico_socket_tcp *t)
daniele	29:1a47b7151851	1139	{
daniele	29:1a47b7151851	1140	struct pico_frame *f;
daniele	29:1a47b7151851	1141	struct pico_tcp_hdr *hdr;
tass	70:cd218dd180e5	1142	uint16_t opt_len = tcp_options_size(t, PICO_TCP_FIN);
tass	70:cd218dd180e5	1143	f = t->sock.net->alloc(t->sock.net, (uint16_t)(PICO_SIZE_TCPHDR + opt_len));
daniele	29:1a47b7151851	1144	if (!f) {
daniele	29:1a47b7151851	1145	return;
daniele	29:1a47b7151851	1146	}
daniele	29:1a47b7151851	1147	f->sock = &t->sock;
daniele	29:1a47b7151851	1148	hdr = (struct pico_tcp_hdr *) f->transport_hdr;
tass	70:cd218dd180e5	1149	hdr->len = (uint8_t)((PICO_SIZE_TCPHDR + opt_len) << 2 \| t->jumbo);
daniele	29:1a47b7151851	1150	hdr->flags = PICO_TCP_FIN \| PICO_TCP_ACK;
daniele	29:1a47b7151851	1151	hdr->ack = long_be(t->rcv_nxt);
daniele	29:1a47b7151851	1152	t->rcv_ackd = t->rcv_nxt;
daniele	29:1a47b7151851	1153	hdr->rwnd = short_be(t->wnd);
daniele	29:1a47b7151851	1154	tcp_set_space(t);
daniele	29:1a47b7151851	1155	tcp_add_options(t,f, PICO_TCP_FIN, opt_len);
daniele	29:1a47b7151851	1156	hdr->trans.sport = t->sock.local_port;
daniele	29:1a47b7151851	1157	hdr->trans.dport = t->sock.remote_port;
tass	40:c8ab0d2bba0b	1158	hdr->seq = long_be(t->snd_nxt); /* XXX TODO check correct ?? --> snd_last? otherwise maybe data after FIN */
daniele	29:1a47b7151851	1159
daniele	29:1a47b7151851	1160	f->start = f->transport_hdr + PICO_SIZE_TCPHDR;
daniele	29:1a47b7151851	1161	hdr->rwnd = short_be(t->wnd);
daniele	29:1a47b7151851	1162	hdr->crc = 0;
daniele	29:1a47b7151851	1163	hdr->crc = short_be(pico_tcp_checksum_ipv4(f));
daniele	29:1a47b7151851	1164	//tcp_dbg("SENDING FIN...\n");
daniele	29:1a47b7151851	1165	/* TCP: ENQUEUE to PROTO ( Pure ACK ) */
daniele	29:1a47b7151851	1166	pico_enqueue(&tcp_out, f);
daniele	29:1a47b7151851	1167	t->snd_nxt++;
daniele	29:1a47b7151851	1168	}
daniele	29:1a47b7151851	1169
daniele	29:1a47b7151851	1170	static void tcp_sack_prepare(struct pico_socket_tcp *t)
daniele	29:1a47b7151851	1171	{
tass	110:0ece1bbbd36e	1172	struct tcp_input_segment *pkt;
daniele	29:1a47b7151851	1173	uint32_t left=0, right=0;
daniele	29:1a47b7151851	1174	struct tcp_sack_block *sb;
daniele	29:1a47b7151851	1175	int n = 0;
daniele	29:1a47b7151851	1176	if (t->sacks) /* previous sacks are pending */
daniele	29:1a47b7151851	1177	return;
daniele	29:1a47b7151851	1178
daniele	29:1a47b7151851	1179	pkt = first_segment(&t->tcpq_in);
daniele	29:1a47b7151851	1180	while(n < 3) {
daniele	29:1a47b7151851	1181	if (!pkt) {
daniele	29:1a47b7151851	1182	if(left) {
daniele	29:1a47b7151851	1183	sb = pico_zalloc(sizeof(struct tcp_sack_block));
daniele	29:1a47b7151851	1184	if (!sb)
daniele	29:1a47b7151851	1185	break;
daniele	29:1a47b7151851	1186	sb->left = long_be(left);
daniele	29:1a47b7151851	1187	sb->right = long_be(right);
daniele	29:1a47b7151851	1188	n++;
daniele	29:1a47b7151851	1189	sb->next = t->sacks;
daniele	29:1a47b7151851	1190	t->sacks = sb;
daniele	29:1a47b7151851	1191	left = 0;
daniele	29:1a47b7151851	1192	right = 0;
daniele	29:1a47b7151851	1193	}
daniele	29:1a47b7151851	1194	break;
daniele	29:1a47b7151851	1195	}
tass	110:0ece1bbbd36e	1196	if (pkt->seq < t->rcv_nxt) {
daniele	29:1a47b7151851	1197	pkt = next_segment(&t->tcpq_in, pkt);
daniele	29:1a47b7151851	1198	continue;
daniele	29:1a47b7151851	1199	}
daniele	29:1a47b7151851	1200	if (!left) {
tass	110:0ece1bbbd36e	1201	left = pkt->seq;
tass	110:0ece1bbbd36e	1202	right = pkt->seq + pkt->payload_len;
daniele	29:1a47b7151851	1203	pkt = next_segment(&t->tcpq_in, pkt);
daniele	29:1a47b7151851	1204	continue;
daniele	29:1a47b7151851	1205	}
tass	110:0ece1bbbd36e	1206	if(pkt->seq == (right + 1)) {
daniele	29:1a47b7151851	1207	right += pkt->payload_len;
daniele	29:1a47b7151851	1208	pkt = next_segment(&t->tcpq_in, pkt);
daniele	29:1a47b7151851	1209	continue;
daniele	29:1a47b7151851	1210	} else {
daniele	29:1a47b7151851	1211	sb = pico_zalloc(sizeof(struct tcp_sack_block));
daniele	29:1a47b7151851	1212	if (!sb)
daniele	29:1a47b7151851	1213	break;
daniele	29:1a47b7151851	1214	sb->left = long_be(left);
daniele	29:1a47b7151851	1215	sb->right = long_be(right);
daniele	29:1a47b7151851	1216	n++;
daniele	29:1a47b7151851	1217	sb->next = t->sacks;
daniele	29:1a47b7151851	1218	t->sacks = sb;
daniele	29:1a47b7151851	1219	left = 0;
daniele	29:1a47b7151851	1220	right = 0;
daniele	29:1a47b7151851	1221	pkt = next_segment(&t->tcpq_in, pkt);
daniele	29:1a47b7151851	1222	}
daniele	29:1a47b7151851	1223	}
daniele	29:1a47b7151851	1224	}
daniele	29:1a47b7151851	1225
daniele	29:1a47b7151851	1226	static int tcp_data_in(struct pico_socket s, struct pico_frame f)
daniele	29:1a47b7151851	1227	{
daniele	29:1a47b7151851	1228	struct pico_socket_tcp t = (struct pico_socket_tcp )s;
daniele	29:1a47b7151851	1229	struct pico_tcp_hdr hdr = (struct pico_tcp_hdr ) f->transport_hdr;
daniele	29:1a47b7151851	1230
daniele	29:1a47b7151851	1231	if (((hdr->len & 0xf0) >> 2) <= f->transport_len) {
daniele	29:1a47b7151851	1232	tcp_parse_options(f);
daniele	29:1a47b7151851	1233	f->payload = f->transport_hdr + ((hdr->len & 0xf0) >>2);
tass	70:cd218dd180e5	1234	f->payload_len = (uint16_t)(f->transport_len - ((hdr->len & 0xf0) >>2));
tass	45:ca30069e49bb	1235	tcp_dbg("TCP> Received segment. (exp: %x got: %x)\n", t->rcv_nxt, SEQN(f));
daniele	29:1a47b7151851	1236
tass	45:ca30069e49bb	1237	if (seq_compare(SEQN(f), t->rcv_nxt) <= 0) {
tass	110:0ece1bbbd36e	1238	struct tcp_input_segment *nxt;
daniele	29:1a47b7151851	1239	if (seq_compare(SEQN(f), t->rcv_nxt) == 0) { /* Exactly what we expected */
tass	110:0ece1bbbd36e	1240	// Create new segment and enqueue it
tass	110:0ece1bbbd36e	1241	struct tcp_input_segment * input = segment_from_frame(f);
tass	110:0ece1bbbd36e	1242	if(input && pico_enqueue_segment(&t->tcpq_in,input) <= 0)
tass	110:0ece1bbbd36e	1243	{
tass	110:0ece1bbbd36e	1244	// failed to enqueue, destroy segment
tass	110:0ece1bbbd36e	1245	pico_free(input->payload);
tass	110:0ece1bbbd36e	1246	pico_free(input);
tass	110:0ece1bbbd36e	1247	}
tass	110:0ece1bbbd36e	1248
daniele	29:1a47b7151851	1249	t->rcv_nxt = SEQN(f) + f->payload_len;
daniele	29:1a47b7151851	1250	nxt = peek_segment(&t->tcpq_in, t->rcv_nxt);
daniele	29:1a47b7151851	1251	while(nxt) {
daniele	29:1a47b7151851	1252	tcp_dbg("scrolling rcv_nxt...%08x\n", t->rcv_nxt);
daniele	29:1a47b7151851	1253	t->rcv_nxt += f->payload_len;
daniele	29:1a47b7151851	1254	nxt = peek_segment(&t->tcpq_in, t->rcv_nxt);
daniele	29:1a47b7151851	1255	}
daniele	29:1a47b7151851	1256	t->sock.ev_pending \|= PICO_SOCK_EV_RD;
daniele	29:1a47b7151851	1257	t->rcv_nxt = SEQN(f) + f->payload_len;
daniele	29:1a47b7151851	1258	} else {
tass	45:ca30069e49bb	1259	tcp_dbg("TCP> lo segment. Uninteresting retransmission. (exp: %x got: %x)\n", t->rcv_nxt, SEQN(f));
daniele	29:1a47b7151851	1260	}
daniele	29:1a47b7151851	1261	} else {
daniele	29:1a47b7151851	1262	tcp_dbg("TCP> hi segment. Possible packet loss. I'll dupack this. (exp: %x got: %x)\n", t->rcv_nxt, SEQN(f));
daniele	29:1a47b7151851	1263	if (t->sack_ok) {
daniele	29:1a47b7151851	1264	tcp_sack_prepare(t);
daniele	29:1a47b7151851	1265	}
daniele	29:1a47b7151851	1266	}
daniele	29:1a47b7151851	1267	/* In either case, ack til recv_nxt. */
daniele	29:1a47b7151851	1268	if ( ((t->sock.state & PICO_SOCKET_STATE_TCP) != PICO_SOCKET_STATE_TCP_CLOSE_WAIT) && ((t->sock.state & PICO_SOCKET_STATE_TCP) != PICO_SOCKET_STATE_TCP_SYN_SENT) && ((t->sock.state & PICO_SOCKET_STATE_TCP) != PICO_SOCKET_STATE_TCP_SYN_RECV)) {
daniele	29:1a47b7151851	1269	//tcp_dbg("SENDACK CALLED FROM OUTSIDE tcp_synack, state %x\n",t->sock.state);
daniele	29:1a47b7151851	1270	tcp_send_ack(t);
daniele	29:1a47b7151851	1271	} else {
daniele	29:1a47b7151851	1272	//tcp_dbg("SENDACK PREVENTED IN SYNSENT STATE\n");
daniele	29:1a47b7151851	1273	}
daniele	29:1a47b7151851	1274	return 0;
daniele	29:1a47b7151851	1275	} else {
daniele	29:1a47b7151851	1276	tcp_dbg("TCP: invalid data in pkt len, exp: %d, got %d\n", (hdr->len & 0xf0) >> 2, f->transport_len);
daniele	29:1a47b7151851	1277	return -1;
daniele	29:1a47b7151851	1278	}
daniele	29:1a47b7151851	1279	}
daniele	29:1a47b7151851	1280
daniele	29:1a47b7151851	1281	static int tcp_ack_advance_una(struct pico_socket_tcp t, struct pico_frame f)
daniele	29:1a47b7151851	1282	{
daniele	29:1a47b7151851	1283	int ret = release_all_until(&t->tcpq_out, ACKN(f));
daniele	29:1a47b7151851	1284	if (ret > 0)
daniele	29:1a47b7151851	1285	t->sock.ev_pending \|= PICO_SOCK_EV_WR;
daniele	29:1a47b7151851	1286	return ret;
daniele	29:1a47b7151851	1287	}
daniele	29:1a47b7151851	1288
tass	73:dfb737147f6e	1289	static uint16_t time_diff(uint32_t a, uint32_t b)
daniele	29:1a47b7151851	1290	{
daniele	29:1a47b7151851	1291	if (a >= b)
tass	73:dfb737147f6e	1292	return (uint16_t)(a - b);
daniele	29:1a47b7151851	1293	else
tass	73:dfb737147f6e	1294	return (uint16_t)(b - a);
daniele	29:1a47b7151851	1295	}
daniele	29:1a47b7151851	1296
daniele	29:1a47b7151851	1297	static void tcp_rtt(struct pico_socket_tcp *t, uint32_t rtt)
daniele	29:1a47b7151851	1298	{
daniele	29:1a47b7151851	1299
daniele	29:1a47b7151851	1300	uint32_t avg = t->avg_rtt;
daniele	29:1a47b7151851	1301	uint32_t rvar = t->rttvar;
daniele	29:1a47b7151851	1302	if (!avg) {
daniele	29:1a47b7151851	1303	/* This follows RFC2988
daniele	29:1a47b7151851	1304	* (2.2) When the first RTT measurement R is made, the host MUST set
daniele	29:1a47b7151851	1305	*
daniele	29:1a47b7151851	1306	* SRTT <- R
daniele	29:1a47b7151851	1307	* RTTVAR <- R/2
daniele	29:1a47b7151851	1308	* RTO <- SRTT + max (G, K*RTTVAR)
daniele	29:1a47b7151851	1309	*/
daniele	29:1a47b7151851	1310	t->avg_rtt = rtt;
daniele	29:1a47b7151851	1311	t->rttvar = rtt >> 1;
daniele	29:1a47b7151851	1312	t->rto = t->avg_rtt + (t->rttvar << 4);
daniele	29:1a47b7151851	1313	} else {
tass	70:cd218dd180e5	1314	int32_t var = (int32_t)(t->avg_rtt - rtt);
daniele	29:1a47b7151851	1315	if (var < 0)
daniele	29:1a47b7151851	1316	var = 0-var;
daniele	29:1a47b7151851	1317	/* RFC2988, section (2.3). Alpha and beta are the ones suggested. */
daniele	29:1a47b7151851	1318
daniele	29:1a47b7151851	1319	/* First, evaluate a new value for the rttvar */
daniele	29:1a47b7151851	1320	t->rttvar <<= 2;
daniele	29:1a47b7151851	1321	t->rttvar -= rvar;
tass	70:cd218dd180e5	1322	t->rttvar += (uint32_t)var;
daniele	29:1a47b7151851	1323	t->rttvar >>= 2;
daniele	29:1a47b7151851	1324
daniele	29:1a47b7151851	1325	/* Then, calculate the new avg_rtt */
daniele	29:1a47b7151851	1326	t->avg_rtt <<= 3;
daniele	29:1a47b7151851	1327	t->avg_rtt -= avg;
daniele	29:1a47b7151851	1328	t->avg_rtt += rtt;
daniele	29:1a47b7151851	1329	t->avg_rtt >>= 3;
daniele	29:1a47b7151851	1330
daniele	29:1a47b7151851	1331	/* Finally, assign a new value for the RTO, as specified in the RFC, with K=4 */
daniele	29:1a47b7151851	1332	t->rto = t->avg_rtt + (t->rttvar << 2);
daniele	29:1a47b7151851	1333	}
tass	45:ca30069e49bb	1334	tcp_dbg(" -----=============== RTT CUR: %u AVG: %u RTTVAR: %u RTO: %u ======================----\n", rtt, t->avg_rtt, t->rttvar, t->rto);
daniele	29:1a47b7151851	1335	}
daniele	29:1a47b7151851	1336
daniele	29:1a47b7151851	1337	static void tcp_congestion_control(struct pico_socket_tcp *t)
daniele	29:1a47b7151851	1338	{
daniele	29:1a47b7151851	1339	if (t->x_mode > PICO_TCP_LOOKAHEAD)
daniele	29:1a47b7151851	1340	return;
daniele	29:1a47b7151851	1341	if (t->cwnd > t->tcpq_out.frames) {
daniele	29:1a47b7151851	1342	tcp_dbg("Limited by app: %d\n", t->cwnd);
tass	45:ca30069e49bb	1343	if (t->sock.wakeup)
tass	45:ca30069e49bb	1344	t->sock.wakeup(PICO_SOCK_EV_WR, &t->sock);
daniele	29:1a47b7151851	1345	return;
daniele	29:1a47b7151851	1346	}
daniele	29:1a47b7151851	1347	tcp_dbg("Doing congestion control\n");
daniele	29:1a47b7151851	1348	if (t->cwnd < t->ssthresh) {
daniele	29:1a47b7151851	1349	t->cwnd++;
daniele	29:1a47b7151851	1350	} else {
daniele	29:1a47b7151851	1351	t->cwnd_counter++;
daniele	29:1a47b7151851	1352	if (t->cwnd_counter >= t->cwnd) {
daniele	29:1a47b7151851	1353	t->cwnd++;
daniele	29:1a47b7151851	1354	t->cwnd_counter = 0;
daniele	29:1a47b7151851	1355	}
daniele	29:1a47b7151851	1356	}
daniele	29:1a47b7151851	1357	tcp_dbg("TCP_CWND, %lu, %u, %u, %u\n", pico_tick, t->cwnd, t->ssthresh, t->in_flight);
daniele	29:1a47b7151851	1358	}
daniele	29:1a47b7151851	1359
tass	73:dfb737147f6e	1360	static void add_retransmission_timer(struct pico_socket_tcp *t, uint32_t next_ts);
tass	73:dfb737147f6e	1361	static void tcp_retrans_timeout(uint32_t val, void *sock)
daniele	29:1a47b7151851	1362	{
daniele	29:1a47b7151851	1363	struct pico_socket_tcp t = (struct pico_socket_tcp ) sock;
daniele	29:1a47b7151851	1364	struct pico_frame *f = NULL;
tass	73:dfb737147f6e	1365	uint32_t limit = val - t->rto;
tass	32:865c101e0874	1366	if( t->sock.net && ((t->sock.state & 0xFF00) == PICO_SOCKET_STATE_TCP_ESTABLISHED
tass	97:e73b01cb3147	1367	\|\| (t->sock.state & 0xFF00) == PICO_SOCKET_STATE_TCP_CLOSE_WAIT) && t->backoff < PICO_TCP_MAX_RETRANS)
daniele	29:1a47b7151851	1368	{
tass	68:0847e35d08a6	1369	tcp_dbg("TIMEOUT! backoff = %d\n", t->backoff);
tass	68:0847e35d08a6	1370	/* was timer cancelled? */
tass	68:0847e35d08a6	1371	if (t->timer_running == 0) {
tass	68:0847e35d08a6	1372	add_retransmission_timer(t, 0);
tass	68:0847e35d08a6	1373	return;
tass	68:0847e35d08a6	1374	}
tass	68:0847e35d08a6	1375	t->timer_running--;
daniele	29:1a47b7151851	1376
tass	68:0847e35d08a6	1377	f = first_segment(&t->tcpq_out);
tass	68:0847e35d08a6	1378	while (f) {
tass	68:0847e35d08a6	1379	if ((t->x_mode == PICO_TCP_WINDOW_FULL) \|\|
tass	68:0847e35d08a6	1380	((f->timestamp != 0) && (f->timestamp <= limit))) {
tass	68:0847e35d08a6	1381	struct pico_frame *cpy;
tass	68:0847e35d08a6	1382	tcp_dbg("TCP BLACKOUT> TIMED OUT (output) frame %08x, len= %d rto=%d Win full: %d frame flags: %04x\n", SEQN(f), f->payload_len, t->rto, t->x_mode == PICO_TCP_WINDOW_FULL, f->flags);
tass	68:0847e35d08a6	1383	if ((t->x_mode != PICO_TCP_WINDOW_FULL) ) {
tass	68:0847e35d08a6	1384	t->x_mode = PICO_TCP_BLACKOUT;
tass	68:0847e35d08a6	1385	tcp_dbg("Mode: Blackout.\n");
tass	68:0847e35d08a6	1386	t->cwnd = PICO_TCP_IW;
tass	68:0847e35d08a6	1387	t->in_flight = 0;
tass	68:0847e35d08a6	1388	}
tass	70:cd218dd180e5	1389	tcp_add_header(t,f);
tass	68:0847e35d08a6	1390	/* TCP: ENQUEUE to PROTO ( retransmit )*/
tass	68:0847e35d08a6	1391	cpy = pico_frame_copy(f);
tass	68:0847e35d08a6	1392	if (pico_enqueue(&tcp_out, cpy) > 0) {
tass	68:0847e35d08a6	1393	t->backoff++;
tass	68:0847e35d08a6	1394	add_retransmission_timer(t, (t->rto << t->backoff) + pico_tick);
tass	68:0847e35d08a6	1395	tcp_dbg("TCP_CWND, %lu, %u, %u, %u\n", pico_tick, t->cwnd, t->ssthresh, t->in_flight);
tass	68:0847e35d08a6	1396	return;
tass	68:0847e35d08a6	1397	} else {
tass	68:0847e35d08a6	1398	add_retransmission_timer(t, (t->rto << t->backoff) + pico_tick);
tass	68:0847e35d08a6	1399	pico_frame_discard(cpy);
tass	68:0847e35d08a6	1400	}
tass	68:0847e35d08a6	1401	}
tass	68:0847e35d08a6	1402	f = next_segment(&t->tcpq_out, f);
tass	68:0847e35d08a6	1403	}
tass	68:0847e35d08a6	1404	t->backoff = 0;
tass	68:0847e35d08a6	1405	add_retransmission_timer(t, 0);
tass	68:0847e35d08a6	1406	if (t->tcpq_out.size < t->tcpq_out.max_size)
tass	97:e73b01cb3147	1407	t->sock.ev_pending \|= PICO_SOCK_EV_WR;
tass	68:0847e35d08a6	1408	return;
tass	68:0847e35d08a6	1409	}
tass	97:e73b01cb3147	1410	else if(t->backoff >= PICO_TCP_MAX_RETRANS && (t->sock.state & 0xFF00) == PICO_SOCKET_STATE_TCP_ESTABLISHED )
tass	97:e73b01cb3147	1411	{
tass	97:e73b01cb3147	1412	// the retransmission timer, failed to get an ack for a frame, giving up on the connection
tass	97:e73b01cb3147	1413	tcp_discard_all_segments(&t->tcpq_out);
tass	97:e73b01cb3147	1414	if(t->sock.wakeup)
tass	97:e73b01cb3147	1415	t->sock.wakeup(PICO_SOCK_EV_FIN,&t->sock);
tass	97:e73b01cb3147	1416	}
daniele	29:1a47b7151851	1417	}
daniele	29:1a47b7151851	1418
tass	73:dfb737147f6e	1419	static void add_retransmission_timer(struct pico_socket_tcp *t, uint32_t next_ts)
daniele	29:1a47b7151851	1420	{
daniele	29:1a47b7151851	1421	struct pico_tree_node * index;
daniele	29:1a47b7151851	1422
daniele	29:1a47b7151851	1423	if (t->timer_running > 0)
daniele	29:1a47b7151851	1424	return;
daniele	29:1a47b7151851	1425
daniele	29:1a47b7151851	1426	if (next_ts == 0) {
daniele	29:1a47b7151851	1427	struct pico_frame *f;
daniele	29:1a47b7151851	1428
daniele	29:1a47b7151851	1429	pico_tree_foreach(index,&t->tcpq_out.pool){
daniele	29:1a47b7151851	1430	f = index->keyValue;
daniele	29:1a47b7151851	1431	if (((next_ts == 0) \|\| (f->timestamp < next_ts)) && (f->timestamp > 0)) {
daniele	29:1a47b7151851	1432	next_ts = f->timestamp;
daniele	29:1a47b7151851	1433	}
daniele	29:1a47b7151851	1434	}
daniele	29:1a47b7151851	1435	}
daniele	29:1a47b7151851	1436	if (next_ts > 0) {
daniele	29:1a47b7151851	1437	if ((next_ts + t->rto) > pico_tick) {
tass	70:cd218dd180e5	1438	t->retrans_tmr = pico_timer_add(next_ts + t->rto - pico_tick, tcp_retrans_timeout, t);
daniele	29:1a47b7151851	1439	} else {
tass	70:cd218dd180e5	1440	t->retrans_tmr = pico_timer_add(1, tcp_retrans_timeout, t);
daniele	29:1a47b7151851	1441	}
daniele	29:1a47b7151851	1442	t->timer_running++;
daniele	29:1a47b7151851	1443	}
daniele	29:1a47b7151851	1444	}
daniele	29:1a47b7151851	1445
daniele	29:1a47b7151851	1446	static int tcp_retrans(struct pico_socket_tcp t, struct pico_frame f)
daniele	29:1a47b7151851	1447	{
daniele	29:1a47b7151851	1448	struct pico_frame *cpy;
daniele	29:1a47b7151851	1449	if (f) {
daniele	29:1a47b7151851	1450	tcp_dbg("TCP> RETRANS (by dupack) frame %08x, len= %d\n", SEQN(f), f->payload_len);
tass	70:cd218dd180e5	1451	tcp_add_header(t,f);
daniele	29:1a47b7151851	1452	/* TCP: ENQUEUE to PROTO ( retransmit )*/
daniele	29:1a47b7151851	1453	cpy = pico_frame_copy(f);
daniele	29:1a47b7151851	1454	if (pico_enqueue(&tcp_out, cpy) > 0) {
daniele	29:1a47b7151851	1455	t->in_flight++;
daniele	29:1a47b7151851	1456	t->snd_last_out = SEQN(cpy);
daniele	29:1a47b7151851	1457	add_retransmission_timer(t, pico_tick + t->rto);
daniele	29:1a47b7151851	1458	} else {
daniele	29:1a47b7151851	1459	pico_frame_discard(cpy);
daniele	29:1a47b7151851	1460	}
daniele	29:1a47b7151851	1461	return(f->payload_len);
daniele	29:1a47b7151851	1462	}
daniele	29:1a47b7151851	1463	return 0;
daniele	29:1a47b7151851	1464	}
daniele	29:1a47b7151851	1465
daniele	29:1a47b7151851	1466	#ifdef TCP_ACK_DBG
daniele	29:1a47b7151851	1467	static void tcp_ack_dbg(struct pico_socket s, struct pico_frame f)
daniele	29:1a47b7151851	1468	{
daniele	29:1a47b7151851	1469	uint32_t una, nxt, ack, cur;
daniele	29:1a47b7151851	1470	struct pico_frame una_f = NULL, cur_f;
daniele	29:1a47b7151851	1471	struct pico_tree_node *idx;
daniele	29:1a47b7151851	1472	struct pico_socket_tcp t = (struct pico_socket_tcp )s;
daniele	29:1a47b7151851	1473	char info[64];
daniele	29:1a47b7151851	1474	char tmp[64];
daniele	29:1a47b7151851	1475	ack = ACKN(f);
daniele	29:1a47b7151851	1476	nxt = t->snd_nxt;
daniele	29:1a47b7151851	1477	tcp_dbg("===================================\n");
daniele	29:1a47b7151851	1478	tcp_dbg("Queue out (%d/%d). ACKED=%08x\n", t->tcpq_out.size, t->tcpq_out.max_size, ack);
daniele	29:1a47b7151851	1479
daniele	29:1a47b7151851	1480	pico_tree_foreach(idx, &t->tcpq_out.pool) {
daniele	29:1a47b7151851	1481	info[0] = 0;
daniele	29:1a47b7151851	1482	cur_f = idx->keyValue;
daniele	29:1a47b7151851	1483	cur = SEQN(cur_f);
daniele	29:1a47b7151851	1484	if (!una_f) {
daniele	29:1a47b7151851	1485	una_f = cur_f;
daniele	29:1a47b7151851	1486	una = SEQN(una_f);
daniele	29:1a47b7151851	1487	}
daniele	29:1a47b7151851	1488
daniele	29:1a47b7151851	1489	if (cur == nxt) {
daniele	29:1a47b7151851	1490	strncpy(tmp, info, strlen(info));
daniele	29:1a47b7151851	1491	snprintf(info,64, "%s SND_NXT", tmp);
daniele	29:1a47b7151851	1492	}
daniele	29:1a47b7151851	1493	if (cur == ack) {
daniele	29:1a47b7151851	1494	strncpy(tmp, info, strlen(info));
daniele	29:1a47b7151851	1495	snprintf(info,64, "%s ACK", tmp);
daniele	29:1a47b7151851	1496	}
daniele	29:1a47b7151851	1497	if (cur == una) {
daniele	29:1a47b7151851	1498	strncpy(tmp, info, strlen(info));
daniele	29:1a47b7151851	1499	snprintf(info,64, "%s SND_UNA", tmp);
daniele	29:1a47b7151851	1500	}
daniele	29:1a47b7151851	1501	if (cur == t->snd_last) {
daniele	29:1a47b7151851	1502	strncpy(tmp, info, strlen(info));
daniele	29:1a47b7151851	1503	snprintf(info,64, "%s SND_LAST", tmp);
daniele	29:1a47b7151851	1504	}
daniele	29:1a47b7151851	1505	tcp_dbg("%08x %d%s\n", cur, cur_f->payload_len, info);
daniele	29:1a47b7151851	1506
daniele	29:1a47b7151851	1507	}
tass	82:93915e13262a	1508	tcp_dbg("SND_NXT is %08x, snd_LAST is %08x\n", nxt, t->snd_last);
daniele	29:1a47b7151851	1509	tcp_dbg("===================================\n");
daniele	29:1a47b7151851	1510	tcp_dbg("\n\n");
daniele	29:1a47b7151851	1511	}
daniele	29:1a47b7151851	1512	#endif
daniele	29:1a47b7151851	1513
daniele	29:1a47b7151851	1514	static int tcp_ack(struct pico_socket s, struct pico_frame f)
daniele	29:1a47b7151851	1515	{
daniele	29:1a47b7151851	1516	struct pico_frame f_new; / use with Nagle to push to out queue */
daniele	29:1a47b7151851	1517	struct pico_socket_tcp t = (struct pico_socket_tcp )s;
daniele	29:1a47b7151851	1518	struct pico_tcp_hdr hdr = (struct pico_tcp_hdr ) f->transport_hdr;
daniele	29:1a47b7151851	1519	uint32_t rtt = 0;
tass	68:0847e35d08a6	1520	uint16_t acked = 0;
daniele	29:1a47b7151851	1521	struct pico_frame *una = NULL;
daniele	29:1a47b7151851	1522	if ((hdr->flags & PICO_TCP_ACK) == 0)
daniele	29:1a47b7151851	1523	return -1;
daniele	29:1a47b7151851	1524
daniele	29:1a47b7151851	1525	#ifdef TCP_ACK_DBG
daniele	29:1a47b7151851	1526	tcp_ack_dbg(s,f);
daniele	29:1a47b7151851	1527	#endif
daniele	29:1a47b7151851	1528
daniele	29:1a47b7151851	1529	tcp_parse_options(f);
daniele	29:1a47b7151851	1530	t->recv_wnd = short_be(hdr->rwnd);
daniele	29:1a47b7151851	1531
tass	70:cd218dd180e5	1532	acked = (uint16_t)tcp_ack_advance_una(t, f);
daniele	29:1a47b7151851	1533	una = first_segment(&t->tcpq_out);
daniele	29:1a47b7151851	1534
daniele	29:1a47b7151851	1535	if ((t->x_mode == PICO_TCP_BLACKOUT) \|\|
daniele	29:1a47b7151851	1536	((t->x_mode == PICO_TCP_WINDOW_FULL) && ((t->recv_wnd << t->recv_wnd_scale) > t->mss))) {
daniele	29:1a47b7151851	1537	tcp_dbg("Re-entering look-ahead...\n\n\n");
daniele	29:1a47b7151851	1538	t->x_mode = PICO_TCP_LOOKAHEAD;
daniele	29:1a47b7151851	1539	t->backoff = 0;
daniele	29:1a47b7151851	1540	}
daniele	29:1a47b7151851	1541
daniele	29:1a47b7151851	1542	/* One should be acked. */
daniele	29:1a47b7151851	1543	// if ((acked == 0) && (t->in_flight > 0))
daniele	29:1a47b7151851	1544	if ((acked == 0) && (f->payload_len == 0) && (t->in_flight > 0))
daniele	29:1a47b7151851	1545	t->in_flight--;
daniele	29:1a47b7151851	1546	if (!una \|\| acked > 0) {
daniele	29:1a47b7151851	1547	t->x_mode = PICO_TCP_LOOKAHEAD;
daniele	29:1a47b7151851	1548	tcp_dbg("Mode: Look-ahead. In flight: %d/%d buf: %d\n", t->in_flight, t->cwnd, t->tcpq_out.frames);
daniele	29:1a47b7151851	1549	t->backoff = 0;
daniele	29:1a47b7151851	1550
daniele	29:1a47b7151851	1551	/* Do rtt/rttvar/rto calculations */
tass	45:ca30069e49bb	1552	/* First, try with timestamps, using the value from options */
tass	45:ca30069e49bb	1553	if(f && (f->timestamp != 0)) {
tass	45:ca30069e49bb	1554	rtt = time_diff(pico_tick, f->timestamp);
daniele	29:1a47b7151851	1555	if (rtt)
daniele	29:1a47b7151851	1556	tcp_rtt(t, rtt);
tass	45:ca30069e49bb	1557	} else if(una && (una->timestamp != 0)) {
tass	45:ca30069e49bb	1558	/* If no timestamps are there, use conservatve estimation on the una */
tass	45:ca30069e49bb	1559	rtt = time_diff(pico_tick, una->timestamp);
tass	45:ca30069e49bb	1560	if (rtt)
tass	45:ca30069e49bb	1561	tcp_rtt(t, rtt);
daniele	29:1a47b7151851	1562	}
daniele	29:1a47b7151851	1563
daniele	29:1a47b7151851	1564	tcp_dbg("TCP ACK> FRESH ACK %08x (acked %d) Queue size: %u/%u frames: %u cwnd: %u in_flight: %u snd_una: %u\n", ACKN(f), acked, t->tcpq_out.size, t->tcpq_out.max_size, t->tcpq_out.frames, t->cwnd, t->in_flight, SEQN(una));
daniele	29:1a47b7151851	1565	if (acked > t->in_flight) {
daniele	29:1a47b7151851	1566	tcp_dbg("WARNING: in flight < 0\n");
daniele	29:1a47b7151851	1567	t->in_flight = 0;
daniele	29:1a47b7151851	1568	} else
daniele	29:1a47b7151851	1569	t->in_flight -= (acked);
daniele	29:1a47b7151851	1570
daniele	29:1a47b7151851	1571	} else if ((t->snd_old_ack == ACKN(f)) && /* We've just seen this ack, and... */
daniele	29:1a47b7151851	1572	((0 == (hdr->flags & (PICO_TCP_PSH \| PICO_TCP_SYN))) &&
daniele	29:1a47b7151851	1573	(f->payload_len == 0)) && /* This is a pure ack, and... */
daniele	29:1a47b7151851	1574	(ACKN(f) != t->snd_nxt)) /* There is something in flight awaiting to be acked... */
daniele	29:1a47b7151851	1575	{
daniele	29:1a47b7151851	1576	/* Process incoming duplicate ack. */
daniele	29:1a47b7151851	1577	if (t->x_mode < PICO_TCP_RECOVER) {
daniele	29:1a47b7151851	1578	t->x_mode++;
daniele	29:1a47b7151851	1579	tcp_dbg("Mode: DUPACK %d, due to PURE ACK %0x, len = %d\n", t->x_mode, SEQN(f), f->payload_len);
daniele	29:1a47b7151851	1580	tcp_dbg("ACK: %x - QUEUE: %x\n",ACKN(f), SEQN(first_segment(&t->tcpq_out)));
daniele	29:1a47b7151851	1581	if (t->x_mode == PICO_TCP_RECOVER) { /* Switching mode */
tass	110:0ece1bbbd36e	1582	t->snd_retry = SEQN((struct pico_frame *)first_segment(&t->tcpq_out));
daniele	29:1a47b7151851	1583	if (t->ssthresh > t->cwnd)
daniele	29:1a47b7151851	1584	t->ssthresh >>=2;
daniele	29:1a47b7151851	1585	else
daniele	29:1a47b7151851	1586	t->ssthresh = (t->cwnd >> 1);
daniele	29:1a47b7151851	1587	if (t->ssthresh < 2)
daniele	29:1a47b7151851	1588	t->ssthresh = 2;
daniele	29:1a47b7151851	1589	}
daniele	29:1a47b7151851	1590	} else if (t->x_mode == PICO_TCP_RECOVER) {
daniele	29:1a47b7151851	1591	tcp_dbg("TCP RECOVER> DUPACK! snd_una: %08x, snd_nxt: %08x, acked now: %08x\n", SEQN(first_segment(&t->tcpq_out)), t->snd_nxt, ACKN(f));
daniele	29:1a47b7151851	1592	if (t->in_flight <= t->cwnd) {
daniele	29:1a47b7151851	1593	struct pico_frame *nxt = peek_segment(&t->tcpq_out, t->snd_retry);
daniele	29:1a47b7151851	1594	if (!nxt)
daniele	29:1a47b7151851	1595	nxt = first_segment(&t->tcpq_out);
daniele	29:1a47b7151851	1596
daniele	29:1a47b7151851	1597	while (nxt && (nxt->flags & PICO_FRAME_FLAG_SACKED) && (nxt != first_segment(&t->tcpq_out))) {
daniele	29:1a47b7151851	1598	tcp_dbg("Skipping %08x because it is sacked.\n", SEQN(nxt));
daniele	29:1a47b7151851	1599	nxt = next_segment(&t->tcpq_out, nxt);
daniele	29:1a47b7151851	1600	}
daniele	29:1a47b7151851	1601
daniele	29:1a47b7151851	1602	if (nxt && (seq_compare(SEQN(nxt), t->snd_nxt)) > 0)
daniele	29:1a47b7151851	1603	nxt = NULL;
tass	110:0ece1bbbd36e	1604	if (nxt && (seq_compare(SEQN(nxt), SEQN((struct pico_frame *)first_segment(&t->tcpq_out))) > (t->recv_wnd << t->recv_wnd_scale)))
daniele	29:1a47b7151851	1605	nxt = NULL;
daniele	29:1a47b7151851	1606
daniele	29:1a47b7151851	1607	if(!nxt)
daniele	29:1a47b7151851	1608	nxt = first_segment(&t->tcpq_out);
daniele	29:1a47b7151851	1609	if (nxt) {
daniele	29:1a47b7151851	1610	tcp_retrans(t, peek_segment(&t->tcpq_out, t->snd_retry));
daniele	29:1a47b7151851	1611	t->snd_retry = SEQN(nxt);
daniele	29:1a47b7151851	1612	}
daniele	29:1a47b7151851	1613	}
daniele	29:1a47b7151851	1614
daniele	29:1a47b7151851	1615	if (++t->cwnd_counter > 1) {
daniele	29:1a47b7151851	1616	t->cwnd--;
daniele	29:1a47b7151851	1617	if (t->cwnd < 2)
daniele	29:1a47b7151851	1618	t->cwnd = 2;
daniele	29:1a47b7151851	1619	t->cwnd_counter = 0;
daniele	29:1a47b7151851	1620	}
daniele	29:1a47b7151851	1621	} else {
daniele	29:1a47b7151851	1622	tcp_dbg("DUPACK in mode %d \n", t->x_mode);
daniele	29:1a47b7151851	1623
daniele	29:1a47b7151851	1624	}
daniele	29:1a47b7151851	1625	} /* End case duplicate ack detection */
daniele	29:1a47b7151851	1626
daniele	29:1a47b7151851	1627	/* Do congestion control */
daniele	29:1a47b7151851	1628	tcp_congestion_control(t);
daniele	29:1a47b7151851	1629	if ((acked > 0) && t->sock.wakeup) {
daniele	29:1a47b7151851	1630	if (t->tcpq_out.size < t->tcpq_out.max_size)
daniele	29:1a47b7151851	1631	t->sock.wakeup(PICO_SOCK_EV_WR, &(t->sock));
daniele	29:1a47b7151851	1632	//t->sock.ev_pending \|= PICO_SOCK_EV_WR;
daniele	29:1a47b7151851	1633	}
daniele	29:1a47b7151851	1634
daniele	29:1a47b7151851	1635	/* if Nagle enabled, check if no unack'ed data and fill out queue (till window) */
daniele	29:1a47b7151851	1636	if (IS_NAGLE_ENABLED((&(t->sock)))) {
daniele	29:1a47b7151851	1637	while (!IS_TCP_HOLDQ_EMPTY(t) && ((t->tcpq_out.max_size - t->tcpq_out.size) >= PICO_TCP_DEFAULT_MSS)) {
tass	45:ca30069e49bb	1638	tcp_dbg_nagle("TCP_ACK - NAGLE add new segment\n");
daniele	29:1a47b7151851	1639	f_new = pico_hold_segment_make(t);
daniele	29:1a47b7151851	1640	if (f_new == NULL)
daniele	29:1a47b7151851	1641	break; /* XXX corrupt !!! (or no memory) */
daniele	29:1a47b7151851	1642	if (pico_enqueue_segment(&t->tcpq_out,f_new) <= 0)
daniele	29:1a47b7151851	1643	// handle error
tass	45:ca30069e49bb	1644	tcp_dbg_nagle("TCP_ACK - NAGLE FAILED to enqueue in out\n");
daniele	29:1a47b7151851	1645	}
daniele	29:1a47b7151851	1646	}
daniele	29:1a47b7151851	1647
daniele	29:1a47b7151851	1648	/* If some space was created, put a few segments out. */
daniele	29:1a47b7151851	1649	tcp_dbg("TCP_CWND, %lu, %u, %u, %u\n", pico_tick, t->cwnd, t->ssthresh, t->in_flight);
daniele	29:1a47b7151851	1650	if (t->x_mode == PICO_TCP_LOOKAHEAD) {
daniele	29:1a47b7151851	1651	if ((t->cwnd >= t->in_flight) && (t->snd_nxt > t->snd_last_out)) {
tass	70:cd218dd180e5	1652	pico_tcp_output(&t->sock, (int)t->cwnd - (int)t->in_flight);
daniele	29:1a47b7151851	1653	}
daniele	29:1a47b7151851	1654	}
daniele	29:1a47b7151851	1655
daniele	29:1a47b7151851	1656	t->snd_old_ack = ACKN(f);
daniele	29:1a47b7151851	1657	return 0;
daniele	29:1a47b7151851	1658	}
daniele	29:1a47b7151851	1659
daniele	29:1a47b7151851	1660	static int tcp_finwaitack(struct pico_socket s, struct pico_frame f)
daniele	29:1a47b7151851	1661	{
tass	68:0847e35d08a6	1662	tcp_dbg("RECEIVED ACK IN FIN_WAIT1\n");
tass	68:0847e35d08a6	1663	tcp_dbg("TCP> IN STATE FIN_WAIT2\n");
daniele	29:1a47b7151851	1664
daniele	29:1a47b7151851	1665	/* acking part */
daniele	29:1a47b7151851	1666	tcp_ack(s,f);
daniele	29:1a47b7151851	1667	/* update TCP state */
daniele	29:1a47b7151851	1668	s->state &= 0x00FFU;
daniele	29:1a47b7151851	1669	s->state \|= PICO_SOCKET_STATE_TCP_FIN_WAIT2;
daniele	29:1a47b7151851	1670
daniele	29:1a47b7151851	1671	return 0;
daniele	29:1a47b7151851	1672	}
daniele	29:1a47b7151851	1673
tass	73:dfb737147f6e	1674	static void tcp_deltcb(uint32_t when, void *arg)
daniele	29:1a47b7151851	1675	{
daniele	29:1a47b7151851	1676	struct pico_socket_tcp t = (struct pico_socket_tcp )arg;
tass	68:0847e35d08a6	1677	IGNORE_PARAMETER(when);
tass	68:0847e35d08a6	1678
daniele	29:1a47b7151851	1679	if (TCPSTATE(&t->sock) == PICO_SOCKET_STATE_TCP_TIME_WAIT) {
daniele	29:1a47b7151851	1680	tcp_dbg("TCP> state: time_wait, final timer expired, going to closed state\n");
daniele	29:1a47b7151851	1681	/* update state */
daniele	29:1a47b7151851	1682	(t->sock).state &= 0x00FFU;
daniele	29:1a47b7151851	1683	(t->sock).state \|= PICO_SOCKET_STATE_TCP_CLOSED;
daniele	29:1a47b7151851	1684	(t->sock).state &= 0xFF00U;
daniele	29:1a47b7151851	1685	(t->sock).state \|= PICO_SOCKET_STATE_CLOSED;
daniele	29:1a47b7151851	1686	/* call EV_FIN wakeup before deleting */
daniele	29:1a47b7151851	1687	if (t->sock.wakeup) {
daniele	29:1a47b7151851	1688	(t->sock).wakeup(PICO_SOCK_EV_FIN, &(t->sock));
daniele	29:1a47b7151851	1689	}
daniele	29:1a47b7151851	1690	/* delete socket */
daniele	29:1a47b7151851	1691	pico_socket_del(&t->sock);
daniele	29:1a47b7151851	1692	} else {
daniele	29:1a47b7151851	1693	tcp_dbg("TCP> trying to go to closed, wrong state\n");
daniele	29:1a47b7151851	1694	}
daniele	29:1a47b7151851	1695	}
daniele	29:1a47b7151851	1696
daniele	29:1a47b7151851	1697	static int tcp_finwaitfin(struct pico_socket s, struct pico_frame f)
daniele	29:1a47b7151851	1698	{
daniele	29:1a47b7151851	1699	struct pico_socket_tcp t = (struct pico_socket_tcp )s;
daniele	29:1a47b7151851	1700	struct pico_tcp_hdr hdr = (struct pico_tcp_hdr ) (f->transport_hdr);
daniele	29:1a47b7151851	1701	tcp_dbg("TCP> received fin in FIN_WAIT2\n");
daniele	29:1a47b7151851	1702	/* received FIN, increase ACK nr */
daniele	29:1a47b7151851	1703	t->rcv_nxt = long_be(hdr->seq) + 1;
daniele	29:1a47b7151851	1704	s->state &= 0x00FFU;
daniele	29:1a47b7151851	1705	s->state \|= PICO_SOCKET_STATE_TCP_TIME_WAIT;
daniele	29:1a47b7151851	1706	/* set SHUT_REMOTE */
daniele	29:1a47b7151851	1707	s->state \|= PICO_SOCKET_STATE_SHUT_REMOTE;
daniele	29:1a47b7151851	1708	if (s->wakeup)
daniele	29:1a47b7151851	1709	s->wakeup(PICO_SOCK_EV_CLOSE, s);
daniele	29:1a47b7151851	1710	if (f->payload_len > 0) /* needed?? */
daniele	29:1a47b7151851	1711	tcp_data_in(s,f);
daniele	29:1a47b7151851	1712	/* send ACK */
daniele	29:1a47b7151851	1713	tcp_send_ack(t);
daniele	29:1a47b7151851	1714	/* set timer */
daniele	29:1a47b7151851	1715	pico_timer_add(200, tcp_deltcb, t);
daniele	29:1a47b7151851	1716	return 0;
daniele	29:1a47b7151851	1717	}
daniele	29:1a47b7151851	1718
daniele	29:1a47b7151851	1719	static int tcp_closewaitack(struct pico_socket s, struct pico_frame f)
daniele	29:1a47b7151851	1720	{
daniele	29:1a47b7151851	1721	struct pico_socket_tcp t = (struct pico_socket_tcp )s;
daniele	29:1a47b7151851	1722	tcp_dbg("TCP> received ack in CLOSING\n");
daniele	29:1a47b7151851	1723	/* acking part */
daniele	29:1a47b7151851	1724	tcp_ack(s,f);
daniele	29:1a47b7151851	1725	/* update TCP state */
daniele	29:1a47b7151851	1726	s->state &= 0x00FFU;
daniele	29:1a47b7151851	1727	s->state \|= PICO_SOCKET_STATE_TCP_TIME_WAIT;
daniele	29:1a47b7151851	1728	/* set timer */
daniele	29:1a47b7151851	1729	pico_timer_add(200, tcp_deltcb, t);
daniele	29:1a47b7151851	1730	return 0;
daniele	29:1a47b7151851	1731	}
daniele	29:1a47b7151851	1732
daniele	29:1a47b7151851	1733	static int tcp_lastackwait(struct pico_socket s, struct pico_frame f)
daniele	29:1a47b7151851	1734	{
tass	68:0847e35d08a6	1735	IGNORE_PARAMETER(f);
daniele	29:1a47b7151851	1736	tcp_dbg("TCP> state: last_ack, received ack, to closed\n");
daniele	29:1a47b7151851	1737	s->state &= 0x00FFU;
daniele	29:1a47b7151851	1738	s->state \|= PICO_SOCKET_STATE_TCP_CLOSED;
daniele	29:1a47b7151851	1739	s->state &= 0xFF00U;
daniele	29:1a47b7151851	1740	s->state \|= PICO_SOCKET_STATE_CLOSED;
daniele	29:1a47b7151851	1741	/* call socket wakeup with EV_FIN */
daniele	29:1a47b7151851	1742	if (s->wakeup)
daniele	29:1a47b7151851	1743	s->wakeup(PICO_SOCK_EV_FIN, s);
daniele	29:1a47b7151851	1744	/* delete socket */
daniele	29:1a47b7151851	1745	pico_socket_del(s);
daniele	29:1a47b7151851	1746	return 0;
daniele	29:1a47b7151851	1747	}
daniele	29:1a47b7151851	1748
daniele	29:1a47b7151851	1749	static int tcp_syn(struct pico_socket s, struct pico_frame f)
daniele	29:1a47b7151851	1750	{
tass	95:f4ca916a26fe	1751	struct pico_socket_tcp *new=NULL;
tass	95:f4ca916a26fe	1752	struct pico_tcp_hdr *hdr=NULL;
tass	95:f4ca916a26fe	1753	if(s->number_of_pending_conn >= s->max_backlog)
tass	95:f4ca916a26fe	1754	return -1;
tass	95:f4ca916a26fe	1755	new = (struct pico_socket_tcp *)pico_socket_clone(s);
tass	95:f4ca916a26fe	1756	hdr = (struct pico_tcp_hdr *)f->transport_hdr;
daniele	29:1a47b7151851	1757	if (!new)
daniele	29:1a47b7151851	1758	return -1;
daniele	29:1a47b7151851	1759
daniele	29:1a47b7151851	1760	#ifdef PICO_TCP_SUPPORT_SOCKET_STATS
daniele	29:1a47b7151851	1761	pico_timer_add(2000, sock_stats, s);
daniele	29:1a47b7151851	1762	#endif
daniele	29:1a47b7151851	1763
daniele	29:1a47b7151851	1764	new->sock.remote_port = ((struct pico_trans *)f->transport_hdr)->sport;
daniele	29:1a47b7151851	1765	#ifdef PICO_SUPPORT_IPV4
daniele	29:1a47b7151851	1766	if (IS_IPV4(f)) {
daniele	29:1a47b7151851	1767	new->sock.remote_addr.ip4.addr = ((struct pico_ipv4_hdr *)(f->net_hdr))->src.addr;
daniele	29:1a47b7151851	1768	new->sock.local_addr.ip4.addr = ((struct pico_ipv4_hdr *)(f->net_hdr))->dst.addr;
daniele	29:1a47b7151851	1769	}
daniele	29:1a47b7151851	1770	#endif
daniele	29:1a47b7151851	1771	#ifdef PICO_SUPPORT_IPV6
daniele	29:1a47b7151851	1772	if (IS_IPV6(f)) {
tass	45:ca30069e49bb	1773	new->sock.remote_addr.ip6 = ((struct pico_ipv6_hdr *)(f->net_hdr))->src;
tass	45:ca30069e49bb	1774	new->sock.local_addr.ip6 = ((struct pico_ipv6_hdr *)(f->net_hdr))->dst;
daniele	29:1a47b7151851	1775	}
daniele	29:1a47b7151851	1776	#endif
daniele	29:1a47b7151851	1777
daniele	29:1a47b7151851	1778	/* Set socket limits */
daniele	29:1a47b7151851	1779	new->tcpq_in.max_size = PICO_DEFAULT_SOCKETQ;
daniele	29:1a47b7151851	1780	new->tcpq_out.max_size = PICO_DEFAULT_SOCKETQ;
daniele	29:1a47b7151851	1781	new->tcpq_hold.max_size = 2*PICO_TCP_DEFAULT_MSS;
tass	111:4003cf17bc15	1782	new->tcpq_in.overhead=(sizeof(struct tcp_input_segment)+sizeof(struct pico_tree_node));
tass	111:4003cf17bc15	1783	new->tcpq_out.overhead=new->tcpq_hold.overhead=sizeof(struct pico_frame)+sizeof(struct pico_tree_node);
daniele	29:1a47b7151851	1784
daniele	29:1a47b7151851	1785	f->sock = &new->sock;
daniele	29:1a47b7151851	1786	tcp_parse_options(f);
daniele	29:1a47b7151851	1787	new->mss = PICO_TCP_DEFAULT_MSS;
daniele	29:1a47b7151851	1788	new->rcv_nxt = long_be(hdr->seq) + 1;
daniele	29:1a47b7151851	1789	new->snd_nxt = long_be(pico_paws());
daniele	29:1a47b7151851	1790	new->snd_last = new->snd_nxt;
daniele	29:1a47b7151851	1791	new->cwnd = PICO_TCP_IW;
daniele	29:1a47b7151851	1792	new->ssthresh = 40;
daniele	29:1a47b7151851	1793	new->recv_wnd = short_be(hdr->rwnd);
daniele	29:1a47b7151851	1794	new->jumbo = hdr->len & 0x07;
tass	95:f4ca916a26fe	1795	s->number_of_pending_conn++;
daniele	29:1a47b7151851	1796	new->sock.parent = s;
daniele	29:1a47b7151851	1797	new->sock.wakeup = s->wakeup;
daniele	29:1a47b7151851	1798	/* Initialize timestamp values */
daniele	29:1a47b7151851	1799	new->sock.state = PICO_SOCKET_STATE_BOUND \| PICO_SOCKET_STATE_CONNECTED \| PICO_SOCKET_STATE_TCP_SYN_RECV;
daniele	29:1a47b7151851	1800	pico_socket_add(&new->sock);
daniele	29:1a47b7151851	1801	tcp_send_synack(&new->sock);
daniele	29:1a47b7151851	1802	tcp_dbg("SYNACK sent, socket added. snd_nxt is %08x\n", new->snd_nxt);
daniele	29:1a47b7151851	1803	return 0;
daniele	29:1a47b7151851	1804	}
daniele	29:1a47b7151851	1805
daniele	29:1a47b7151851	1806	static void tcp_set_init_point(struct pico_socket *s)
daniele	29:1a47b7151851	1807	{
daniele	29:1a47b7151851	1808	struct pico_socket_tcp t = (struct pico_socket_tcp )s;
daniele	29:1a47b7151851	1809	t->rcv_processed = t->rcv_nxt;
daniele	29:1a47b7151851	1810	}
daniele	29:1a47b7151851	1811
daniele	29:1a47b7151851	1812	static int tcp_synack(struct pico_socket s, struct pico_frame f)
daniele	29:1a47b7151851	1813	{
daniele	29:1a47b7151851	1814	struct pico_socket_tcp t = (struct pico_socket_tcp ) s;
daniele	29:1a47b7151851	1815	struct pico_tcp_hdr hdr = (struct pico_tcp_hdr )f->transport_hdr;
daniele	29:1a47b7151851	1816
daniele	29:1a47b7151851	1817	if (ACKN(f) == (1 + t->snd_nxt)) {
daniele	29:1a47b7151851	1818	t->rcv_nxt = long_be(hdr->seq);
daniele	29:1a47b7151851	1819	t->rcv_processed = t->rcv_nxt + 1;
daniele	29:1a47b7151851	1820	tcp_ack(s, f);
daniele	29:1a47b7151851	1821
daniele	29:1a47b7151851	1822	s->state &= 0x00FFU;
daniele	29:1a47b7151851	1823	s->state \|= PICO_SOCKET_STATE_TCP_ESTABLISHED;
daniele	29:1a47b7151851	1824	tcp_dbg("TCP> Established. State: %x\n", s->state);
daniele	29:1a47b7151851	1825
daniele	29:1a47b7151851	1826	if (s->wakeup)
daniele	29:1a47b7151851	1827	s->wakeup(PICO_SOCK_EV_CONN, s);
daniele	29:1a47b7151851	1828	s->ev_pending \|= PICO_SOCK_EV_WR;
daniele	29:1a47b7151851	1829
daniele	29:1a47b7151851	1830	t->rcv_nxt++;
daniele	29:1a47b7151851	1831	t->snd_nxt++;
daniele	29:1a47b7151851	1832	tcp_send_ack(t); /* return ACK */
daniele	29:1a47b7151851	1833
daniele	29:1a47b7151851	1834	return 0;
daniele	29:1a47b7151851	1835
daniele	29:1a47b7151851	1836	} else {
daniele	29:1a47b7151851	1837	tcp_dbg("TCP> Not established, RST sent.\n");
daniele	29:1a47b7151851	1838	tcp_nosync_rst(s,f);
daniele	29:1a47b7151851	1839	return 0;
daniele	29:1a47b7151851	1840	}
daniele	29:1a47b7151851	1841	}
daniele	29:1a47b7151851	1842
daniele	29:1a47b7151851	1843	static int tcp_first_ack(struct pico_socket s, struct pico_frame f)
daniele	29:1a47b7151851	1844	{
daniele	29:1a47b7151851	1845	struct pico_socket_tcp t = (struct pico_socket_tcp )s;
daniele	29:1a47b7151851	1846	tcp_dbg("ACK in SYN_RECV: expecting %08x got %08x\n", t->snd_nxt, ACKN(f));
daniele	29:1a47b7151851	1847	if (t->snd_nxt == ACKN(f)) {
daniele	29:1a47b7151851	1848	tcp_set_init_point(s);
daniele	29:1a47b7151851	1849	tcp_ack(s, f);
daniele	29:1a47b7151851	1850	s->state &= 0x00FFU;
daniele	29:1a47b7151851	1851	s->state \|= PICO_SOCKET_STATE_TCP_ESTABLISHED;
daniele	29:1a47b7151851	1852	tcp_dbg("TCP: Established. State now: %04x\n", s->state);
daniele	29:1a47b7151851	1853	if( !s->parent && s->wakeup) { /* If the socket has no parent, -> sending socket that has a sim_open */
daniele	29:1a47b7151851	1854	tcp_dbg("FIRST ACK - No parent found -> sending socket\n");
daniele	29:1a47b7151851	1855	s->wakeup(PICO_SOCK_EV_CONN, s);
daniele	29:1a47b7151851	1856	}
daniele	29:1a47b7151851	1857	if (s->parent && s->parent->wakeup) {
daniele	29:1a47b7151851	1858	tcp_dbg("FIRST ACK - Parent found -> listening socket\n");
daniele	29:1a47b7151851	1859	s->wakeup = s->parent->wakeup;
daniele	29:1a47b7151851	1860	s->parent->wakeup(PICO_SOCK_EV_CONN, s->parent);
daniele	29:1a47b7151851	1861	}
daniele	29:1a47b7151851	1862	s->ev_pending \|= PICO_SOCK_EV_WR;
daniele	29:1a47b7151851	1863	tcp_dbg("%s: snd_nxt is now %08x\n", __FUNCTION__, t->snd_nxt);
daniele	29:1a47b7151851	1864	return 0;
daniele	29:1a47b7151851	1865	} else {
daniele	29:1a47b7151851	1866	tcp_nosync_rst(s,f);
daniele	29:1a47b7151851	1867	return 0;
daniele	29:1a47b7151851	1868	}
daniele	29:1a47b7151851	1869	}
daniele	29:1a47b7151851	1870
daniele	29:1a47b7151851	1871	static int tcp_closewait(struct pico_socket s, struct pico_frame f)
daniele	29:1a47b7151851	1872	{
daniele	29:1a47b7151851	1873
daniele	29:1a47b7151851	1874	struct pico_socket_tcp t = (struct pico_socket_tcp )s;
daniele	29:1a47b7151851	1875	struct pico_tcp_hdr hdr = (struct pico_tcp_hdr ) (f->transport_hdr);
daniele	29:1a47b7151851	1876
tass	32:865c101e0874	1877
daniele	29:1a47b7151851	1878	if (f->payload_len > 0)
daniele	29:1a47b7151851	1879	tcp_data_in(s,f);
daniele	29:1a47b7151851	1880	if (f->flags & PICO_TCP_ACK)
daniele	29:1a47b7151851	1881	tcp_ack(s,f);
daniele	29:1a47b7151851	1882	if (seq_compare(SEQN(f), t->rcv_nxt) == 0) {
daniele	29:1a47b7151851	1883	/* received FIN, increase ACK nr */
tass	68:0847e35d08a6	1884	t->rcv_nxt = long_be(hdr->seq) + 1;
tass	68:0847e35d08a6	1885	s->state &= 0x00FFU;
tass	68:0847e35d08a6	1886	s->state \|= PICO_SOCKET_STATE_TCP_CLOSE_WAIT;
tass	68:0847e35d08a6	1887	/* set SHUT_REMOTE */
daniele	29:1a47b7151851	1888	s->state \|= PICO_SOCKET_STATE_SHUT_REMOTE;
daniele	29:1a47b7151851	1889	tcp_dbg("TCP> Close-wait\n");
tass	32:865c101e0874	1890
daniele	29:1a47b7151851	1891	if (s->wakeup){
daniele	29:1a47b7151851	1892	if(f->payload_len>0){
tass	68:0847e35d08a6	1893	struct pico_socket_tcp _t = (struct pico_socket_tcp )s;
tass	68:0847e35d08a6	1894	_t->sock.ev_pending \|=PICO_SOCK_EV_CLOSE;
daniele	29:1a47b7151851	1895	}else
daniele	29:1a47b7151851	1896	s->wakeup(PICO_SOCK_EV_CLOSE, s);
daniele	29:1a47b7151851	1897	}
daniele	29:1a47b7151851	1898	} else {
daniele	29:1a47b7151851	1899	tcp_send_ack(t); /* return ACK */
daniele	29:1a47b7151851	1900	}
daniele	29:1a47b7151851	1901	return 0;
daniele	29:1a47b7151851	1902	}
daniele	29:1a47b7151851	1903
daniele	29:1a47b7151851	1904	/static int tcp_fin(struct pico_socket s, struct pico_frame *f)
daniele	29:1a47b7151851	1905	{
daniele	29:1a47b7151851	1906	return 0;
daniele	29:1a47b7151851	1907	}*/
daniele	29:1a47b7151851	1908
daniele	29:1a47b7151851	1909	static int tcp_rcvfin(struct pico_socket s, struct pico_frame f)
daniele	29:1a47b7151851	1910	{
daniele	29:1a47b7151851	1911	struct pico_socket_tcp t = (struct pico_socket_tcp )s;
tass	68:0847e35d08a6	1912	IGNORE_PARAMETER(f);
daniele	29:1a47b7151851	1913	tcp_dbg("TCP> Received FIN in FIN_WAIT1\n");
daniele	29:1a47b7151851	1914	s->state &= 0x00FFU;
daniele	29:1a47b7151851	1915	s->state \|= PICO_SOCKET_STATE_TCP_CLOSING;
daniele	29:1a47b7151851	1916	t->rcv_processed = t->rcv_nxt + 1;
daniele	29:1a47b7151851	1917	t->rcv_nxt++;
daniele	29:1a47b7151851	1918	/* send ACK */
daniele	29:1a47b7151851	1919	tcp_send_ack(t);
daniele	29:1a47b7151851	1920	return 0;
daniele	29:1a47b7151851	1921	}
daniele	29:1a47b7151851	1922
daniele	29:1a47b7151851	1923	static int tcp_finack(struct pico_socket s, struct pico_frame f)
daniele	29:1a47b7151851	1924	{
daniele	29:1a47b7151851	1925	struct pico_socket_tcp t = (struct pico_socket_tcp )s;
tass	68:0847e35d08a6	1926	IGNORE_PARAMETER(f);
tass	68:0847e35d08a6	1927
daniele	29:1a47b7151851	1928	tcp_dbg("TCP> ENTERED finack\n");
daniele	29:1a47b7151851	1929	t->rcv_nxt++;
daniele	29:1a47b7151851	1930	/* send ACK */
daniele	29:1a47b7151851	1931	tcp_send_ack(t);
daniele	29:1a47b7151851	1932
daniele	29:1a47b7151851	1933	/* call socket wakeup with EV_FIN */
daniele	29:1a47b7151851	1934	if (s->wakeup)
daniele	29:1a47b7151851	1935	s->wakeup(PICO_SOCK_EV_FIN, s);
daniele	29:1a47b7151851	1936	s->state &= 0x00FFU;
daniele	29:1a47b7151851	1937	s->state \|= PICO_SOCKET_STATE_TCP_TIME_WAIT;
daniele	29:1a47b7151851	1938	/* set SHUT_REMOTE */
daniele	29:1a47b7151851	1939	s->state \|= PICO_SOCKET_STATE_SHUT_REMOTE;
daniele	29:1a47b7151851	1940	pico_timer_add(2000, tcp_deltcb, t);
daniele	29:1a47b7151851	1941
daniele	29:1a47b7151851	1942	return 0;
daniele	29:1a47b7151851	1943	}
daniele	29:1a47b7151851	1944
tass	70:cd218dd180e5	1945	static void tcp_force_closed(struct pico_socket *s)
tass	70:cd218dd180e5	1946	{
tass	70:cd218dd180e5	1947	struct pico_socket_tcp t = (struct pico_socket_tcp ) s;
tass	70:cd218dd180e5	1948	/* update state */
tass	70:cd218dd180e5	1949	(t->sock).state &= 0x00FFU;
tass	70:cd218dd180e5	1950	(t->sock).state \|= PICO_SOCKET_STATE_TCP_CLOSED;
tass	70:cd218dd180e5	1951	(t->sock).state &= 0xFF00U;
tass	70:cd218dd180e5	1952	(t->sock).state \|= PICO_SOCKET_STATE_CLOSED;
tass	70:cd218dd180e5	1953	}
tass	70:cd218dd180e5	1954
tass	70:cd218dd180e5	1955	static void tcp_wakeup_pending(struct pico_socket *s, uint16_t ev)
tass	70:cd218dd180e5	1956	{
tass	70:cd218dd180e5	1957	struct pico_socket_tcp t = (struct pico_socket_tcp ) s;
tass	70:cd218dd180e5	1958	if ((t->sock).wakeup)
tass	70:cd218dd180e5	1959	(t->sock).wakeup(ev, &(t->sock));
tass	70:cd218dd180e5	1960	}
tass	70:cd218dd180e5	1961
daniele	29:1a47b7151851	1962	static int tcp_rst(struct pico_socket s, struct pico_frame f)
daniele	29:1a47b7151851	1963	{
daniele	29:1a47b7151851	1964	struct pico_socket_tcp t = (struct pico_socket_tcp ) s;
daniele	29:1a47b7151851	1965	struct pico_tcp_hdr hdr = (struct pico_tcp_hdr ) (f->transport_hdr);
daniele	29:1a47b7151851	1966
daniele	29:1a47b7151851	1967	tcp_dbg("TCP >>>>>>>>>>>>>> received RST <<<<<<<<<<<<<<<<<<<<\n");
daniele	29:1a47b7151851	1968	if ((s->state & PICO_SOCKET_STATE_TCP) == PICO_SOCKET_STATE_TCP_SYN_SENT) {
daniele	29:1a47b7151851	1969	/* the RST is acceptable if the ACK field acknowledges the SYN */
daniele	29:1a47b7151851	1970	if ((t->snd_nxt + 1) == ACKN(f)) { /* valid, got to closed state */
tass	70:cd218dd180e5	1971	tcp_force_closed(s);
tass	70:cd218dd180e5	1972	tcp_wakeup_pending(s, PICO_SOCK_EV_FIN);
daniele	29:1a47b7151851	1973	pico_err = PICO_ERR_ECONNRESET;
tass	70:cd218dd180e5	1974	tcp_wakeup_pending(s, PICO_SOCK_EV_ERR);
tass	70:cd218dd180e5	1975	pico_socket_del(&t->sock); /* delete socket */
daniele	29:1a47b7151851	1976	} else { /* not valid, ignore */
daniele	29:1a47b7151851	1977	tcp_dbg("TCP RST> IGNORE\n");
daniele	29:1a47b7151851	1978	return 0;
daniele	29:1a47b7151851	1979	}
daniele	29:1a47b7151851	1980	} else { /* all other states */
daniele	29:1a47b7151851	1981	/* all reset (RST) segments are validated by checking their SEQ-fields,
daniele	29:1a47b7151851	1982	a reset is valid if its sequence number is in the window */
tass	70:cd218dd180e5	1983	if ((long_be(hdr->seq) >= t->rcv_ackd) && (long_be(hdr->seq) <= ((uint32_t)(short_be(hdr->rwnd)<<(t->wnd_scale)) + t->rcv_ackd))) {
daniele	29:1a47b7151851	1984	if ((s->state & PICO_SOCKET_STATE_TCP) == PICO_SOCKET_STATE_TCP_SYN_RECV) {
tass	106:d34698d89baf	1985	s->parent->number_of_pending_conn--;
tass	70:cd218dd180e5	1986	tcp_force_closed(s);
daniele	29:1a47b7151851	1987	pico_err = PICO_ERR_ECONNRESET;
tass	70:cd218dd180e5	1988	tcp_wakeup_pending(s, PICO_SOCK_EV_ERR);
tass	70:cd218dd180e5	1989	pico_socket_del(&t->sock); /* delete socket */
daniele	29:1a47b7151851	1990	tcp_dbg("TCP RST> SOCKET BACK TO LISTEN\n");
tass	109:f630e6230063	1991	// pico_socket_del(s);
daniele	29:1a47b7151851	1992	} else {
tass	70:cd218dd180e5	1993	tcp_force_closed(s);
tass	70:cd218dd180e5	1994	tcp_wakeup_pending(s, PICO_SOCK_EV_FIN);
daniele	29:1a47b7151851	1995	pico_err = PICO_ERR_ECONNRESET;
tass	70:cd218dd180e5	1996	tcp_wakeup_pending(s, PICO_SOCK_EV_ERR);
tass	70:cd218dd180e5	1997	pico_socket_del(&t->sock); /* delete socket */
daniele	29:1a47b7151851	1998	}
daniele	29:1a47b7151851	1999	} else { /* not valid, ignore */
daniele	29:1a47b7151851	2000	tcp_dbg("TCP RST> IGNORE\n");
daniele	29:1a47b7151851	2001	return 0;
daniele	29:1a47b7151851	2002	}
daniele	29:1a47b7151851	2003	}
daniele	29:1a47b7151851	2004
daniele	29:1a47b7151851	2005	return 0;
daniele	29:1a47b7151851	2006	}
tass	79:6d1cb906043d	2007	static int tcp_halfopencon(struct pico_socket s, struct pico_frame fr)
tass	79:6d1cb906043d	2008	{
tass	79:6d1cb906043d	2009	struct pico_socket_tcp t = (struct pico_socket_tcp ) s;
tass	79:6d1cb906043d	2010	IGNORE_PARAMETER(fr);
tass	79:6d1cb906043d	2011	tcp_send_ack(t);
tass	79:6d1cb906043d	2012	return 0;
tass	79:6d1cb906043d	2013	}
tass	110:0ece1bbbd36e	2014
tass	109:f630e6230063	2015	static int tcp_closeconn(struct pico_socket s, struct pico_frame fr)
tass	109:f630e6230063	2016	{
tass	109:f630e6230063	2017	struct pico_socket_tcp t = (struct pico_socket_tcp ) s;
tass	109:f630e6230063	2018	struct pico_tcp_hdr hdr = (struct pico_tcp_hdr ) (fr->transport_hdr);
tass	109:f630e6230063	2019
tass	109:f630e6230063	2020	if (seq_compare(SEQN(fr), t->rcv_nxt) == 0) {
tass	109:f630e6230063	2021	/* received FIN, increase ACK nr */
tass	109:f630e6230063	2022	t->rcv_nxt = long_be(hdr->seq) + 1;
tass	109:f630e6230063	2023	s->state &= 0x00FFU;
tass	109:f630e6230063	2024	s->state \|= PICO_SOCKET_STATE_TCP_CLOSE_WAIT;
tass	109:f630e6230063	2025	/* set SHUT_LOCAL */
tass	109:f630e6230063	2026	s->state \|= PICO_SOCKET_STATE_SHUT_LOCAL;
tass	109:f630e6230063	2027	pico_socket_close(s);
tass	109:f630e6230063	2028	s->parent->number_of_pending_conn--;
tass	109:f630e6230063	2029	return 1;
tass	109:f630e6230063	2030	}
tass	109:f630e6230063	2031	return 0;
tass	109:f630e6230063	2032	}
tass	110:0ece1bbbd36e	2033
daniele	29:1a47b7151851	2034	struct tcp_action_entry {
daniele	29:1a47b7151851	2035	uint16_t tcpstate;
daniele	29:1a47b7151851	2036	int (syn)(struct pico_socket s, struct pico_frame *f);
daniele	29:1a47b7151851	2037	int (synack)(struct pico_socket s, struct pico_frame *f);
daniele	29:1a47b7151851	2038	int (ack)(struct pico_socket s, struct pico_frame *f);
daniele	29:1a47b7151851	2039	int (data)(struct pico_socket s, struct pico_frame *f);
daniele	29:1a47b7151851	2040	int (fin)(struct pico_socket s, struct pico_frame *f);
daniele	29:1a47b7151851	2041	int (finack)(struct pico_socket s, struct pico_frame *f);
daniele	29:1a47b7151851	2042	int (rst)(struct pico_socket s, struct pico_frame *f);
daniele	29:1a47b7151851	2043	};
daniele	29:1a47b7151851	2044
daniele	29:1a47b7151851	2045	static struct tcp_action_entry tcp_fsm[] = {
daniele	29:1a47b7151851	2046	/* State syn synack ack data fin finack rst*/
daniele	29:1a47b7151851	2047	{ PICO_SOCKET_STATE_TCP_UNDEF, NULL, NULL, NULL, NULL, NULL, NULL, NULL },
daniele	29:1a47b7151851	2048	{ PICO_SOCKET_STATE_TCP_CLOSED, NULL, NULL, NULL, NULL, NULL, NULL, NULL },
daniele	29:1a47b7151851	2049	{ PICO_SOCKET_STATE_TCP_LISTEN, &tcp_syn, &tcp_nosync_rst, &tcp_nosync_rst, &tcp_nosync_rst, &tcp_nosync_rst, &tcp_nosync_rst, NULL },
tass	40:c8ab0d2bba0b	2050	{ PICO_SOCKET_STATE_TCP_SYN_SENT, &tcp_nosync_rst, &tcp_synack, &tcp_nosync_rst, &tcp_nosync_rst, &tcp_nosync_rst, &tcp_nosync_rst, &tcp_rst },
tass	110:0ece1bbbd36e	2051	{ PICO_SOCKET_STATE_TCP_SYN_RECV, NULL, &tcp_nosync_rst, &tcp_first_ack, &tcp_data_in, &tcp_nosync_rst, &tcp_closeconn, &tcp_rst },
tass	79:6d1cb906043d	2052	{ PICO_SOCKET_STATE_TCP_ESTABLISHED, &tcp_halfopencon,&tcp_ack, &tcp_ack, &tcp_data_in, &tcp_closewait, &tcp_closewait, &tcp_rst },
tass	45:ca30069e49bb	2053	{ PICO_SOCKET_STATE_TCP_CLOSE_WAIT, NULL, &tcp_ack, &tcp_ack, &tcp_send_rst, &tcp_closewait, &tcp_closewait, &tcp_rst },
tass	40:c8ab0d2bba0b	2054	{ PICO_SOCKET_STATE_TCP_LAST_ACK, NULL, &tcp_ack, &tcp_lastackwait, &tcp_send_rst, &tcp_send_rst, &tcp_send_rst, &tcp_rst },
tass	40:c8ab0d2bba0b	2055	{ PICO_SOCKET_STATE_TCP_FIN_WAIT1, NULL, &tcp_ack, &tcp_finwaitack, &tcp_data_in, &tcp_rcvfin, &tcp_finack, &tcp_rst },
tass	40:c8ab0d2bba0b	2056	{ PICO_SOCKET_STATE_TCP_FIN_WAIT2, NULL, &tcp_ack, &tcp_ack, &tcp_data_in, &tcp_finwaitfin, &tcp_finack, &tcp_rst },
tass	40:c8ab0d2bba0b	2057	{ PICO_SOCKET_STATE_TCP_CLOSING, NULL, &tcp_ack, &tcp_closewaitack, &tcp_send_rst, &tcp_send_rst, &tcp_send_rst, &tcp_rst },
tass	40:c8ab0d2bba0b	2058	{ PICO_SOCKET_STATE_TCP_TIME_WAIT, NULL, &tcp_ack, &tcp_send_rst, &tcp_send_rst, &tcp_send_rst, &tcp_send_rst, &tcp_rst }
daniele	29:1a47b7151851	2059	};
daniele	29:1a47b7151851	2060
daniele	29:1a47b7151851	2061	/*
daniele	29:1a47b7151851	2062	NOTE: in SYN-RECV receiving syn when cloned by default (see yellow pos-it), should send reset.
daniele	29:1a47b7151851	2063	*/
daniele	29:1a47b7151851	2064
daniele	29:1a47b7151851	2065	int pico_tcp_input(struct pico_socket s, struct pico_frame f)
daniele	29:1a47b7151851	2066	{
daniele	29:1a47b7151851	2067	struct pico_tcp_hdr hdr = (struct pico_tcp_hdr ) (f->transport_hdr);
daniele	29:1a47b7151851	2068	int ret = 0;
daniele	29:1a47b7151851	2069	uint8_t flags = hdr->flags;
daniele	29:1a47b7151851	2070	struct tcp_action_entry *action = &tcp_fsm[s->state >> 8];
daniele	29:1a47b7151851	2071
daniele	29:1a47b7151851	2072	f->payload = (f->transport_hdr + ((hdr->len & 0xf0) >> 2));
tass	70:cd218dd180e5	2073	f->payload_len = (uint16_t)(f->transport_len - ((hdr->len & 0xf0) >> 2));
daniele	29:1a47b7151851	2074
daniele	29:1a47b7151851	2075	tcp_dbg("[%lu] TCP> [tcp input] socket: %p state: %d <-- local port:%d remote port: %d seq: %08x ack: %08x flags: %02x = t_len: %d, hdr: %u payload: %d\n", pico_tick,
daniele	29:1a47b7151851	2076	s, s->state >> 8, short_be(hdr->trans.dport), short_be(hdr->trans.sport), SEQN(f), ACKN(f), hdr->flags, f->transport_len, (hdr->len & 0xf0) >> 2, f->payload_len );
daniele	29:1a47b7151851	2077
daniele	29:1a47b7151851	2078	/* This copy of the frame has the current socket as owner */
daniele	29:1a47b7151851	2079	f->sock = s;
tass	68:0847e35d08a6	2080	s->timestamp = PICO_TIME_MS();
daniele	29:1a47b7151851	2081	/* Those are not supported at this time. */
tass	73:dfb737147f6e	2082	flags &= (uint8_t)~(PICO_TCP_CWR \| PICO_TCP_URG \| PICO_TCP_ECN);
daniele	29:1a47b7151851	2083	if (flags == PICO_TCP_SYN) {
daniele	29:1a47b7151851	2084	if (action->syn)
daniele	29:1a47b7151851	2085	action->syn(s,f);
daniele	29:1a47b7151851	2086	} else if (flags == (PICO_TCP_SYN \| PICO_TCP_ACK)) {
daniele	29:1a47b7151851	2087	if (action->synack)
daniele	29:1a47b7151851	2088	action->synack(s,f);
daniele	29:1a47b7151851	2089	} else {
daniele	29:1a47b7151851	2090	if ((flags == PICO_TCP_ACK) \|\| (flags == (PICO_TCP_ACK \| PICO_TCP_PSH))) {
daniele	29:1a47b7151851	2091	if (action->ack) {
daniele	29:1a47b7151851	2092	action->ack(s,f);
daniele	29:1a47b7151851	2093	}
daniele	29:1a47b7151851	2094	}
tass	68:0847e35d08a6	2095	if (f->payload_len > 0 && !(s->state & PICO_SOCKET_STATE_CLOSED) && !TCP_IS_STATE(s,PICO_SOCKET_STATE_TCP_LISTEN))
tass	68:0847e35d08a6	2096	{
daniele	29:1a47b7151851	2097	ret = f->payload_len;
daniele	29:1a47b7151851	2098	if (action->data)
daniele	29:1a47b7151851	2099	action->data(s,f);
daniele	29:1a47b7151851	2100	}
daniele	29:1a47b7151851	2101	if (flags == PICO_TCP_FIN) {
daniele	29:1a47b7151851	2102	if (action->fin)
daniele	29:1a47b7151851	2103	action->fin(s,f);
daniele	29:1a47b7151851	2104	}
daniele	29:1a47b7151851	2105	if ((flags == (PICO_TCP_FIN \| PICO_TCP_ACK)) \|\| (flags == (PICO_TCP_FIN \| PICO_TCP_ACK \| PICO_TCP_PSH))) {
daniele	29:1a47b7151851	2106	if (action->finack)
daniele	29:1a47b7151851	2107	action->finack(s,f);
daniele	29:1a47b7151851	2108	}
daniele	29:1a47b7151851	2109	if (flags & PICO_TCP_RST) {
daniele	29:1a47b7151851	2110	if (action->rst)
daniele	29:1a47b7151851	2111	action->rst(s,f);
daniele	29:1a47b7151851	2112	}
daniele	29:1a47b7151851	2113	}
daniele	29:1a47b7151851	2114
daniele	29:1a47b7151851	2115	//discard:
daniele	29:1a47b7151851	2116	pico_frame_discard(f);
daniele	29:1a47b7151851	2117	return ret;
daniele	29:1a47b7151851	2118	}
daniele	29:1a47b7151851	2119
tass	73:dfb737147f6e	2120	static void tcp_send_keepalive(uint32_t when, void *_t)
daniele	29:1a47b7151851	2121	{
daniele	29:1a47b7151851	2122	struct pico_socket_tcp t = (struct pico_socket_tcp )_t;
tass	68:0847e35d08a6	2123	IGNORE_PARAMETER(when);
tass	82:93915e13262a	2124	tcp_dbg("Sending keepalive (%d), [State = %d]...\n", t->backoff,t->sock.state );
daniele	29:1a47b7151851	2125	if( t->sock.net && ((t->sock.state & 0xFF00) == PICO_SOCKET_STATE_TCP_ESTABLISHED) )
daniele	29:1a47b7151851	2126	{
tass	68:0847e35d08a6	2127	tcp_send_ack(t);
daniele	29:1a47b7151851	2128
tass	68:0847e35d08a6	2129	if (t->keepalive_timer_running > 0) {
tass	68:0847e35d08a6	2130	t->keepalive_timer_running--;
tass	68:0847e35d08a6	2131	}
daniele	29:1a47b7151851	2132
tass	68:0847e35d08a6	2133	if (t->keepalive_timer_running == 0) {
tass	68:0847e35d08a6	2134	t->keepalive_timer_running++;
tass	68:0847e35d08a6	2135	tcp_dbg("[Self] Adding timer(retransmit keepalive)\n");
tass	68:0847e35d08a6	2136	pico_timer_add(t->rto << (++t->backoff), tcp_send_keepalive, t);
tass	68:0847e35d08a6	2137	}
daniele	29:1a47b7151851	2138	}
daniele	29:1a47b7151851	2139	}
daniele	29:1a47b7151851	2140
tass	76:938a140caf12	2141	inline static int checkLocalClosing(struct pico_socket *s);
tass	76:938a140caf12	2142	inline static int checkRemoteClosing(struct pico_socket *s);
tass	76:938a140caf12	2143
tass	48:40fc4462265c	2144
daniele	29:1a47b7151851	2145	int pico_tcp_output(struct pico_socket *s, int loop_score)
daniele	29:1a47b7151851	2146	{
daniele	29:1a47b7151851	2147	struct pico_socket_tcp t = (struct pico_socket_tcp )s;
daniele	29:1a47b7151851	2148	struct pico_frame f, una;
daniele	29:1a47b7151851	2149	struct pico_tcp_hdr *hdr;
daniele	29:1a47b7151851	2150	int sent = 0;
daniele	29:1a47b7151851	2151
daniele	29:1a47b7151851	2152	una = first_segment(&t->tcpq_out);
daniele	29:1a47b7151851	2153
daniele	29:1a47b7151851	2154	f = peek_segment(&t->tcpq_out, t->snd_nxt);
daniele	29:1a47b7151851	2155	while((f) && (t->cwnd >= t->in_flight)) {
daniele	29:1a47b7151851	2156	hdr = (struct pico_tcp_hdr *)f->transport_hdr;
daniele	29:1a47b7151851	2157	f->timestamp = pico_tick;
daniele	29:1a47b7151851	2158	tcp_add_options(t, f, hdr->flags, tcp_options_size(t, hdr->flags));
tass	70:cd218dd180e5	2159	if (seq_compare((SEQN(f) + f->payload_len), (SEQN(una) + (uint32_t)(t->recv_wnd << t->recv_wnd_scale))) > 0) {
tass	70:cd218dd180e5	2160	t->cwnd = (uint16_t)t->in_flight;
daniele	29:1a47b7151851	2161	if (t->cwnd < 1)
daniele	29:1a47b7151851	2162	t->cwnd = 1;
daniele	29:1a47b7151851	2163	if (t->x_mode != PICO_TCP_WINDOW_FULL) {
daniele	29:1a47b7151851	2164	tcp_dbg("TCP> RIGHT SIZING (rwnd: %d, frame len: %d\n",t->recv_wnd << t->recv_wnd_scale, f->payload_len);
daniele	29:1a47b7151851	2165	tcp_dbg("In window full...\n");
tass	45:ca30069e49bb	2166	t->snd_nxt = SEQN(una); /* XXX prevent out-of-order-packets ! / /DLA re-enabled.*/
tass	40:c8ab0d2bba0b	2167	t->snd_retry = SEQN(una); /* XXX replace by retry pointer? */
daniele	29:1a47b7151851	2168
daniele	29:1a47b7151851	2169	/* Alternative to the line above: (better performance, but seems to lock anyway with larger buffers)
daniele	29:1a47b7151851	2170	if (seq_compare(t->snd_nxt, SEQN(una)) > 0)
daniele	29:1a47b7151851	2171	t->snd_nxt -= f->payload_len;
daniele	29:1a47b7151851	2172	*/
daniele	29:1a47b7151851	2173
daniele	29:1a47b7151851	2174	t->x_mode = PICO_TCP_WINDOW_FULL;
daniele	29:1a47b7151851	2175	if (t->keepalive_timer_running == 0) {
daniele	29:1a47b7151851	2176	tcp_dbg("[Window full] Adding timer(send keepalive)\n");
daniele	29:1a47b7151851	2177	tcp_send_keepalive(0, t);
daniele	29:1a47b7151851	2178	}
daniele	29:1a47b7151851	2179	}
daniele	29:1a47b7151851	2180	break;
daniele	29:1a47b7151851	2181	}
daniele	29:1a47b7151851	2182	tcp_dbg("TCP> DEQUEUED (for output) frame %08x, acks %08x len= %d, remaining frames %d\n", SEQN(f), ACKN(f), f->payload_len,t->tcpq_out.frames);
daniele	29:1a47b7151851	2183	tcp_send(t, f);
daniele	29:1a47b7151851	2184	sent++;
daniele	29:1a47b7151851	2185	loop_score--;
daniele	29:1a47b7151851	2186	t->snd_last_out = SEQN(f);
daniele	29:1a47b7151851	2187	if (loop_score < 1)
daniele	29:1a47b7151851	2188	break;
daniele	29:1a47b7151851	2189	if (f->payload_len > 0) {
daniele	29:1a47b7151851	2190	f = next_segment(&t->tcpq_out, f);
daniele	29:1a47b7151851	2191	} else {
daniele	29:1a47b7151851	2192	f = NULL;
daniele	29:1a47b7151851	2193	}
daniele	29:1a47b7151851	2194	}
daniele	29:1a47b7151851	2195	if (sent > 0) {
daniele	29:1a47b7151851	2196	if (t->rto < PICO_TCP_RTO_MIN)
daniele	29:1a47b7151851	2197	t->rto = PICO_TCP_RTO_MIN;
tass	45:ca30069e49bb	2198	//if (s->wakeup)
tass	45:ca30069e49bb	2199	// t->sock.wakeup(PICO_SOCK_EV_WR, &t->sock);
daniele	29:1a47b7151851	2200	add_retransmission_timer(t, pico_tick + t->rto);
daniele	29:1a47b7151851	2201	} else {
tass	45:ca30069e49bb	2202	/* Nothing to transmit. */
daniele	29:1a47b7151851	2203	}
daniele	29:1a47b7151851	2204
daniele	29:1a47b7151851	2205	if ((t->tcpq_out.frames == 0) && (s->state & PICO_SOCKET_STATE_SHUT_LOCAL)) { /* if no more packets in queue, XXX replacled !f by tcpq check */
tass	76:938a140caf12	2206	if(!checkLocalClosing(&t->sock)) // check if local closing started and send fin
tass	76:938a140caf12	2207	{
tass	76:938a140caf12	2208	checkRemoteClosing(&t->sock); // check if remote closing started and send fin
tass	76:938a140caf12	2209	}
daniele	29:1a47b7151851	2210	}
daniele	29:1a47b7151851	2211	return loop_score;
daniele	29:1a47b7151851	2212	}
daniele	29:1a47b7151851	2213
daniele	29:1a47b7151851	2214	/* function to make new segment from hold queue with specific size (mss) */
daniele	29:1a47b7151851	2215	static struct pico_frame * pico_hold_segment_make(struct pico_socket_tcp *t)
daniele	29:1a47b7151851	2216	{
daniele	29:1a47b7151851	2217	struct pico_frame f_temp,f_new;
daniele	29:1a47b7151851	2218	struct pico_socket s = (struct pico_socket ) &t->sock;
daniele	29:1a47b7151851	2219	struct pico_tcp_hdr *hdr;
tass	70:cd218dd180e5	2220	uint16_t total_len = 0, total_payload_len = 0;
tass	70:cd218dd180e5	2221	uint16_t off = 0, test = 0;
daniele	29:1a47b7151851	2222
daniele	29:1a47b7151851	2223	off = pico_tcp_overhead(s);
daniele	29:1a47b7151851	2224
daniele	29:1a47b7151851	2225	/* init with first frame in hold queue */
daniele	29:1a47b7151851	2226	f_temp = first_segment(&t->tcpq_hold);
daniele	29:1a47b7151851	2227	total_len = f_temp->payload_len;
daniele	29:1a47b7151851	2228	f_temp = next_segment(&t->tcpq_hold, f_temp);
daniele	29:1a47b7151851	2229
daniele	29:1a47b7151851	2230	/* check till total_len <= MSS */
daniele	29:1a47b7151851	2231	while ((f_temp != NULL) && ((total_len+f_temp->payload_len) <= PICO_TCP_DEFAULT_MSS)) {
tass	73:dfb737147f6e	2232	total_len = (uint16_t)(total_len + f_temp->payload_len);
daniele	29:1a47b7151851	2233	f_temp = next_segment(&t->tcpq_hold, f_temp);
daniele	29:1a47b7151851	2234	if (f_temp == NULL)
daniele	29:1a47b7151851	2235	break;
daniele	29:1a47b7151851	2236	}
daniele	29:1a47b7151851	2237	/* alloc new frame with payload size = off + total_len */
tass	70:cd218dd180e5	2238	f_new = pico_socket_frame_alloc(s, (uint16_t)(off + total_len));
daniele	29:1a47b7151851	2239	if (!f_new) {
daniele	29:1a47b7151851	2240	pico_err = PICO_ERR_ENOMEM;
daniele	29:1a47b7151851	2241	return f_new;
daniele	29:1a47b7151851	2242	}
daniele	29:1a47b7151851	2243
daniele	29:1a47b7151851	2244	hdr = (struct pico_tcp_hdr *) f_new->transport_hdr;
daniele	29:1a47b7151851	2245	/* init new frame */
daniele	29:1a47b7151851	2246	f_new->payload += off;
tass	73:dfb737147f6e	2247	f_new->payload_len = (uint16_t)(f_new->payload_len - off);
daniele	29:1a47b7151851	2248	f_new->sock = s;
daniele	29:1a47b7151851	2249
daniele	29:1a47b7151851	2250	f_temp = first_segment(&t->tcpq_hold);
daniele	29:1a47b7151851	2251	hdr->seq = ((struct pico_tcp_hdr )(f_temp->transport_hdr))->seq; / get sequence number of first frame */
daniele	29:1a47b7151851	2252	hdr->trans.sport = t->sock.local_port;
daniele	29:1a47b7151851	2253	hdr->trans.dport = t->sock.remote_port;
daniele	29:1a47b7151851	2254
daniele	29:1a47b7151851	2255	/* check till total_payload_len <= MSS */
daniele	29:1a47b7151851	2256	while ((f_temp != NULL) && ((total_payload_len + f_temp->payload_len) <= PICO_TCP_DEFAULT_MSS)) {
daniele	29:1a47b7151851	2257	/* cpy data and discard frame */
daniele	29:1a47b7151851	2258	test++;
daniele	29:1a47b7151851	2259	memcpy(f_new->payload + total_payload_len, f_temp->payload, f_temp->payload_len);
tass	73:dfb737147f6e	2260	total_payload_len = (uint16_t)(total_payload_len + f_temp->payload_len);
daniele	29:1a47b7151851	2261	pico_discard_segment(&t->tcpq_hold, f_temp);
daniele	29:1a47b7151851	2262	f_temp = first_segment(&t->tcpq_hold);
daniele	29:1a47b7151851	2263	}
daniele	29:1a47b7151851	2264
tass	70:cd218dd180e5	2265	hdr->len = (uint8_t)((f_new->payload - f_new->transport_hdr) << 2 \| t->jumbo);
daniele	29:1a47b7151851	2266
tass	45:ca30069e49bb	2267	tcp_dbg_nagle("NAGLE make - joined %d segments, len %d bytes\n",test,total_payload_len);
daniele	29:1a47b7151851	2268
daniele	29:1a47b7151851	2269	return f_new;
daniele	29:1a47b7151851	2270	}
daniele	29:1a47b7151851	2271
daniele	29:1a47b7151851	2272	/* original behavior kept when Nagle disabled;
daniele	29:1a47b7151851	2273	Nagle algorithm added here, keeping hold frame queue instead of eg linked list of data */
tass	70:cd218dd180e5	2274	int32_t pico_tcp_push(struct pico_protocol self, struct pico_frame f)
daniele	29:1a47b7151851	2275	{
daniele	29:1a47b7151851	2276	struct pico_tcp_hdr hdr = (struct pico_tcp_hdr )f->transport_hdr;
daniele	29:1a47b7151851	2277	struct pico_socket_tcp t = (struct pico_socket_tcp ) f->sock;
daniele	29:1a47b7151851	2278	struct pico_frame *f_new;
tass	70:cd218dd180e5	2279	uint32_t total_len = 0;
tass	68:0847e35d08a6	2280	IGNORE_PARAMETER(self);
tass	68:0847e35d08a6	2281	pico_err = PICO_ERR_NOERR;
daniele	29:1a47b7151851	2282	hdr->trans.sport = t->sock.local_port;
daniele	29:1a47b7151851	2283	hdr->trans.dport = t->sock.remote_port;
daniele	29:1a47b7151851	2284	hdr->seq = long_be(t->snd_last + 1);
tass	70:cd218dd180e5	2285	hdr->len = (uint8_t)((f->payload - f->transport_hdr) << 2 \| t->jumbo);
daniele	29:1a47b7151851	2286
tass	68:0847e35d08a6	2287	if ((uint32_t)f->payload_len > (uint32_t)(t->tcpq_out.max_size - t->tcpq_out.size))
tass	70:cd218dd180e5	2288	t->sock.ev_pending &= (uint16_t)(~PICO_SOCK_EV_WR);
daniele	29:1a47b7151851	2289
daniele	29:1a47b7151851	2290	/***************************************************************************/
daniele	29:1a47b7151851	2291
daniele	29:1a47b7151851	2292	if (!IS_NAGLE_ENABLED((&(t->sock)))) {
daniele	29:1a47b7151851	2293	/* TCP_NODELAY enabled, original behavior */
daniele	29:1a47b7151851	2294	if (pico_enqueue_segment(&t->tcpq_out,f) > 0) {
tass	45:ca30069e49bb	2295	tcp_dbg_nagle("TCP_PUSH - NO NAGLE - Pushing segment %08x, len %08x to socket %p\n", t->snd_last + 1, f->payload_len, t);
daniele	29:1a47b7151851	2296	t->snd_last += f->payload_len;
daniele	29:1a47b7151851	2297	return f->payload_len;
daniele	29:1a47b7151851	2298	} else {
daniele	29:1a47b7151851	2299	tcp_dbg("Enqueue failed.\n");
daniele	29:1a47b7151851	2300	return 0;
daniele	29:1a47b7151851	2301	}
daniele	29:1a47b7151851	2302	}
daniele	29:1a47b7151851	2303	/***************************************************************************/
daniele	29:1a47b7151851	2304	else {
daniele	29:1a47b7151851	2305	/* Nagle's algorithm enabled, check if ready to send, or put frame in hold queue */
daniele	29:1a47b7151851	2306	if (IS_TCP_IDLE(t) && IS_TCP_HOLDQ_EMPTY(t)) { /* opt 1. send frame */
daniele	29:1a47b7151851	2307	if (pico_enqueue_segment(&t->tcpq_out,f) > 0) {
tass	45:ca30069e49bb	2308	tcp_dbg_nagle("TCP_PUSH - NAGLE - Pushing segment %08x, len %08x to socket %p\n", t->snd_last + 1, f->payload_len, t);
daniele	29:1a47b7151851	2309	t->snd_last += f->payload_len;
daniele	29:1a47b7151851	2310	return f->payload_len;
daniele	29:1a47b7151851	2311	} else {
daniele	29:1a47b7151851	2312	tcp_dbg("Enqueue failed.\n");
daniele	29:1a47b7151851	2313	return 0;
daniele	29:1a47b7151851	2314	}
daniele	29:1a47b7151851	2315	} else { /* opt 2. hold data back */
daniele	29:1a47b7151851	2316	total_len = f->payload_len + t->tcpq_hold.size;
daniele	29:1a47b7151851	2317	if ((total_len >= PICO_TCP_DEFAULT_MSS) && ((t->tcpq_out.max_size - t->tcpq_out.size) >= PICO_TCP_DEFAULT_MSS)) {/* TODO check mss socket */
daniele	29:1a47b7151851	2318	/* IF enough data in hold (>mss) AND space in out queue (>mss) */
daniele	29:1a47b7151851	2319	/* add current frame in hold and make new segment */
daniele	29:1a47b7151851	2320	if (pico_enqueue_segment(&t->tcpq_hold,f) > 0 ) {
tass	45:ca30069e49bb	2321	tcp_dbg_nagle("TCP_PUSH - NAGLE - Pushed into hold, make new (enqueued frames out %d)\n",t->tcpq_out.frames);
daniele	29:1a47b7151851	2322	t->snd_last += f->payload_len; /* XXX WATCH OUT */
daniele	29:1a47b7151851	2323	f_new = pico_hold_segment_make(t);
daniele	29:1a47b7151851	2324	} else {
tass	45:ca30069e49bb	2325	tcp_dbg_nagle("TCP_PUSH - NAGLE - enqueue hold failed 1\n");
daniele	29:1a47b7151851	2326	return 0;
daniele	29:1a47b7151851	2327	}
daniele	29:1a47b7151851	2328	/* and put new frame in out queue */
daniele	29:1a47b7151851	2329	if ((f_new != NULL) && (pico_enqueue_segment(&t->tcpq_out,f_new) > 0)) {
daniele	29:1a47b7151851	2330	return f_new->payload_len;
daniele	29:1a47b7151851	2331	} else {
tass	45:ca30069e49bb	2332	tcp_dbg_nagle("TCP_PUSH - NAGLE - enqueue out failed, f_new = %p\n",f_new);
daniele	29:1a47b7151851	2333	return -1; /* XXX something seriously wrong */
daniele	29:1a47b7151851	2334	}
daniele	29:1a47b7151851	2335	} else {
daniele	29:1a47b7151851	2336	/* ELSE put frame in hold queue */
daniele	29:1a47b7151851	2337	if (pico_enqueue_segment(&t->tcpq_hold,f) > 0) {
tass	45:ca30069e49bb	2338	tcp_dbg_nagle("TCP_PUSH - NAGLE - Pushed into hold (enqueued frames out %d)\n",t->tcpq_out.frames);
daniele	29:1a47b7151851	2339	t->snd_last += f->payload_len; /* XXX WATCH OUT */
daniele	29:1a47b7151851	2340	return f->payload_len;
daniele	29:1a47b7151851	2341	} else {
tass	68:0847e35d08a6	2342	pico_err = PICO_ERR_EAGAIN;
tass	45:ca30069e49bb	2343	tcp_dbg_nagle("TCP_PUSH - NAGLE - enqueue hold failed 2\n");
daniele	29:1a47b7151851	2344	return 0;
daniele	29:1a47b7151851	2345	}
daniele	29:1a47b7151851	2346	}
daniele	29:1a47b7151851	2347	}
tass	97:e73b01cb3147	2348	}
daniele	29:1a47b7151851	2349	/***************************************************************************/
daniele	29:1a47b7151851	2350	}
tass	68:0847e35d08a6	2351
tass	68:0847e35d08a6	2352	inline static void tcp_discard_all_segments(struct pico_tcp_queue *tq)
tass	68:0847e35d08a6	2353	{
tass	68:0847e35d08a6	2354	struct pico_tree_node index = NULL, index_safe = NULL;
tass	68:0847e35d08a6	2355	LOCK(Mutex);
tass	68:0847e35d08a6	2356	pico_tree_foreach_safe(index,&tq->pool,index_safe)
tass	68:0847e35d08a6	2357	{
tass	110:0ece1bbbd36e	2358	void *f = index->keyValue;
tass	68:0847e35d08a6	2359	if(!f)
tass	68:0847e35d08a6	2360	break;
tass	68:0847e35d08a6	2361	pico_tree_delete(&tq->pool,f);
tass	110:0ece1bbbd36e	2362	if(IS_INPUT_QUEUE(tq))
tass	110:0ece1bbbd36e	2363	{
tass	110:0ece1bbbd36e	2364	struct tcp_input_segment inp = (struct tcp_input_segment )f;
tass	110:0ece1bbbd36e	2365	pico_free(inp->payload);
tass	110:0ece1bbbd36e	2366	pico_free(inp);
tass	110:0ece1bbbd36e	2367	}
tass	110:0ece1bbbd36e	2368	else
tass	110:0ece1bbbd36e	2369	pico_frame_discard(f);
tass	68:0847e35d08a6	2370	}
tass	68:0847e35d08a6	2371	tq->frames = 0;
tass	68:0847e35d08a6	2372	tq->size = 0;
tass	68:0847e35d08a6	2373	UNLOCK(Mutex);
tass	68:0847e35d08a6	2374	}
tass	68:0847e35d08a6	2375
tass	68:0847e35d08a6	2376	void pico_tcp_cleanup_queues(struct pico_socket *sck)
tass	68:0847e35d08a6	2377	{
tass	68:0847e35d08a6	2378	struct pico_socket_tcp * tcp = (struct pico_socket_tcp *)sck;
tass	70:cd218dd180e5	2379	if(tcp->retrans_tmr)
tass	70:cd218dd180e5	2380	pico_timer_cancel(tcp->retrans_tmr);
tass	68:0847e35d08a6	2381	tcp_discard_all_segments(&tcp->tcpq_in);
tass	68:0847e35d08a6	2382	tcp_discard_all_segments(&tcp->tcpq_out);
tass	68:0847e35d08a6	2383	tcp_discard_all_segments(&tcp->tcpq_hold);
tass	68:0847e35d08a6	2384	}
tass	68:0847e35d08a6	2385
tass	76:938a140caf12	2386	static int checkLocalClosing(struct pico_socket *s)
tass	76:938a140caf12	2387	{
tass	76:938a140caf12	2388	struct pico_socket_tcp * t = (struct pico_socket_tcp *)s;
tass	76:938a140caf12	2389	if ((s->state & PICO_SOCKET_STATE_TCP) == PICO_SOCKET_STATE_TCP_ESTABLISHED) {
tass	76:938a140caf12	2390	tcp_dbg("TCP> buffer empty, shutdown established ...\n");
tass	76:938a140caf12	2391	/* send fin if queue empty and in state shut local (write) */
tass	76:938a140caf12	2392	tcp_send_fin(t);
tass	76:938a140caf12	2393	/* change tcp state to FIN_WAIT1 */
tass	76:938a140caf12	2394	s->state &= 0x00FFU;
tass	76:938a140caf12	2395	s->state \|= PICO_SOCKET_STATE_TCP_FIN_WAIT1;
tass	76:938a140caf12	2396	return 1;
tass	76:938a140caf12	2397	}
tass	76:938a140caf12	2398	return 0;
tass	76:938a140caf12	2399	}
tass	76:938a140caf12	2400
tass	76:938a140caf12	2401	static int checkRemoteClosing(struct pico_socket *s)
tass	76:938a140caf12	2402	{
tass	76:938a140caf12	2403	struct pico_socket_tcp * t = (struct pico_socket_tcp *)s;
tass	76:938a140caf12	2404	if ((s->state & PICO_SOCKET_STATE_TCP) == PICO_SOCKET_STATE_TCP_CLOSE_WAIT) {
tass	76:938a140caf12	2405	/* send fin if queue empty and in state shut local (write) */
tass	76:938a140caf12	2406	tcp_send_fin(t);
tass	76:938a140caf12	2407	/* change tcp state to LAST_ACK */
tass	76:938a140caf12	2408	s->state &= 0x00FFU;
tass	76:938a140caf12	2409	s->state \|= PICO_SOCKET_STATE_TCP_LAST_ACK;
tass	76:938a140caf12	2410	tcp_dbg("TCP> STATE: LAST_ACK.\n");
tass	76:938a140caf12	2411	return 1;
tass	76:938a140caf12	2412	}
tass	76:938a140caf12	2413	return 0;
tass	76:938a140caf12	2414	}
tass	76:938a140caf12	2415
tass	76:938a140caf12	2416	void pico_tcp_notify_closing(struct pico_socket *sck)
tass	76:938a140caf12	2417	{
tass	76:938a140caf12	2418	struct pico_socket_tcp t=(struct pico_socket_tcp )sck;
tass	76:938a140caf12	2419	if(t->tcpq_out.frames == 0)
tass	76:938a140caf12	2420	{
tass	109:f630e6230063	2421	if(!checkLocalClosing(sck))
tass	109:f630e6230063	2422	checkRemoteClosing(sck);
tass	76:938a140caf12	2423	}
tass	76:938a140caf12	2424	}
tass	76:938a140caf12	2425
daniele	29:1a47b7151851	2426	#endif //PICO_SUPPORT_TCP
tass	79:6d1cb906043d	2427
tass	79:6d1cb906043d	2428