Daniele Lacamera / PicoTCP Featured

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

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

PicoTCP. Copyright (c) 2013 TASS Belgium NV.

Released under the GNU General Public License, version 2.

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

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

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

Development steps:

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

Demo application (measuring TCP sender performance):

Import programlpc1768-picotcp-demo

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

Last commit 17 May 2013 by TASS Belgium

modules/pico_tcp.c@32:865c101e0874, 2013-06-20 (annotated)

Committer:
tass
Date:
Thu Jun 20 12:36:39 2013 +0000
Revision:
32:865c101e0874
Parent:
29:1a47b7151851
Child:
36:afa3ab5e06b3
Fixed a few bugs. Sequential connections seem to work fine now.

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