Daniele Lacamera / PicoTCP-Experimental_CDC_ECM_Branch

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

Fork of PicoTCP by Daniele Lacamera

modules/pico_tcp.c@45:ca30069e49bb, 2013-07-23 (annotated)

Committer:
tass
Date:
Tue Jul 23 13:22:24 2013 +0000
Revision:
45:ca30069e49bb
Parent:
40:c8ab0d2bba0b
Child:
49:40fc4462265c
Updated pico_tcp and pico_frame from masterbranch.

Who changed what in which revision?

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