From 850542e9585f716985c25d5995ba5bcb2cc6ba87 Mon Sep 17 00:00:00 2001
From: Guus Sliepen <guus@meshlink.io>
Date: Mon, 2 Oct 2017 22:52:53 +0200
Subject: [PATCH] Format the code using the Artistic Style formatter.

---
 .astylerc  |  10 +
 .gitignore |   2 +
 Makefile   |   5 +-
 selftest.c |  38 ++--
 test.c     | 131 ++++++++++---
 utcp.c     | 548 +++++++++++++++++++++++++++++++++++++----------------
 6 files changed, 531 insertions(+), 203 deletions(-)
 create mode 100644 .astylerc

diff --git a/.astylerc b/.astylerc
new file mode 100644
index 0000000..ba38946
--- /dev/null
+++ b/.astylerc
@@ -0,0 +1,10 @@
+--indent=tab=8
+--convert-tabs
+-j
+-f
+-A2
+-U
+-p
+-xg
+-k3
+-w
diff --git a/.gitignore b/.gitignore
index 4b29b74..980671a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,6 @@
 .*
+!.astylerc
+!.gitignore
 *~
 *.o
 /test
diff --git a/Makefile b/Makefile
index c2429e5..9748954 100644
--- a/Makefile
+++ b/Makefile
@@ -14,4 +14,7 @@ selftest: utcp.o selftest.c
 clean:
 	rm -f *.o $(BIN)
 
-.PHONY: clean
+astyle:
+	astyle --options=.astylerc -nQ *.c *.h
+
+.PHONY: clean astyle
diff --git a/selftest.c b/selftest.c
index da6b7ca..0b8a891 100644
--- a/selftest.c
+++ b/selftest.c
@@ -12,28 +12,35 @@ struct utcp_connection *c;
 
 ssize_t do_recv(struct utcp_connection *x, const void *data, size_t len) {
 	if(!len) {
-		if(errno)
+		if(errno) {
 			fprintf(stderr, "%p Error: %s\n", x->utcp, strerror(errno));
-		else
+		} else {
 			fprintf(stderr, "%p Connection closed by peer\n", x->utcp);
+		}
+
 		if(x != c) {
 			fprintf(stderr, "closing my side too...\n");
 			utcp_close(x);
 		}
+
 		return -1;
 	}
 
-	if(x == c)
+	if(x == c) {
 		return write(0, data, len);
-	else
+	} else {
 		return utcp_send(x, data, len);
+	}
 }
 
 bool do_pre_accept(struct utcp *utcp, uint16_t port) {
 	(void)utcp;
 	fprintf(stderr, "pre-accept\n");
-	if(port != 7)
+
+	if(port != 7) {
 		return false;
+	}
+
 	return true;
 }
 
