+ }
+
+ for(int i = 0; i < NSACKS && c->sacks[i].len; i++) {
+ debug("SACK[%d] offset %u len %u\n", i, c->sacks[i].offset, c->sacks[i].len);
+ }
+}
+
+static void handle_out_of_order(struct utcp_connection *c, uint32_t offset, const void *data, size_t len) {
+ debug("out of order packet, offset %u\n", offset);
+ // Packet loss or reordering occured. Store the data in the buffer.
+ ssize_t rxd = buffer_put_at(&c->rcvbuf, offset, data, len);
+
+ if(rxd < 0 || (size_t)rxd < len) {
+ abort();
+ }
+
+ // Make note of where we put it.
+ for(int i = 0; i < NSACKS; i++) {
+ if(!c->sacks[i].len) { // nothing to merge, add new entry
+ debug("New SACK entry %d\n", i);
+ c->sacks[i].offset = offset;
+ c->sacks[i].len = rxd;
+ break;
+ } else if(offset < c->sacks[i].offset) {
+ if(offset + rxd < c->sacks[i].offset) { // insert before
+ if(!c->sacks[NSACKS - 1].len) { // only if room left
+ debug("Insert SACK entry at %d\n", i);
+ memmove(&c->sacks[i + 1], &c->sacks[i], (NSACKS - i - 1) * sizeof(c->sacks)[i]);
+ c->sacks[i].offset = offset;
+ c->sacks[i].len = rxd;
+ } else {
+ debug("SACK entries full, dropping packet\n");
+ }
+
+ break;
+ } else { // merge
+ debug("Merge with start of SACK entry at %d\n", i);
+ c->sacks[i].offset = offset;
+ break;
+ }
+ } else if(offset <= c->sacks[i].offset + c->sacks[i].len) {
+ if(offset + rxd > c->sacks[i].offset + c->sacks[i].len) { // merge
+ debug("Merge with end of SACK entry at %d\n", i);
+ c->sacks[i].len = offset + rxd - c->sacks[i].offset;
+ // TODO: handle potential merge with next entry
+ }
+
+ break;
+ }
+ }
+
+ for(int i = 0; i < NSACKS && c->sacks[i].len; i++) {
+ debug("SACK[%d] offset %u len %u\n", i, c->sacks[i].offset, c->sacks[i].len);
+ }
+}
+
+static void handle_in_order(struct utcp_connection *c, const void *data, size_t len) {
+ // Check if we can process out-of-order data now.
+ if(c->sacks[0].len && len >= c->sacks[0].offset) { // TODO: handle overlap with second SACK
+ debug("incoming packet len %lu connected with SACK at %u\n", (unsigned long)len, c->sacks[0].offset);
+ buffer_put_at(&c->rcvbuf, 0, data, len); // TODO: handle return value
+ len = max(len, c->sacks[0].offset + c->sacks[0].len);
+ data = c->rcvbuf.data;
+ }
+
+ if(c->recv) {
+ ssize_t rxd = c->recv(c, data, len);
+
+ if(rxd < 0 || (size_t)rxd != len) {
+ // TODO: handle the application not accepting all data.
+ abort();
+ }
+ }
+
+ if(c->rcvbuf.used) {
+ sack_consume(c, len);
+ }
+
+ c->rcv.nxt += len;
+}
+
+
+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();
+ }
+
+ if(offset) {
+ handle_out_of_order(c, offset, data, len);
+ } else {
+ handle_in_order(c, data, len);
+ }
+}
+
+
+ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
+ const uint8_t *ptr = data;
+
+ if(!utcp) {
+ errno = EFAULT;
+ return -1;
+ }
+
+ if(!len) {
+ return 0;
+ }
+
+ if(!data) {
+ errno = EFAULT;
+ return -1;
+ }
+
+ print_packet(utcp, "recv", data, len);
+
+ // Drop packets smaller than the header
+
+ struct hdr hdr;
+
+ if(len < sizeof(hdr)) {
+ errno = EBADMSG;
+ return -1;
+ }
+
+ // Make a copy from the potentially unaligned data to a struct hdr
+
+ memcpy(&hdr, ptr, sizeof(hdr));
+ ptr += sizeof(hdr);
+ len -= sizeof(hdr);
+
+ // Drop packets with an unknown CTL flag
+
+ if(hdr.ctl & ~(SYN | ACK | RST | FIN)) {
+ errno = EBADMSG;
+ 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 = ptr;
+ break;
+
+ default:
+ errno = EBADMSG;
+ return -1;
+ }
+
+ len -= auxlen;
+ ptr += auxlen;
+
+ if(!(aux & 0x800)) {
+ break;
+ }
+
+ if(len < 2) {
+ errno = EBADMSG;
+ return -1;
+ }
+
+ memcpy(&aux, ptr, 2);
+ len -= 2;
+ ptr += 2;
+ }
+
+ // Try to match the packet to an existing connection
+
+ struct utcp_connection *c = find_connection(utcp, hdr.dst, hdr.src);
+
+ // Is it for a new connection?
+
+ if(!c) {
+ // Ignore RST packets
+