switch(c->state) {
case CLOSED:
case LISTEN:
- case SYN_SENT:
- case SYN_RECEIVED:
debug("Error: send() called on unconnected connection %p\n", c);
errno = ENOTCONN;
return -1;
+ case SYN_SENT:
+ case SYN_RECEIVED:
case ESTABLISHED:
case CLOSE_WAIT:
break;
}
c->snd.last += len;
+
+ // Don't send anything yet if the connection has not fully established yet
+
+ if (c->state == SYN_SENT || c->state == SYN_RECEIVED)
+ return len;
+
ack(c, false);
if(!is_reliable(c)) {
ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
+ const uint8_t *ptr = data;
+
if(!utcp) {
errno = EFAULT;
return -1;
// Make a copy from the potentially unaligned data to a struct hdr
- memcpy(&hdr, data, sizeof(hdr));
- data += sizeof(hdr);
+ memcpy(&hdr, ptr, sizeof(hdr));
+ ptr += sizeof(hdr);
len -= sizeof(hdr);
// Drop packets with an unknown CTL flag
return -1;
}
- init = data;
+ init = ptr;
break;
default:
}
len -= auxlen;
- data += auxlen;
+ ptr += auxlen;
if(!(aux & 0x800)) {
break;
return -1;
}
- memcpy(&aux, data, 2);
+ memcpy(&aux, ptr, 2);
len -= 2;
- data += 2;
+ ptr += 2;
}
// Try to match the packet to an existing connection
acceptable = len > (size_t) - rcv_offset;
if(acceptable) {
- data -= rcv_offset;
+ ptr -= rcv_offset;
len += rcv_offset;
hdr.seq -= rcv_offset;
}
}
}
+ uint32_t advanced;
+
if(!(hdr.ctl & ACK)) {
+ advanced = 0;
goto skip_ack;
}
// 3. Advance snd.una
- uint32_t advanced = seqdiff(hdr.ack, c->snd.una);
+ advanced = seqdiff(hdr.ack, c->snd.una);
prevrcvnxt = c->rcv.nxt;
if(advanced) {
c->rcv.irs = hdr.seq;
c->rcv.nxt = hdr.seq;
- set_state(c, ESTABLISHED);
+ if(c->shut_wr) {
+ c->snd.last++;
+ set_state(c, FIN_WAIT_1);
+ } else {
+ set_state(c, ESTABLISHED);
+ }
// TODO: notify application of this somehow.
break;
return 0;
}
- handle_incoming_data(c, hdr.seq, data, len);
+ handle_incoming_data(c, hdr.seq, ptr, len);
}
// 7. Process FIN stuff
return 0;
}
+ // Only process shutting down writes once.
+ if (c->shut_wr)
+ return 0;
+
+ c->shut_wr = true;
+
switch(c->state) {
case CLOSED:
case LISTEN:
return -1;
case SYN_SENT:
- set_state(c, CLOSED);
return 0;
case SYN_RECEIVED:
}
size_t utcp_get_sndbuf_free(struct utcp_connection *c) {
- if(c && (c->state == ESTABLISHED || c->state == CLOSE_WAIT)) {
+ if (!c)
+ return 0;
+
+ switch(c->state) {
+ case SYN_SENT:
+ case SYN_RECEIVED:
+ case ESTABLISHED:
+ case CLOSE_WAIT:
return buffer_free(&c->sndbuf);
- } else {
+
+ default:
return 0;
}
}