@@ -45,15 +52,17 @@ void do_accept(struct utcp_connection *c, uint16_t port) {
 
 ssize_t do_send(struct utcp *utcp, const void *data, size_t len) {
 	static int count = 0;
+
 	if(++count > 1000) {
 		fprintf(stderr, "Too many packets!\n");
 		abort();
 	}
 
-	if(utcp == a)
+	if(utcp == a) {
 		return utcp_recv(b, data, len);
-	else
+	} else {
 		return utcp_recv(a, data, len);
+	}
 }
 
 int main(int argc, char *argv[]) {
@@ -87,18 +96,21 @@ int main(int argc, char *argv[]) {
 	ssize_t len = utcp_send(c, "Hello world!\n", 13);
 
 	if(len != 13) {
-		if(len == -1)
+		if(len == -1) {
 			fprintf(stderr, "Error: %s\n", strerror(errno));
-		else
+		} else {
 			fprintf(stderr, "Short write %zd!\n", len);
+		}
 	}
+
 	len = utcp_send(c, "This is a test.\n", 16);
 
 	if(len != 16) {
-		if(len == -1)
+		if(len == -1) {
 			fprintf(stderr, "Error: %s\n", strerror(errno));
-		else
+		} else {
 			fprintf(stderr, "Short write %zd!\n", len);
+		}
 	}
 
 	fprintf(stderr, "closing...\n");
@@ -111,8 +123,10 @@ int main(int argc, char *argv[]) {
 	char buf[20480] = "buf";
 
 	len = utcp_send(c, buf, sizeof(buf));
-	if(len != 10240)
+
+	if(len != 10240) {
 		fprintf(stderr, "Error: utcp_send() returned %zd, expected 10240\n", len);
+	}
 
 	fprintf(stderr, "closing...\n");
 	utcp_close(c);
diff --git a/test.c b/test.c
index 94c0d7c..81f45a5 100644
--- a/test.c
+++ b/test.c
@@ -52,6 +52,7 @@ void debug(const char *format, ...) {
 
 ssize_t do_recv(struct utcp_connection *c, const void *data, size_t len) {
 	(void)c;
+
 	if(!data || !len) {
 		if(errno) {
 			debug("Error: %s\n", strerror(errno));
@@ -60,19 +61,24 @@ ssize_t do_recv(struct utcp_connection *c, const void *data, size_t len) {
 			dir &= ~DIR_WRITE;
 			debug("Connection closed by peer\n");
 		}
+
 		return -1;
 	}
+
 	if(reference) {
 		char buf[len];
+
 		if(fread(buf, len, 1, reference) != 1) {
 			debug("Error reading reference\n");
 			abort();
 		}
+
 		if(memcmp(buf, data, len)) {
 			debug("Received data differs from reference\n");
 			abort();
 		}
 	}
+
 	return write(1, data, len);
 }
 
@@ -86,17 +92,21 @@ void do_accept(struct utcp_connection *nc, uint16_t port) {
 ssize_t do_send(struct utcp *utcp, const void *data, size_t len) {
 	int s = *(int *)utcp->priv;
 	outpktno++;
+
 	if(outpktno >= dropfrom && outpktno < dropto) {
 		if(drand48() < dropout) {
 			debug("Dropped outgoing packet\n");
 			return len;
 		}
+
 		if(!reorder_data && drand48() < reorder) {
 			reorder_data = malloc(len);
+
 			if(!reorder_data) {
 				debug("Out of memory\n");
 				return len;
 			}
+
 			reorder_len = len;
 			memcpy(reorder_data, data, len);
 			reorder_countdown = 1 + drand48() * reorder_dist;
@@ -115,8 +125,11 @@ ssize_t do_send(struct utcp *utcp, const void *data, size_t len) {
 
 	total_out += len;
 	ssize_t result = send(s, data, len, MSG_DONTWAIT);
-	if(result <= 0)
+
+	if(result <= 0) {
 		debug("Error sending UDP packet: %s\n", strerror(errno));
+	}
+
 	return result;
 }
 
@@ -124,64 +137,102 @@ int main(int argc, char *argv[]) {
 	srand(time(NULL));
 	srand48(time(NULL));
 
-	if(argc < 2 || argc > 3)
+	if(argc < 2 || argc > 3) {
 		return 1;
+	}
 
 	bool server = argc == 2;
 	bool connected = false;
 	uint32_t flags = UTCP_TCP;
 	size_t read_size = 102400;
 
-	if(getenv("DROPIN")) dropin = atof(getenv("DROPIN"));
-	if(getenv("DROPOUT")) dropout = atof(getenv("DROPOUT"));
-	if(getenv("DROPFROM")) dropfrom = atoi(getenv("DROPFROM"));
-	if(getenv("DROPTO")) dropto = atoi(getenv("DROPTO"));
-	if(getenv("REORDER")) reorder = atof(getenv("REORDER"));
-	if(getenv("REORDER_DIST")) reorder_dist = atoi(getenv("REORDER_DIST"));
-	if(getenv("FLAGS")) flags = atoi(getenv("FLAGS"));
-	if(getenv("READ_SIZE")) read_size = atoi(getenv("READ_SIZE"));
+	if(getenv("DROPIN")) {
+		dropin = atof(getenv("DROPIN"));
+	}
+
+	if(getenv("DROPOUT")) {
+		dropout = atof(getenv("DROPOUT"));
+	}
+
+	if(getenv("DROPFROM")) {
+		dropfrom = atoi(getenv("DROPFROM"));
+	}
+
+	if(getenv("DROPTO")) {
+		dropto = atoi(getenv("DROPTO"));
+	}
+
+	if(getenv("REORDER")) {
+		reorder = atof(getenv("REORDER"));
+	}
+
+	if(getenv("REORDER_DIST")) {
+		reorder_dist = atoi(getenv("REORDER_DIST"));
+	}
+
+	if(getenv("FLAGS")) {
+		flags = atoi(getenv("FLAGS"));
+	}
+
+	if(getenv("READ_SIZE")) {
+		read_size = atoi(getenv("READ_SIZE"));
+	}
 
 	char *reference_filename = getenv("REFERENCE");
-	if(reference_filename)
+
+	if(reference_filename) {
 		reference = fopen(reference_filename, "r");
+	}
 
-	if(dropto < dropfrom)
+	if(dropto < dropfrom) {
 		dropto = 1 << 30;
+	}
 
 	struct addrinfo *ai;
+
 	struct addrinfo hint = {
 		.ai_flags = server ? AI_PASSIVE : 0,
 		.ai_socktype = SOCK_DGRAM,
 	};
 
 	getaddrinfo(server ? NULL : argv[1], server ? argv[1] : argv[2], &hint, &ai);
-	if(!ai)
+
+	if(!ai) {
 		return 1;
+	}
 
 	int s = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
-	if(s == -1)
+
+	if(s == -1) {
 		return 1;
+	}
 
 	if(server) {
-		if(bind(s, ai->ai_addr, ai->ai_addrlen))
+		if(bind(s, ai->ai_addr, ai->ai_addrlen)) {
 			return 1;
+		}
 	} else {
-		if(connect(s, ai->ai_addr, ai->ai_addrlen))
+		if(connect(s, ai->ai_addr, ai->ai_addrlen)) {
 			return 1;
+		}
+
 		connected = true;
 	}
 
 	freeaddrinfo(ai);
 
 	struct utcp *u = utcp_init(server ? do_accept : NULL, NULL, do_send, &s);
-	if(!u)
+
+	if(!u) {
 		return 1;
+	}
 
 	utcp_set_mtu(u, 1300);
 	utcp_set_user_timeout(u, 10);
 
-	if(!server)
+	if(!server) {
 		c = utcp_connect_ex(u, 1, do_recv, NULL, flags);
+	}
 
 	struct pollfd fds[2] = {
 		{.fd = 0, .events = POLLIN | POLLERR | POLLHUP},
@@ -189,41 +240,56 @@ int main(int argc, char *argv[]) {
 	};
 
 	char buf[102400];
+
 	struct timeval timeout = utcp_timeout(u);
 
 	while(!connected || utcp_is_active(u)) {
 		size_t max = c ? utcp_get_sndbuf_free(c) : 0;
-		if(max > sizeof(buf))
+
+		if(max > sizeof(buf)) {
 			max = sizeof(buf);
-		if(max > read_size)
+		}
+
+		if(max > read_size) {
 			max = read_size;
+		}
 
 		int timeout_ms = timeout.tv_sec * 1000 + timeout.tv_usec / 1000 + 1;
 
 		debug("polling, dir = %d, timeout = %d\n", dir, timeout_ms);
-		if((dir & DIR_READ) && max)
+
+		if((dir & DIR_READ) && max) {
 			poll(fds, 2, timeout_ms);
-		else
+		} else {
 			poll(fds + 1, 1, timeout_ms);
+		}
 
 		if(fds[0].revents) {
 			fds[0].revents = 0;
 			debug("stdin\n");
 			ssize_t len = read(0, buf, max);
+
 			if(len <= 0) {
 				fds[0].fd = -1;
 				dir &= ~DIR_READ;
-				if(c)
+
+				if(c) {
 					utcp_shutdown(c, SHUT_WR);
-				if(len == -1)
+				}
+
+				if(len == -1) {
 					break;
-				else
+				} else {
 					continue;
+				}
 			}
+
 			if(c) {
 				ssize_t sent = utcp_send(c, buf, len);
-				if(sent != len)
+
+				if(sent != len) {
 					debug("Short send: %zd != %zd\n", sent, len);
+				}
 			}
 		}
 
@@ -233,18 +299,25 @@ int main(int argc, char *argv[]) {
 			struct sockaddr_storage ss;
 			socklen_t sl = sizeof(ss);
 			int len = recvfrom(s, buf, sizeof(buf), MSG_DONTWAIT, (struct sockaddr *)&ss, &sl);
+
 			if(len <= 0) {
 				debug("Error receiving UDP packet: %s\n", strerror(errno));
 				break;
 			}
+
 			if(!connected)
-				if(!connect(s, (struct sockaddr *)&ss, sl))
+				if(!connect(s, (struct sockaddr *)&ss, sl)) {
 					connected = true;
+				}
+
 			inpktno++;
+
 			if(inpktno >= dropto || inpktno < dropfrom || drand48() >= dropin) {
 				total_in += len;
-				if(utcp_recv(u, buf, len) == -1)
+
+				if(utcp_recv(u, buf, len) == -1) {
 					debug("Error receiving UTCP packet: %s\n", strerror(errno));
+				}
 			} else {
 				debug("Dropped incoming packet\n");
 			}
@@ -254,7 +327,9 @@ int main(int argc, char *argv[]) {
 	};
 
 	utcp_close(c);
+
 	utcp_exit(u);
+
 	free(reorder_data);
 
 	debug("Total bytes in: %ld, out: %ld\n", total_in, total_out);
diff --git a/utcp.c b/utcp.c
index f20d86e..b939dc8 100644
--- a/utcp.c
+++ b/utcp.c
@@ -45,12 +45,13 @@
 #endif
 
 #ifndef timersub
-#define timersub(a, b, r) do {\
-	(r)->tv_sec = (a)->tv_sec - (b)->tv_sec;\
-	(r)->tv_usec = (a)->tv_usec - (b)->tv_usec;\
-	if((r)->tv_usec < 0)\
-		(r)->tv_sec--, (r)->tv_usec += USEC_PER_SEC;\
-} while (0)
+#define timersub(a, b, r)\
+	do {\
+		(r)->tv_sec = (a)->tv_sec - (b)->tv_sec;\
+		(r)->tv_usec = (a)->tv_usec - (b)->tv_usec;\
+		if((r)->tv_usec < 0)\
+			(r)->tv_sec--, (r)->tv_usec += USEC_PER_SEC;\
+	} while (0)
 #endif
 
 static inline size_t max(size_t a, size_t b) {
@@ -69,6 +70,7 @@ static void debug(const char *format, ...) {
 
 static void print_packet(struct utcp *utcp, const char *dir, const void *pkt, size_t len) {
 	struct hdr hdr;
+
 	if(len < sizeof(hdr)) {
 		debug("%p %s: short packet (%lu bytes)\n", utcp, dir, (unsigned long)len);
 		return;
@@ -76,14 +78,22 @@ static void print_packet(struct utcp *utcp, const char *dir, const void *pkt, si
 
 	memcpy(&hdr, pkt, sizeof(hdr));
 	debug("%p %s: len=%lu, src=%u dst=%u seq=%u ack=%u wnd=%u aux=%x ctl=", utcp, dir, (unsigned long)len, hdr.src, hdr.dst, hdr.seq, hdr.ack, hdr.wnd, hdr.aux);
-	if(hdr.ctl & SYN)
+
+	if(hdr.ctl & SYN) {
 		debug("SYN");
-	if(hdr.ctl & RST)
+	}
+
+	if(hdr.ctl & RST) {
 		debug("RST");
-	if(hdr.ctl & FIN)
+	}
+
+	if(hdr.ctl & FIN) {
 		debug("FIN");
-	if(hdr.ctl & ACK)
+	}
+
+	if(hdr.ctl & ACK) {
 		debug("ACK");
+	}
 
 	if(len > sizeof(hdr)) {
 		uint32_t datalen = len - sizeof(hdr);
@@ -95,6 +105,7 @@ static void print_packet(struct utcp *utcp, const char *dir, const void *pkt, si
 			*p++ = "0123456789ABCDEF"[data[i] >> 4];
 			*p++ = "0123456789ABCDEF"[data[i] & 15];
 		}
+
 		*p = 0;
 
 		debug(" data=%s", str);
@@ -109,19 +120,25 @@ static void print_packet(struct utcp *utcp, const char *dir, const void *pkt, si
 
 static void set_state(struct utcp_connection *c, enum state state) {
 	c->state = state;
-	if(state == ESTABLISHED)
+
+	if(state == ESTABLISHED) {
 		timerclear(&c->conn_timeout);
+	}
+
 	debug("%p new state: %s\n", c->utcp, strstate[state]);
 }
 
 static bool fin_wanted(struct utcp_connection *c, uint32_t seq) {
-	if(seq != c->snd.last)
+	if(seq != c->snd.last) {
 		return false;
+	}
+
 	switch(c->state) {
 	case FIN_WAIT_1:
 	case CLOSING:
 	case LAST_ACK:
 		return true;
+
 	default:
 		return false;
 	}
@@ -143,15 +160,19 @@ static ssize_t buffer_put_at(struct buffer *buf, size_t offset, const void *data
 	debug("buffer_put_at %lu %lu %lu\n", (unsigned long)buf->used, (unsigned long)offset, (unsigned long)len);
 
 	size_t required = offset + len;
+
 	if(required > buf->maxsize) {
-		if(offset >= buf->maxsize)
+		if(offset >= buf->maxsize) {
 			return 0;
+		}
+
 		len = buf->maxsize - offset;
 		required = buf->maxsize;
 	}
 
 	if(required > buf->size) {
 		size_t newsize = buf->size;
+
 		if(!newsize) {
 			newsize = required;
 		} else {
@@ -159,18 +180,27 @@ static ssize_t buffer_put_at(struct buffer *buf, size_t offset, const void *data
 				newsize *= 2;
 			} while(newsize < required);
 		}
-		if(newsize > buf->maxsize)
+
+		if(newsize > buf->maxsize) {
 			newsize = buf->maxsize;
+		}
+
 		char *newdata = realloc(buf->data, newsize);
-		if(!newdata)
+
+		if(!newdata) {
 			return -1;
+		}
+
 		buf->data = newdata;
 		buf->size = newsize;
 	}
 
 	memcpy(buf->data + offset, data, len);
-	if(required > buf->used)
+
+	if(required > buf->used) {
 		buf->used = required;
+	}
+
 	return len;
 }
 
@@ -180,33 +210,47 @@ static ssize_t buffer_put(struct buffer *buf, const void *data, size_t len) {
 
 // Get data from the buffer. data can be NULL.
 static ssize_t buffer_get(struct buffer *buf, void *data, size_t len) {
-	if(len > buf->used)
+	if(len > buf->used) {
 		len = buf->used;
-	if(data)
+	}
+
+	if(data) {
 		memcpy(data, buf->data, len);
-	if(len < buf->used)
+	}
+
+	if(len < buf->used) {
 		memmove(buf->data, buf->data + len, buf->used - len);
+	}
+
 	buf->used -= len;
 	return len;
 }
 
 // Copy data from the buffer without removing it.
 static ssize_t buffer_copy(struct buffer *buf, void *data, size_t offset, size_t len) {
-	if(offset >= buf->used)
+	if(offset >= buf->used) {
 		return 0;
-	if(offset + len > buf->used)
+	}
+
+	if(offset + len > buf->used) {
 		len = buf->used - offset;
+	}
+
 	memcpy(data, buf->data + offset, len);
 	return len;
 }
 
 static bool buffer_init(struct buffer *buf, uint32_t len, uint32_t maxlen) {
 	memset(buf, 0, sizeof(*buf));
+
 	if(len) {
 		buf->data = malloc(len);
-		if(!buf->data)
+
+		if(!buf->data) {
 			return false;
+		}
 	}
+
 	buf->size = len;
 	buf->maxsize = maxlen;
 	return true;
@@ -234,15 +278,20 @@ static int compare(const void *va, const void *vb) {
 	assert(a->src && b->src);
 
 	int c = (int)a->src - (int)b->src;
-	if(c)
+
+	if(c) {
 		return c;
+	}
+
 	c = (int)a->dst - (int)b->dst;
 	return c;
 }
 
 static struct utcp_connection *find_connection(const struct utcp *utcp, uint16_t src, uint16_t dst) {
-	if(!utcp->nconnections)
+	if(!utcp->nconnections) {
 		return NULL;
+	}
+
 	struct utcp_connection key = {
 		.src = src,
 		.dst = dst,
@@ -279,27 +328,37 @@ static struct utcp_connection *allocate_connection(struct utcp *utcp, uint16_t s
 			errno = ENOMEM;
 			return NULL;
 		}
+
 		src = rand() | 0x8000;
-		while(find_connection(utcp, src, dst))
+
+		while(find_connection(utcp, src, dst)) {
 			src++;
+		}
 	}
 
 	// Allocate memory for the new connection
 
 	if(utcp->nconnections >= utcp->nallocated) {
-		if(!utcp->nallocated)
+		if(!utcp->nallocated) {
 			utcp->nallocated = 4;
-		else
+		} else {
 			utcp->nallocated *= 2;
+		}
+
 		struct utcp_connection **new_array = realloc(utcp->connections, utcp->nallocated * sizeof(*utcp->connections));
-		if(!new_array)
+
+		if(!new_array) {
 			return NULL;
+		}
+
 		utcp->connections = new_array;
 	}
 
 	struct utcp_connection *c = calloc(1, sizeof(*c));
-	if(!c)
+
+	if(!c) {
 		return NULL;
+	}
 
 	if(!buffer_init(&c->sndbuf, DEFAULT_SNDBUFSIZE, DEFAULT_MAXSNDBUFSIZE)) {
 		free(c);
@@ -337,10 +396,11 @@ static struct utcp_connection *allocate_connection(struct utcp *utcp, uint16_t s
 }
 
 static inline uint32_t absdiff(uint32_t a, uint32_t b) {
-	if(a > b)
+	if(a > b) {
 		return a - b;
-	else
+	} else {
 		return b - a;
+	}
 }
 
 // Update RTT variables. See RFC 6298.
@@ -362,8 +422,9 @@ static void update_rtt(struct utcp_connection *c, uint32_t rtt) {
 		utcp->rto = utcp->srtt + max(utcp->rttvar, CLOCK_GRANULARITY);
 	}
 
-	if(utcp->rto > MAX_RTO)
+	if(utcp->rto > MAX_RTO) {
 		utcp->rto = MAX_RTO;
+	}
 
 	debug("rtt %u srtt %u rttvar %u rto %u\n", rtt, utcp->srtt, utcp->rttvar, utcp->rto);
 }
@@ -371,10 +432,12 @@ static void update_rtt(struct utcp_connection *c, uint32_t rtt) {
 static void start_retransmit_timer(struct utcp_connection *c) {
 	gettimeofday(&c->rtrx_timeout, NULL);
 	c->rtrx_timeout.tv_usec += c->utcp->rto;
+
 	while(c->rtrx_timeout.tv_usec >= 1000000) {
 		c->rtrx_timeout.tv_usec -= 1000000;
 		c->rtrx_timeout.tv_sec++;
 	}
+
 	debug("timeout set to %lu.%06lu (%u)\n", c->rtrx_timeout.tv_sec, c->rtrx_timeout.tv_usec, c->utcp->rto);
 }
 
@@ -385,8 +448,10 @@ static void stop_retransmit_timer(struct utcp_connection *c) {
 
 struct utcp_connection *utcp_connect_ex(struct utcp *utcp, uint16_t dst, utcp_recv_t recv, void *priv, uint32_t flags) {
 	struct utcp_connection *c = allocate_connection(utcp, 0, dst);
-	if(!c)
+
+	if(!c) {
 		return NULL;
+	}
 
 	assert((flags & ~0xf) == 0);
 
@@ -447,14 +512,17 @@ static void ack(struct utcp_connection *c, bool sendatleastone) {
 
 	assert(left >= 0);
 
-	if(cwndleft <= 0)
+	if(cwndleft <= 0) {
 		cwndleft = 0;
+	}
 
-	if(cwndleft < left)
+	if(cwndleft < left) {
 		left = cwndleft;
+	}
 
-	if(!left && !sendatleastone)
+	if(!left && !sendatleastone) {
 		return;
+	}
 
 	struct {
 		struct hdr hdr;
@@ -462,8 +530,10 @@ static void ack(struct utcp_connection *c, bool sendatleastone) {
 	} *pkt;
 
 	pkt = malloc(sizeof(pkt->hdr) + c->utcp->mtu);
-	if(!pkt)
+
+	if(!pkt) {
 		return;
+	}
 
 	pkt->hdr.src = c->src;
 	pkt->hdr.dst = c->dst;
@@ -515,9 +585,11 @@ ssize_t utcp_send(struct utcp_connection *c, const void *data, size_t len) {
 		debug("Error: send() called on unconnected connection %p\n", c);
 		errno = ENOTCONN;
 		return -1;
+
 	case ESTABLISHED:
 	case CLOSE_WAIT:
 		break;
+
 	case FIN_WAIT_1:
 	case FIN_WAIT_2:
 	case CLOSING:
@@ -530,8 +602,9 @@ ssize_t utcp_send(struct utcp_connection *c, const void *data, size_t len) {
 
 	// Exit early if we have nothing to send.
 
-	if(!len)
+	if(!len) {
 		return 0;
+	}
 
 	if(!data) {
 		errno = EFAULT;
@@ -541,6 +614,7 @@ ssize_t utcp_send(struct utcp_connection *c, const void *data, size_t len) {
 	// Add data to send buffer.
 
 	len = buffer_put(&c->sndbuf, data, len);
+
 	if(len <= 0) {
 		errno = EWOULDBLOCK;
 		return 0;
@@ -548,12 +622,16 @@ ssize_t utcp_send(struct utcp_connection *c, const void *data, size_t len) {
 
 	c->snd.last += len;
 	ack(c, false);
+
 	if(!is_reliable(c)) {
 		c->snd.una = c->snd.nxt = c->snd.last;
 		buffer_get(&c->sndbuf, NULL, c->sndbuf.used);
 	}
-	if(is_reliable(c) && !timerisset(&c->rtrx_timeout))
+
+	if(is_reliable(c) && !timerisset(&c->rtrx_timeout)) {
 		start_retransmit_timer(c);
+	}
+
 	return len;
 }
 
@@ -578,8 +656,10 @@ static void retransmit(struct utcp_connection *c) {
 	} *pkt;
 
 	pkt = malloc(sizeof(pkt->hdr) + c->utcp->mtu);
-	if(!pkt)
+
+	if(!pkt) {
 		return;
+	}
 
 	pkt->hdr.src = c->src;
 	pkt->hdr.dst = c->dst;
@@ -587,68 +667,75 @@ static void retransmit(struct utcp_connection *c) {
 	pkt->hdr.aux = 0;
 
 	switch(c->state) {
-		case SYN_SENT:
-			// Send our SYN again
-			pkt->hdr.seq = c->snd.iss;
-			pkt->hdr.ack = 0;
-			pkt->hdr.ctl = SYN;
-			pkt->hdr.aux = 0x0101;
-			pkt->data[0] = 1;
-			pkt->data[1] = 0;
-			pkt->data[2] = 0;
-			pkt->data[3] = c->flags & 0x7;
-			print_packet(c->utcp, "rtrx", pkt, sizeof(pkt->hdr) + 4);
-			utcp->send(utcp, pkt, sizeof(pkt->hdr) + 4);
-			break;
+	case SYN_SENT:
+		// Send our SYN again
+		pkt->hdr.seq = c->snd.iss;
+		pkt->hdr.ack = 0;
+		pkt->hdr.ctl = SYN;
+		pkt->hdr.aux = 0x0101;
+		pkt->data[0] = 1;
+		pkt->data[1] = 0;
+		pkt->data[2] = 0;
+		pkt->data[3] = c->flags & 0x7;
+		print_packet(c->utcp, "rtrx", pkt, sizeof(pkt->hdr) + 4);
+		utcp->send(utcp, pkt, sizeof(pkt->hdr) + 4);
+		break;
 
-		case SYN_RECEIVED:
-			// Send SYNACK again
-			pkt->hdr.seq = c->snd.nxt;
-			pkt->hdr.ack = c->rcv.nxt;
-			pkt->hdr.ctl = SYN | ACK;
-			print_packet(c->utcp, "rtrx", pkt, sizeof(pkt->hdr));
-			utcp->send(utcp, pkt, sizeof(pkt->hdr));
-			break;
+	case SYN_RECEIVED:
+		// Send SYNACK again
+		pkt->hdr.seq = c->snd.nxt;
+		pkt->hdr.ack = c->rcv.nxt;
+		pkt->hdr.ctl = SYN | ACK;
+		print_packet(c->utcp, "rtrx", pkt, sizeof(pkt->hdr));
+		utcp->send(utcp, pkt, sizeof(pkt->hdr));
+		break;
 
-		case ESTABLISHED:
-		case FIN_WAIT_1:
-		case CLOSE_WAIT:
-		case CLOSING:
-		case LAST_ACK:
-			// Send unacked data again.
-			pkt->hdr.seq = c->snd.una;
-			pkt->hdr.ack = c->rcv.nxt;
-			pkt->hdr.ctl = ACK;
-			uint32_t len = seqdiff(c->snd.last, c->snd.una);
-			if(len > utcp->mtu)
-				len = utcp->mtu;
-			if(fin_wanted(c, c->snd.una + len)) {
-				len--;
-				pkt->hdr.ctl |= FIN;
-			}
-			c->snd.nxt = c->snd.una + len;
-			c->snd.cwnd = utcp->mtu; // reduce cwnd on retransmit
-			buffer_copy(&c->sndbuf, pkt->data, 0, len);
-			print_packet(c->utcp, "rtrx", pkt, sizeof(pkt->hdr) + len);
-			utcp->send(utcp, pkt, sizeof(pkt->hdr) + len);
-			break;
+	case ESTABLISHED:
+	case FIN_WAIT_1:
+	case CLOSE_WAIT:
+	case CLOSING:
+	case LAST_ACK:
+		// Send unacked data again.
+		pkt->hdr.seq = c->snd.una;
+		pkt->hdr.ack = c->rcv.nxt;
+		pkt->hdr.ctl = ACK;
+		uint32_t len = seqdiff(c->snd.last, c->snd.una);
+
+		if(len > utcp->mtu) {
+			len = utcp->mtu;
+		}
 
-		case CLOSED:
-		case LISTEN:
-		case TIME_WAIT:
-		case FIN_WAIT_2:
-			// We shouldn't need to retransmit anything in this state.
+		if(fin_wanted(c, c->snd.una + len)) {
+			len--;
+			pkt->hdr.ctl |= FIN;
+		}
+
+		c->snd.nxt = c->snd.una + len;
+		c->snd.cwnd = utcp->mtu; // reduce cwnd on retransmit
+		buffer_copy(&c->sndbuf, pkt->data, 0, len);
+		print_packet(c->utcp, "rtrx", pkt, sizeof(pkt->hdr) + len);
+		utcp->send(utcp, pkt, sizeof(pkt->hdr) + len);
+		break;
+
+	case CLOSED:
+	case LISTEN:
+	case TIME_WAIT:
+	case FIN_WAIT_2:
+		// We shouldn't need to retransmit anything in this state.
 #ifdef UTCP_DEBUG
-			abort();
+		abort();
 #endif
-			stop_retransmit_timer(c);
-			goto cleanup;
+		stop_retransmit_timer(c);
+		goto cleanup;
 	}
 
 	start_retransmit_timer(c);
 	utcp->rto *= 2;
-	if(utcp->rto > MAX_RTO)
+
+	if(utcp->rto > MAX_RTO) {
 		utcp->rto = MAX_RTO;
+	}
+
 	c->rtt_start.tv_sec = 0; // invalidate RTT timer
 
 cleanup:
@@ -675,6 +762,7 @@ cleanup:
  */
 static void sack_consume(struct utcp_connection *c, size_t len) {
 	debug("sack_consume %lu\n", (unsigned long)len);
+
 	if(len > c->rcvbuf.used) {
 		debug("All SACK entries consumed");
 		c->sacks[0].len = 0;
@@ -683,7 +771,7 @@ static void sack_consume(struct utcp_connection *c, size_t len) {
 
 	buffer_get(&c->rcvbuf, NULL, len);
 
-	for(int i = 0; i < NSACKS && c->sacks[i].len; ) {
+	for(int i = 0; i < NSACKS && c->sacks[i].len;) {
 		if(len < c->sacks[i].offset) {
 			c->sacks[i].offset -= len;
 			i++;
@@ -702,16 +790,19 @@ static void sack_consume(struct utcp_connection *c, size_t len) {
 		}
 	}
 
-	for(int i = 0; i < NSACKS && c->sacks[i].len; i++)
+	for(int i = 0; i < NSACKS && c->sacks[i].len; i++) {
 		debug("SACK[%d] offset %u len %u\n", i, c->sacks[i].offset, c->sacks[i].len);
+	}
 }
 
 static void handle_out_of_order(struct utcp_connection *c, uint32_t offset, const void *data, size_t len) {
 	debug("out of order packet, offset %u\n", offset);
 	// Packet loss or reordering occured. Store the data in the buffer.
 	ssize_t rxd = buffer_put_at(&c->rcvbuf, offset, data, len);
-	if(rxd < 0 || (size_t)rxd < len)
+
+	if(rxd < 0 || (size_t)rxd < len) {
 		abort();
+	}
 
 	// Make note of where we put it.
 	for(int i = 0; i < NSACKS; i++) {
@@ -730,6 +821,7 @@ static void handle_out_of_order(struct utcp_connection *c, uint32_t offset, cons
 				} else {
 					debug("SACK entries full, dropping packet\n");
 				}
+
 				break;
 			} else { // merge
 				debug("Merge with start of SACK entry at %d\n", i);
@@ -742,12 +834,14 @@ static void handle_out_of_order(struct utcp_connection *c, uint32_t offset, cons
 				c->sacks[i].len = offset + rxd - c->sacks[i].offset;
 				// TODO: handle potential merge with next entry
 			}
+
 			break;
 		}
 	}
 
-	for(int i = 0; i < NSACKS && c->sacks[i].len; i++)
+	for(int i = 0; i < NSACKS && c->sacks[i].len; i++) {
 		debug("SACK[%d] offset %u len %u\n", i, c->sacks[i].offset, c->sacks[i].len);
+	}
 }
 
 static void handle_in_order(struct utcp_connection *c, const void *data, size_t len) {
@@ -761,14 +855,16 @@ static void handle_in_order(struct utcp_connection *c, const void *data, size_t
 
 	if(c->recv) {
 		ssize_t rxd = c->recv(c, data, len);
+
 		if(rxd < 0 || (size_t)rxd != len) {
 			// TODO: handle the application not accepting all data.
 			abort();
 		}
 	}
 
-	if(c->rcvbuf.used)
+	if(c->rcvbuf.used) {
 		sack_consume(c, len);
+	}
 
 	c->rcv.nxt += len;
 }
@@ -782,13 +878,16 @@ static void handle_incoming_data(struct utcp_connection *c, uint32_t seq, const
 	}
 
 	uint32_t offset = seqdiff(seq, c->rcv.nxt);
-	if(offset + len > c->rcvbuf.maxsize)
+
+	if(offset + len > c->rcvbuf.maxsize) {
 		abort();
+	}
 
-	if(offset)
+	if(offset) {
 		handle_out_of_order(c, offset, data, len);
-	else
+	} else {
 		handle_in_order(c, data, len);
+	}
 }
 
 
@@ -798,8 +897,9 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 		return -1;
 	}
 
-	if(!len)
+	if(!len) {
 		return 0;
+	}
 
 	if(!data) {
 		errno = EFAULT;
@@ -811,6 +911,7 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 	// Drop packets smaller than the header
 
 	struct hdr hdr;
+
 	if(len < sizeof(hdr)) {
 		errno = EBADMSG;
 		return -1;
@@ -834,6 +935,7 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 	const uint8_t *init = NULL;
 
 	uint16_t aux = hdr.aux;
+
 	while(aux) {
 		size_t auxlen = 4 * (aux >> 8) & 0xf;
 		uint8_t auxtype = aux & 0xff;
@@ -849,8 +951,10 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 				errno = EBADMSG;
 				return -1;
 			}
+
 			init = data;
 			break;
+
 		default:
 			errno = EBADMSG;
 			return -1;
@@ -859,8 +963,9 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 		len -= auxlen;
 		data += auxlen;
 
-		if(!(aux & 0x800))
+		if(!(aux & 0x800)) {
 			break;
+		}
 
 		if(len < 2) {
 			errno = EBADMSG;
@@ -881,8 +986,9 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 	if(!c) {
 		// Ignore RST packets
 
-		if(hdr.ctl & RST)
+		if(hdr.ctl & RST) {
 			return 0;
+		}
 
 		// Is it a SYN packet and are we LISTENing?
 
@@ -895,6 +1001,7 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 
 			// Try to allocate memory, otherwise send a RST back
 			c = allocate_connection(utcp, hdr.dst, hdr.src);
+
 			if(!c) {
 				len = 1;
 				goto reset;
@@ -906,6 +1013,7 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 					len = 1;
 					goto reset;
 				}
+
 				c->flags = init[3] & 0x7;
 			} else {
 				c->flags = UTCP_TCP;
@@ -928,6 +1036,7 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 			pkt.hdr.seq = c->snd.iss;
 			pkt.hdr.wnd = c->rcv.wnd;
 			pkt.hdr.ctl = SYN | ACK;
+
 			if(init) {
 				pkt.hdr.aux = 0x0101;
 				pkt.data[0] = 1;
@@ -979,6 +1088,7 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 	case LAST_ACK:
 	case TIME_WAIT:
 		break;
+
 	default:
 #ifdef UTCP_DEBUG
 		abort();
@@ -990,16 +1100,17 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 
 	bool acceptable;
 
-	if(c->state == SYN_SENT)
+	if(c->state == SYN_SENT) {
 		acceptable = true;
-	else if(len == 0)
+	} else if(len == 0) {
 		acceptable = seqdiff(hdr.seq, c->rcv.nxt) >= 0;
-	else {
+	} else {
 		int32_t rcv_offset = seqdiff(hdr.seq, c->rcv.nxt);
 
 		// cut already accepted front overlapping
 		if(rcv_offset < 0) {
-			acceptable = len > (size_t)-rcv_offset;
+			acceptable = len > (size_t) - rcv_offset;
+
 			if(acceptable) {
 				data -= rcv_offset;
 				len += rcv_offset;
@@ -1012,9 +1123,12 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 
 	if(!acceptable) {
 		debug("Packet not acceptable, %u <= %u + %lu < %u\n", c->rcv.nxt, hdr.seq, (unsigned long)len, c->rcv.nxt + c->rcvbuf.maxsize);
+
 		// Ignore unacceptable RST packets.
-		if(hdr.ctl & RST)
+		if(hdr.ctl & RST) {
 			return 0;
+		}
+
 		// Otherwise, continue processing.
 		len = 0;
 	}
@@ -1027,9 +1141,12 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 
 	if(hdr.ctl & ACK && (seqdiff(hdr.ack, c->snd.last) > 0 || seqdiff(hdr.ack, c->snd.una) < 0)) {
 		debug("Packet ack seqno out of range, %u <= %u < %u\n", c->snd.una, hdr.ack, c->snd.una + c->sndbuf.used);
+
 		// Ignore unacceptable RST packets.
-		if(hdr.ctl & RST)
+		if(hdr.ctl & RST) {
 			return 0;
+		}
+
 		goto reset;
 	}
 
@@ -1038,46 +1155,65 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 	if(hdr.ctl & RST) {
 		switch(c->state) {
 		case SYN_SENT:
-			if(!(hdr.ctl & ACK))
+			if(!(hdr.ctl & ACK)) {
 				return 0;
+			}
+
 			// The peer has refused our connection.
 			set_state(c, CLOSED);
 			errno = ECONNREFUSED;
-			if(c->recv)
+
+			if(c->recv) {
 				c->recv(c, NULL, 0);
+			}
+
 			return 0;
+
 		case SYN_RECEIVED:
-			if(hdr.ctl & ACK)
+			if(hdr.ctl & ACK) {
 				return 0;
+			}
+
 			// We haven't told the application about this connection yet. Silently delete.
 			free_connection(c);
 			return 0;
+
 		case ESTABLISHED:
 		case FIN_WAIT_1:
 		case FIN_WAIT_2:
 		case CLOSE_WAIT:
-			if(hdr.ctl & ACK)
+			if(hdr.ctl & ACK) {
 				return 0;
+			}
+
 			// The peer has aborted our connection.
 			set_state(c, CLOSED);
 			errno = ECONNRESET;
-			if(c->recv)
+
+			if(c->recv) {
 				c->recv(c, NULL, 0);
+			}
+
 			return 0;
+
 		case CLOSING:
 		case LAST_ACK:
 		case TIME_WAIT:
-			if(hdr.ctl & ACK)
+			if(hdr.ctl & ACK) {
 				return 0;
+			}
+
 			// As far as the application is concerned, the connection has already been closed.
 			// If it has called utcp_close() already, we can immediately free this connection.
 			if(c->reapable) {
 				free_connection(c);
 				return 0;
 			}
+
 			// Otherwise, immediately move to the CLOSED state.
 			set_state(c, CLOSED);
 			return 0;
+
 		default:
 #ifdef UTCP_DEBUG
 			abort();
@@ -1086,8 +1222,9 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 		}
 	}
 
-	if(!(hdr.ctl & ACK))
+	if(!(hdr.ctl & ACK)) {
 		goto skip_ack;
+	}
 
 	// 3. Advance snd.una
 
@@ -1112,13 +1249,14 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 		int32_t data_acked = advanced;
 
 		switch(c->state) {
-			case SYN_SENT:
-			case SYN_RECEIVED:
-				data_acked--;
-				break;
-			// TODO: handle FIN as well.
-			default:
-				break;
+		case SYN_SENT:
+		case SYN_RECEIVED:
+			data_acked--;
+			break;
+
+		// TODO: handle FIN as well.
+		default:
+			break;
 		}
 
 		assert(data_acked >= 0);
@@ -1126,39 +1264,49 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 		int32_t bufused = seqdiff(c->snd.last, c->snd.una);
 		assert(data_acked <= bufused);
 
-		if(data_acked)
+		if(data_acked) {
 			buffer_get(&c->sndbuf, NULL, data_acked);
+		}
 
 		// Also advance snd.nxt if possible
-		if(seqdiff(c->snd.nxt, hdr.ack) < 0)
+		if(seqdiff(c->snd.nxt, hdr.ack) < 0) {
 			c->snd.nxt = hdr.ack;
+		}
 
 		c->snd.una = hdr.ack;
 
 		c->dupack = 0;
 		c->snd.cwnd += utcp->mtu;
-		if(c->snd.cwnd > c->sndbuf.maxsize)
+
+		if(c->snd.cwnd > c->sndbuf.maxsize) {
 			c->snd.cwnd = c->sndbuf.maxsize;
+		}
 
 		// Check if we have sent a FIN that is now ACKed.
 		switch(c->state) {
 		case FIN_WAIT_1:
-			if(c->snd.una == c->snd.last)
+			if(c->snd.una == c->snd.last) {
 				set_state(c, FIN_WAIT_2);
+			}
+
 			break;
+
 		case CLOSING:
 			if(c->snd.una == c->snd.last) {
 				gettimeofday(&c->conn_timeout, NULL);
 				c->conn_timeout.tv_sec += 60;
 				set_state(c, TIME_WAIT);
 			}
+
 			break;
+
 		default:
 			break;
 		}
 	} else {
 		if(!len && is_reliable(c)) {
 			c->dupack++;
+
 			if(c->dupack == 3) {
 				debug("Triplicate ACK\n");
 				//TODO: Resend one packet and go to fast recovery mode. See RFC 6582.
@@ -1175,10 +1323,12 @@ ssize_t utcp_recv(struct utcp *utcp, const void *data, size_t len) {
 
 	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)
+
+		if(c->snd.una == c->snd.last) {
 			stop_retransmit_timer(c);
-		else if(is_reliable(c))
+		} else if(is_reliable(c)) {
 			start_retransmit_timer(c);
+		}
 	}
 
 skip_ack:
@@ -1187,14 +1337,18 @@ skip_ack:
 	if(hdr.ctl & SYN) {
 		switch(c->state) {
 		case SYN_SENT:
+
 			// This is a SYNACK. It should always have ACKed the SYN.
-			if(!advanced)
+			if(!advanced) {
 				goto reset;
+			}
+
 			c->rcv.irs = hdr.seq;
 			c->rcv.nxt = hdr.seq;
 			set_state(c, ESTABLISHED);
 			// TODO: notify application of this somehow.
 			break;
+
 		case SYN_RECEIVED:
 		case ESTABLISHED:
 		case FIN_WAIT_1:
@@ -1205,6 +1359,7 @@ skip_ack:
 		case TIME_WAIT:
 			// Ehm, no. We should never receive a second SYN.
 			return 0;
+
 		default:
 #ifdef UTCP_DEBUG
 			abort();
@@ -1220,12 +1375,14 @@ skip_ack:
 
 	if(c->state == SYN_RECEIVED) {
 		// This is the ACK after the SYNACK. It should always have ACKed the SYNACK.
-		if(!advanced)
+		if(!advanced) {
 			goto reset;
+		}
 
 		// Are we still LISTENing?
-		if(utcp->accept)
+		if(utcp->accept) {
 			utcp->accept(c, c->src);
+		}
 
 		if(c->state != ESTABLISHED) {
 			set_state(c, CLOSED);
@@ -1243,16 +1400,19 @@ skip_ack:
 			abort();
 #endif
 			return 0;
+
 		case ESTABLISHED:
 		case FIN_WAIT_1:
 		case FIN_WAIT_2:
 			break;
+
 		case CLOSE_WAIT:
 		case CLOSING:
 		case LAST_ACK:
 		case TIME_WAIT:
 			// Ehm no, We should never receive more data after a FIN.
 			goto reset;
+
 		default:
 #ifdef UTCP_DEBUG
 			abort();
@@ -1274,23 +1434,28 @@ skip_ack:
 			abort();
 #endif
 			break;
+
 		case ESTABLISHED:
 			set_state(c, CLOSE_WAIT);
 			break;
+
 		case FIN_WAIT_1:
 			set_state(c, CLOSING);
 			break;
+
 		case FIN_WAIT_2:
 			gettimeofday(&c->conn_timeout, NULL);
 			c->conn_timeout.tv_sec += 60;
 			set_state(c, TIME_WAIT);
 			break;
+
 		case CLOSE_WAIT:
 		case CLOSING:
 		case LAST_ACK:
 		case TIME_WAIT:
 			// Ehm, no. We should never receive a second FIN.
 			goto reset;
+
 		default:
 #ifdef UTCP_DEBUG
 			abort();
@@ -1322,6 +1487,7 @@ reset:
 	swap_ports(&hdr);
 	hdr.wnd = 0;
 	hdr.aux = 0;
+
 	if(hdr.ctl & ACK) {
 		hdr.seq = hdr.ack;
 		hdr.ctl = RST;
@@ -1330,6 +1496,7 @@ reset:
 		hdr.seq = 0;
 		hdr.ctl = RST | ACK;
 	}
+
 	print_packet(utcp, "send", &hdr, sizeof(hdr));
 	utcp->send(utcp, &hdr, sizeof(hdr));
 	return 0;
@@ -1338,6 +1505,7 @@ reset:
 
 int utcp_shutdown(struct utcp_connection *c, int dir) {
 	debug("%p shutdown %d at %u\n", c ? c->utcp : NULL, dir, c ? c->snd.last : 0);
+
 	if(!c) {
 		errno = EFAULT;
 		return -1;
@@ -1356,12 +1524,14 @@ int utcp_shutdown(struct utcp_connection *c, int dir) {
 
 	// TCP does not have a provision for stopping incoming packets.
 	// The best we can do is to just ignore them.
-	if(dir == UTCP_SHUT_RD || dir == UTCP_SHUT_RDWR)
+	if(dir == UTCP_SHUT_RD || dir == UTCP_SHUT_RDWR) {
 		c->recv = NULL;
+	}
 
 	// The rest of the code deals with shutting down writes.
-	if(dir == UTCP_SHUT_RD)
+	if(dir == UTCP_SHUT_RD) {
 		return 0;
+	}
 
 	switch(c->state) {
 	case CLOSED:
@@ -1377,9 +1547,11 @@ int utcp_shutdown(struct utcp_connection *c, int dir) {
 	case ESTABLISHED:
 		set_state(c, FIN_WAIT_1);
 		break;
+
 	case FIN_WAIT_1:
 	case FIN_WAIT_2:
 		return 0;
+
 	case CLOSE_WAIT:
 		set_state(c, CLOSING);
 		break;
@@ -1393,14 +1565,19 @@ int utcp_shutdown(struct utcp_connection *c, int dir) {
 	c->snd.last++;
 
 	ack(c, false);
-	if(!timerisset(&c->rtrx_timeout))
+
+	if(!timerisset(&c->rtrx_timeout)) {
 		start_retransmit_timer(c);
+	}
+
 	return 0;
 }
 
 int utcp_close(struct utcp_connection *c) {
-	if(utcp_shutdown(c, SHUT_RDWR) && errno != ENOTCONN)
+	if(utcp_shutdown(c, SHUT_RDWR) && errno != ENOTCONN) {
 		return -1;
+	}
+
 	c->recv = NULL;
 	c->poll = NULL;
 	c->reapable = true;
@@ -1426,6 +1603,7 @@ int utcp_abort(struct utcp_connection *c) {
 	switch(c->state) {
 	case CLOSED:
 		return 0;
+
 	case LISTEN:
 	case SYN_SENT:
 	case CLOSING:
@@ -1472,8 +1650,10 @@ struct timeval utcp_timeout(struct utcp *utcp) {
 
 	for(int i = 0; i < utcp->nconnections; i++) {
 		struct utcp_connection *c = utcp->connections[i];
-		if(!c)
+
+		if(!c) {
 			continue;
+		}
 
 		// delete connections that have been utcp_close()d.
 		if(c->state == CLOSED) {
@@ -1482,14 +1662,18 @@ struct timeval utcp_timeout(struct utcp *utcp) {
 				free_connection(c);
 				i--;
 			}
+
 			continue;
 		}
 
 		if(timerisset(&c->conn_timeout) && timercmp(&c->conn_timeout, &now, <)) {
 			errno = ETIMEDOUT;
 			c->state = CLOSED;
-			if(c->recv)
+
+			if(c->recv) {
 				c->recv(c, NULL, 0);
+			}
+
 			continue;
 		}
 
@@ -1501,32 +1685,40 @@ struct timeval utcp_timeout(struct utcp *utcp) {
 		if(c->poll) {
 			if((c->state == ESTABLISHED || c->state == CLOSE_WAIT)) {
 				uint32_t len =  buffer_free(&c->sndbuf);
-				if(len)
+
+				if(len) {
 					c->poll(c, len);
+				}
 			} else if(c->state == CLOSED) {
 				c->poll(c, 0);
 			}
 		}
 
-		if(timerisset(&c->conn_timeout) && timercmp(&c->conn_timeout, &next, <))
+		if(timerisset(&c->conn_timeout) && timercmp(&c->conn_timeout, &next, <)) {
 			next = c->conn_timeout;
+		}
 
-		if(timerisset(&c->rtrx_timeout) && timercmp(&c->rtrx_timeout, &next, <))
+		if(timerisset(&c->rtrx_timeout) && timercmp(&c->rtrx_timeout, &next, <)) {
 			next = c->rtrx_timeout;
+		}
 	}
 
 	struct timeval diff;
+
 	timersub(&next, &now, &diff);
+
 	return diff;
 }
 
 bool utcp_is_active(struct utcp *utcp) {
-	if(!utcp)
+	if(!utcp) {
 		return false;
+	}
 
 	for(int i = 0; i < utcp->nconnections; i++)
-		if(utcp->connections[i]->state != CLOSED && utcp->connections[i]->state != TIME_WAIT)
+		if(utcp->connections[i]->state != CLOSED && utcp->connections[i]->state != TIME_WAIT) {
 			return true;
+		}
 
 	return false;
 }
@@ -1538,8 +1730,10 @@ struct utcp *utcp_init(utcp_accept_t accept, utcp_pre_accept_t pre_accept, utcp_
 	}
 
 	struct utcp *utcp = calloc(1, sizeof(*utcp));
-	if(!utcp)
+
+	if(!utcp) {
 		return NULL;
+	}
 
 	utcp->accept = accept;
 	utcp->pre_accept = pre_accept;
@@ -1553,17 +1747,23 @@ struct utcp *utcp_init(utcp_accept_t accept, utcp_pre_accept_t pre_accept, utcp_
 }
 
 void utcp_exit(struct utcp *utcp) {
-	if(!utcp)
+	if(!utcp) {
 		return;
+	}
+
 	for(int i = 0; i < utcp->nconnections; i++) {
 		struct utcp_connection *c = utcp->connections[i];
+
 		if(!c->reapable)
-			if(c->recv)
+			if(c->recv) {
 				c->recv(c, NULL, 0);
+			}
+
 		buffer_exit(&c->rcvbuf);
 		buffer_exit(&c->sndbuf);
 		free(c);
 	}
+
 	free(utcp->connections);
 	free(utcp);
 }
@@ -1574,24 +1774,33 @@ uint16_t utcp_get_mtu(struct utcp *utcp) {
 
 void utcp_set_mtu(struct utcp *utcp, uint16_t mtu) {
 	// TODO: handle overhead of the header
-	if(utcp)
+	if(utcp) {
 		utcp->mtu = mtu;
+	}
 }
 
 void utcp_reset_timers(struct utcp *utcp) {
-	if(!utcp)
+	if(!utcp) {
 		return;
+	}
+
 	struct timeval now, then;
+
 	gettimeofday(&now, NULL);
+
 	then = now;
+
 	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;
 	}
-	if(utcp->rto > START_RTO)
+
+	if(utcp->rto > START_RTO) {
 		utcp->rto = START_RTO;
+	}
 }
 
 int utcp_get_user_timeout(struct utcp *u) {
@@ -1599,8 +1808,9 @@ int utcp_get_user_timeout(struct utcp *u) {
 }
 
 void utcp_set_user_timeout(struct utcp *u, int timeout) {
-	if(u)
+	if(u) {
 		u->timeout = timeout;
+	}
 }
 
 size_t utcp_get_sndbuf(struct utcp_connection *c) {
@@ -1608,18 +1818,23 @@ size_t utcp_get_sndbuf(struct utcp_connection *c) {
 }
 
 size_t utcp_get_sndbuf_free(struct utcp_connection *c) {
-	if(c && (c->state == ESTABLISHED || c->state == CLOSE_WAIT))
+	if(c && (c->state == ESTABLISHED || c->state == CLOSE_WAIT)) {
 		return buffer_free(&c->sndbuf);
-	else
+	} else {
 		return 0;
+	}
 }
 
 void utcp_set_sndbuf(struct utcp_connection *c, size_t size) {
-	if(!c)
+	if(!c) {
 		return;
+	}
+
 	c->sndbuf.maxsize = size;
-	if(c->sndbuf.maxsize != size)
+
+	if(c->sndbuf.maxsize != size) {
 		c->sndbuf.maxsize = -1;
+	}
 }
 
 size_t utcp_get_rcvbuf(struct utcp_connection *c) {
@@ -1627,18 +1842,23 @@ size_t utcp_get_rcvbuf(struct utcp_connection *c) {
 }
 
 size_t utcp_get_rcvbuf_free(struct utcp_connection *c) {
-	if(c && (c->state == ESTABLISHED || c->state == CLOSE_WAIT))
+	if(c && (c->state == ESTABLISHED || c->state == CLOSE_WAIT)) {
 		return buffer_free(&c->rcvbuf);
-	else
+	} else {
 		return 0;
+	}
 }
 
 void utcp_set_rcvbuf(struct utcp_connection *c, size_t size) {
-	if(!c)
+	if(!c) {
 		return;
+	}
+
 	c->rcvbuf.maxsize = size;
-	if(c->rcvbuf.maxsize != size)
+
+	if(c->rcvbuf.maxsize != size) {
 		c->rcvbuf.maxsize = -1;
+	}
 }
 
 bool utcp_get_nodelay(struct utcp_connection *c) {
@@ -1646,8 +1866,9 @@ bool utcp_get_nodelay(struct utcp_connection *c) {
 }
 
 void utcp_set_nodelay(struct utcp_connection *c, bool nodelay) {
-	if(c)
+	if(c) {
 		c->nodelay = nodelay;
+	}
 }
 
 bool utcp_get_keepalive(struct utcp_connection *c) {
@@ -1655,8 +1876,9 @@ bool utcp_get_keepalive(struct utcp_connection *c) {
 }
 
 void utcp_set_keepalive(struct utcp_connection *c, bool keepalive) {
-	if(c)
+	if(c) {
 		c->keepalive = keepalive;
+	}
 }
 
 size_t utcp_get_outq(struct utcp_connection *c) {
@@ -1664,13 +1886,15 @@ size_t utcp_get_outq(struct utcp_connection *c) {
 }
 
 void utcp_set_recv_cb(struct utcp_connection *c, utcp_recv_t recv) {
-	if(c)
+	if(c) {
 		c->recv = recv;
+	}
 }
 
 void utcp_set_poll_cb(struct utcp_connection *c, utcp_poll_t poll) {
-	if(c)
+	if(c) {
 		c->poll = poll;
+	}
 }
 
 void utcp_set_accept_cb(struct utcp *utcp, utcp_accept_t accept, utcp_pre_accept_t pre_accept) {
-- 
2.39.2