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@37:bdf736327c71, 2013-07-03 (annotated)

Committer:
tass
Date:
Wed Jul 03 08:56:01 2013 +0000
Revision:
37:bdf736327c71
Parent:
36:afa3ab5e06b3
Child:
40:c8ab0d2bba0b
Added DNS calls to stack interface.; Integrated the DNS feature in Endpoint.; Fixed incomplete data receiving.;

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