return NULL;
}
- assert((flags & ~0xf) == 0);
+ assert((flags & ~0x1f) == 0);
c->flags = flags;
c->recv = recv;
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;
return -1;
}
+ // Check if we need to be able to buffer all data
+
+ if(c->flags & UTCP_NO_PARTIAL) {
+ if(len > buffer_free(&c->sndbuf)) {
+ if(len > c->sndbuf.maxsize) {
+ errno = EMSGSIZE;
+ return -1;
+ } else {
+ errno = EWOULDBLOCK;
+ return 0;
+ }
+ }
+ }
+
// Add data to send buffer.
len = buffer_put(&c->sndbuf, data, len);
}
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)) {
start_retransmit_timer(c);
}
+ if(is_reliable(c) && !timerisset(&c->conn_timeout)) {
+ gettimeofday(&c->conn_timeout, NULL);
+ c->conn_timeout.tv_sec += c->utcp->timeout;
+ }
+
return 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;
// 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;
}
c->recv(c, NULL, 0);
}
+ if(c->poll && !c->reapable) {
+ c->poll(c, 0);
+ }
+
return 0;
case SYN_RECEIVED:
c->recv(c, NULL, 0);
}
+ if(c->poll && !c->reapable) {
+ c->poll(c, 0);
+ }
+
return 0;
case CLOSING:
}
}
+ 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) {
// 4. Update timers
if(advanced) {
- 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);
+ timerclear(&c->conn_timeout);
} else if(is_reliable(c)) {
start_retransmit_timer(c);
+ gettimeofday(&c->conn_timeout, NULL);
+ c->conn_timeout.tv_sec += utcp->timeout;
}
}
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
c->rcv.nxt++;
len++;
- // Inform the application that the peer closed the connection.
+ // Inform the application that the peer closed its end of the connection.
if(c->recv) {
errno = 0;
c->recv(c, NULL, 0);
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:
return 0;
}
-int utcp_close(struct utcp_connection *c) {
- if(utcp_shutdown(c, SHUT_RDWR) && errno != ENOTCONN) {
- return -1;
- }
-
- c->recv = NULL;
- c->poll = NULL;
- c->reapable = true;
- return 0;
-}
-
-int utcp_abort(struct utcp_connection *c) {
+static bool reset_connection(struct utcp_connection *c) {
if(!c) {
errno = EFAULT;
- return -1;
+ return false;
}
if(c->reapable) {
debug("Error: abort() called on closed connection %p\n", c);
errno = EBADF;
- return -1;
+ return false;
}
c->recv = NULL;
c->poll = NULL;
- c->reapable = true;
switch(c->state) {
case CLOSED:
- return 0;
+ return true;
case LISTEN:
case SYN_SENT:
case LAST_ACK:
case TIME_WAIT:
set_state(c, CLOSED);
- return 0;
+ return true;
case SYN_RECEIVED:
case ESTABLISHED:
print_packet(c->utcp, "send", &hdr, sizeof(hdr));
c->utcp->send(c->utcp, &hdr, sizeof(hdr));
+ return true;
+}
+
+// Closes all the opened connections
+void utcp_abort_all_connections(struct utcp *utcp) {
+ if(!utcp) {
+ errno = EINVAL;
+ return;
+ }
+
+ for(int i = 0; i < utcp->nconnections; i++) {
+ struct utcp_connection *c = utcp->connections[i];
+
+ if(c->reapable || c->state == CLOSED) {
+ continue;
+ }
+
+ utcp_recv_t old_recv = c->recv;
+ utcp_poll_t old_poll = c->poll;
+
+ reset_connection(c);
+
+ if(old_recv) {
+ errno = 0;
+ old_recv(c, NULL, 0);
+ }
+
+ if(old_poll && !c->reapable) {
+ errno = 0;
+ old_poll(c, 0);
+ }
+ }
+
+ return;
+}
+
+int utcp_close(struct utcp_connection *c) {
+ if(utcp_shutdown(c, SHUT_RDWR) && errno != ENOTCONN) {
+ return -1;
+ }
+
+ c->recv = NULL;
+ c->poll = NULL;
+ c->reapable = true;
+ return 0;
+}
+
+int utcp_abort(struct utcp_connection *c) {
+ if(!reset_connection(c)) {
+ return -1;
+ }
+
+ c->reapable = true;
return 0;
}
c->recv(c, NULL, 0);
}
+ if(c->poll && !c->reapable) {
+ c->poll(c, 0);
+ }
+
continue;
}
for(int i = 0; i < utcp->nconnections; i++) {
struct utcp_connection *c = utcp->connections[i];
- if(!c->reapable)
+ if(!c->reapable) {
if(c->recv) {
c->recv(c, NULL, 0);
}
+ if(c->poll && !c->reapable) {
+ c->poll(c, 0);
+ }
+ }
+
buffer_exit(&c->rcvbuf);
buffer_exit(&c->sndbuf);
free(c);
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;
+ struct utcp_connection *c = utcp->connections[i];
+
+ if(c->reapable) {
+ continue;
+ }
+
+ c->rtrx_timeout = now;
+ c->conn_timeout = then;
+ c->rtt_start.tv_sec = 0;
}
if(utcp->rto > START_RTO) {
}
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;
}
}
}
}
+size_t utcp_get_sendq(struct utcp_connection *c) {
+ return c->sndbuf.used;
+}
+
+size_t utcp_get_recvq(struct utcp_connection *c) {
+ return c->rcvbuf.used;
+}
+
bool utcp_get_nodelay(struct utcp_connection *c) {
return c ? c->nodelay : false;
}
utcp->pre_accept = pre_accept;
}
}
+
+void utcp_expect_data(struct utcp_connection *c, bool expect) {
+ if(!c || c->reapable) {
+ return;
+ }
+
+ if(!(c->state == ESTABLISHED || c->state == FIN_WAIT_1 || c->state == FIN_WAIT_2)) {
+ return;
+ }
+
+ if(expect) {
+ // If we expect data, start the connection timer.
+ if(!timerisset(&c->conn_timeout)) {
+ gettimeofday(&c->conn_timeout, NULL);
+ c->conn_timeout.tv_sec += c->utcp->timeout;
+ }
+ } else {
+ // If we want to cancel expecting data, only clear the timer when there is no unACKed data.
+ if(c->snd.una == c->snd.last) {
+ timerclear(&c->conn_timeout);
+ }
+ }
+}
+
+void utcp_offline(struct utcp *utcp, bool offline) {
+ for(int i = 0; i < utcp->nconnections; i++) {
+ struct utcp_connection *c = utcp->connections[i];
+
+ if(!c->reapable) {
+ utcp_expect_data(c, offline);
+
+ // If we are online again, reset the retransmission timers, but keep the connection timeout as it is,
+ // to prevent peers toggling online/offline state frequently from keeping connections alive
+ // if there is no progress in sending actual data.
+ if(!offline) {
+ gettimeofday(&utcp->connections[i]->rtrx_timeout, NULL);
+ utcp->connections[i]->rtt_start.tv_sec = 0;
+ }
+ }
+ }
+
+ if(!offline && utcp->rto > START_RTO) {
+ utcp->rto = START_RTO;
+ }
+}