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:
return 0;
}
-int utcp_close(struct utcp_connection *c) {
- if(utcp_shutdown(c, SHUT_RDWR) && errno != ENOTCONN) {
- return -1;
+// Closes all the opened connections
+void utcp_abort_all_connections(struct utcp *utcp) {
+ if(!utcp) {
+ return;
}
- c->recv = NULL;
- c->poll = NULL;
- c->reapable = true;
- return 0;
+ for(int i = 0; i < utcp->nconnections; i++) {
+ struct utcp_connection *c = utcp->connections[i];
+
+ if(c->recv) {
+ errno = 0;
+ c->recv(c, NULL, 0);
+ }
+
+ if(utcp_reset_connection(c) != -1) {
+ c->reapable = false;
+ }
+ }
+
+ return;
}
-int utcp_abort(struct utcp_connection *c) {
+int utcp_reset_connection(struct utcp_connection *c) {
if(!c) {
errno = EFAULT;
return -1;
c->recv = NULL;
c->poll = NULL;
- c->reapable = true;
switch(c->state) {
case CLOSED:
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) {
+ int utcp_reset_return;
+
+ utcp_reset_return = utcp_reset_connection(c);
+
+ if(utcp_reset_return != -1) {
+ c->reapable = true;
+ }
+
+ return utcp_reset_return;
+}
+
/* Handle timeouts.
* One call to this function will loop through all connections,
* checking if something needs to be resent or not.
}
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;
}
}