return NULL;
}
- assert((flags & ~0xf) == 0);
+ assert((flags & ~0x1f) == 0);
c->flags = flags;
c->recv = recv;
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);
// Don't send anything yet if the connection has not fully established yet
- if (c->state == SYN_SENT || c->state == SYN_RECEIVED)
+ if(c->state == SYN_SENT || c->state == SYN_RECEIVED) {
return len;
+ }
ack(c, false);
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;
}
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:
// 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;
+
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;
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);
}
// Only process shutting down writes once.
- if (c->shut_wr)
+ if(c->shut_wr) {
return 0;
+ }
c->shut_wr = true;
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)
+ if(!c) {
return 0;
+ }
switch(c->state) {
case SYN_SENT:
}
}
+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;
+ }
+}
projects / utcp / blobdiff