Daniele Lacamera / PicoTCP-Experimental_CDC_ECM_Branch

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

Fork of PicoTCP by Daniele Lacamera

modules/pico_tcp.c@6:55b47464d5bc, 2013-05-31 (annotated)

Committer:
tass
Date:
Fri May 31 11:34:20 2013 +0000
Revision:
6:55b47464d5bc
Integrated mbed friendly sockets;

Who changed what in which revision?

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