}
memcpy(&hdr, pkt, sizeof hdr);
- debug("%p %s: len=%lu, src=%u dst=%u seq=%u ack=%u wnd=%u ctl=", utcp, dir, (unsigned long)len, hdr.src, hdr.dst, hdr.seq, hdr.ack, hdr.wnd);
+ debug("%p %s: len=%lu, src=%u dst=%u seq=%u ack=%u wnd=%u aux=%x ctl=", utcp, dir, (unsigned long)len, hdr.src, hdr.dst, hdr.seq, hdr.ack, hdr.wnd, hdr.aux);
if(hdr.ctl & SYN)
debug("SYN");
if(hdr.ctl & RST)
}
}
+static bool is_reliable(struct utcp_connection *c) {
+ return c->flags & UTCP_RELIABLE;
+}
+
static inline void list_connections(struct utcp *utcp) {
debug("%p has %d connections:\n", utcp, utcp->nconnections);
for(int i = 0; i < utcp->nconnections; i++)
c->recv = recv;
c->priv = priv;
- struct hdr hdr;
-
- hdr.src = c->src;
- hdr.dst = c->dst;
- hdr.seq = c->snd.iss;
- hdr.ack = 0;
- hdr.wnd = c->rcv.wnd;
- hdr.ctl = SYN;
- hdr.aux = 0;
+ struct {
+ struct hdr hdr;
+ uint8_t init[4];
+ } pkt;
+
+ pkt.hdr.src = c->src;
+ pkt.hdr.dst = c->dst;
+ pkt.hdr.seq = c->snd.iss;
+ pkt.hdr.ack = 0;
+ pkt.hdr.wnd = c->rcv.wnd;
+ pkt.hdr.ctl = SYN;
+ pkt.hdr.aux = 0x0101;
+ pkt.init[0] = 1;
+ pkt.init[1] = 0;
+ pkt.init[2] = 0;
+ pkt.init[3] = flags & 0x7;
set_state(c, SYN_SENT);
- print_packet(utcp, "send", &hdr, sizeof hdr);
- utcp->send(utcp, &hdr, sizeof hdr);
+ print_packet(utcp, "send", &pkt, sizeof pkt);
+ utcp->send(utcp, &pkt, sizeof pkt);
gettimeofday(&c->conn_timeout, NULL);
c->conn_timeout.tv_sec += utcp->timeout;
+ start_retransmit_timer(c);
+
return c;
}
struct {
struct hdr hdr;
- char data[];
+ uint8_t data[];
} *pkt;
pkt = malloc(sizeof pkt->hdr + c->utcp->mtu);
return -1;
}
- // Add data to send buffer
+ // Exit early if we have nothing to send.
if(!len)
return 0;
return -1;
}
+ // Add data to send buffer.
+
len = buffer_put(&c->sndbuf, data, len);
if(len <= 0) {
errno = EWOULDBLOCK;
c->snd.last += len;
ack(c, false);
- if(!timerisset(&c->rtrx_timeout))
+ if(!is_reliable(c)) {
+ c->snd.una = c->snd.nxt = c->snd.last;
+ buffer_get(&c->sndbuf, NULL, c->sndbuf.used);
+ }
+ if(is_reliable(c) && !timerisset(&c->rtrx_timeout))
start_retransmit_timer(c);
return len;
}
struct {
struct hdr hdr;
- char data[];
+ uint8_t data[];
} *pkt;
pkt = malloc(sizeof pkt->hdr + c->utcp->mtu);
pkt->hdr.seq = c->snd.iss;
pkt->hdr.ack = 0;
pkt->hdr.ctl = SYN;
- print_packet(c->utcp, "rtrx", pkt, sizeof pkt->hdr);
- utcp->send(utcp, pkt, sizeof pkt->hdr);
+ pkt->hdr.aux = 0x0101;
+ pkt->data[0] = 1;
+ pkt->data[1] = 0;
+ pkt->data[2] = 0;
+ pkt->data[3] = c->flags & 0x7;
+ print_packet(c->utcp, "rtrx", pkt, sizeof pkt->hdr + 4);
+ utcp->send(utcp, pkt, sizeof pkt->hdr + 4);
break;
case SYN_RECEIVED:
static void handle_incoming_data(struct utcp_connection *c, uint32_t seq, const void *data, size_t len) {
+ if(!is_reliable(c)) {
+ c->recv(c, data, len);
+ c->rcv.nxt = seq + len;
+ return;
+ }
+
uint32_t offset = seqdiff(seq, c->rcv.nxt);
if(offset + len > c->rcvbuf.maxsize)
abort();
return -1;
}
+ // Check for auxiliary headers
+
+ const uint8_t *init = NULL;
+
+ uint16_t aux = hdr.aux;
+ while(aux) {
+ size_t auxlen = 4 * (aux >> 8) & 0xf;
+ uint8_t auxtype = aux & 0xff;
+
+ if(len < auxlen) {
+ errno = EBADMSG;
+ return -1;
+ }
+
+ switch(auxtype) {
+ case AUX_INIT:
+ if(!(hdr.ctl & SYN) || auxlen != 4) {
+ errno = EBADMSG;
+ return -1;
+ }
+ init = data;
+ break;
+ default:
+ errno = EBADMSG;
+ return -1;
+ }
+
+ len -= auxlen;
+ data += auxlen;
+
+ if(!(aux & 0x800))
+ break;
+
+ if(len < 2) {
+ errno = EBADMSG;
+ return -1;
+ }
+
+ memcpy(&aux, data, 2);
+ len -= 2;
+ data += 2;
+ }
+
// Try to match the packet to an existing connection
struct utcp_connection *c = find_connection(utcp, hdr.dst, hdr.src);
goto reset;
}
+ // Parse auxilliary information
+ if(init) {
+ if(init[0] < 1) {
+ len = 1;
+ goto reset;
+ }
+ c->flags = init[3] & 0x7;
+ } else {
+ c->flags = UTCP_TCP;
+ }
+
// Return SYN+ACK, go to SYN_RECEIVED state
c->snd.wnd = hdr.wnd;
c->rcv.irs = hdr.seq;
c->rcv.nxt = c->rcv.irs + 1;
set_state(c, SYN_RECEIVED);
- hdr.dst = c->dst;
- hdr.src = c->src;
- hdr.ack = c->rcv.irs + 1;
- hdr.seq = c->snd.iss;
- hdr.ctl = SYN | ACK;
- print_packet(c->utcp, "send", &hdr, sizeof hdr);
- utcp->send(utcp, &hdr, sizeof hdr);
+ struct {
+ struct hdr hdr;
+ uint8_t data[4];
+ } pkt;
+
+ pkt.hdr.src = c->src;
+ pkt.hdr.dst = c->dst;
+ pkt.hdr.ack = c->rcv.irs + 1;
+ pkt.hdr.seq = c->snd.iss;
+ pkt.hdr.wnd = c->rcv.wnd;
+ pkt.hdr.ctl = SYN | ACK;
+ if(init) {
+ pkt.hdr.aux = 0x0101;
+ pkt.data[0] = 1;
+ pkt.data[1] = 0;
+ pkt.data[2] = 0;
+ pkt.data[3] = c->flags & 0x7;
+ print_packet(c->utcp, "send", &pkt, sizeof hdr + 4);
+ utcp->send(utcp, &pkt, sizeof hdr + 4);
+ } else {
+ pkt.hdr.aux = 0;
+ print_packet(c->utcp, "send", &pkt, sizeof hdr);
+ utcp->send(utcp, &pkt, sizeof hdr);
+ }
} else {
// No, we don't want your packets, send a RST back
len = 1;
}
}
+ if(!(hdr.ctl & ACK))
+ goto skip_ack;
+
// 3. Advance snd.una
uint32_t advanced = seqdiff(hdr.ack, c->snd.una);
break;
}
} else {
- if(!len) {
+ if(!len && is_reliable(c)) {
c->dupack++;
if(c->dupack == 3) {
debug("Triplicate ACK\n");
timerclear(&c->conn_timeout); // It will be set anew in utcp_timeout() if c->snd.una != c->snd.nxt.
if(c->snd.una == c->snd.last)
stop_retransmit_timer(c);
- else
+ else if(is_reliable(c))
start_retransmit_timer(c);
}
+skip_ack:
// 5. Process SYN stuff
if(hdr.ctl & SYN) {
case LAST_ACK:
case TIME_WAIT:
// Ehm, no. We should never receive a second SYN.
- goto reset;
+ return 0;
default:
#ifdef UTCP_DEBUG
abort();
reset:
swap_ports(&hdr);
hdr.wnd = 0;
+ hdr.aux = 0;
if(hdr.ctl & ACK) {
hdr.seq = hdr.ack;
hdr.ctl = RST;
retransmit(c);
}
- if(c->poll && buffer_free(&c->sndbuf) && (c->state == ESTABLISHED || c->state == CLOSE_WAIT))
- c->poll(c, buffer_free(&c->sndbuf));
+ if(c->poll) {
+ if((c->state == ESTABLISHED || c->state == CLOSE_WAIT)) {
+ uint32_t len = buffer_free(&c->sndbuf);
+ if(len)
+ c->poll(c, len);
+ } else if(c->state == CLOSED) {
+ c->poll(c, 0);
+ }
+ }
if(timerisset(&c->conn_timeout) && timercmp(&c->conn_timeout, &next, <))
next = c->conn_timeout;
utcp->mtu = mtu;
}
+void utcp_reset_timers(struct utcp *utcp) {
+ if(!utcp)
+ return;
+ struct timeval now, then;
+ gettimeofday(&now, NULL);
+ then = now;
+ then.tv_sec += utcp->timeout;
+ for(int i = 0; i < utcp->nconnections; i++) {
+ utcp->connections[i]->rtrx_timeout = now;
+ utcp->connections[i]->conn_timeout = then;
+ utcp->connections[i]->rtt_start.tv_sec = 0;
+ }
+ if(utcp->rto > START_RTO)
+ utcp->rto = START_RTO;
+}
+
int utcp_get_user_timeout(struct utcp *u) {
return u ? u->timeout : 0;
}
projects / utcp / blobdiff