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);
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.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);
}
utcp_recv_t old_recv = c->recv;
+ utcp_poll_t old_poll = c->poll;
reset_connection(c);
errno = 0;
old_recv(c, NULL, 0);
}
+
+ if(old_poll && !c->reapable) {
+ errno = 0;
+ old_poll(c, 0);
+ }
}
return;
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) {
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;
+ }
+}