Make the send/receive buffer size configurable in the test program.

Add packet loss to the benchmark script.

Add a script to generate graphs of the data recorded by the benchmark script.

Add better debugging output.

All messages from UTCP itself are now of the form:

timestamp srcport:dstport foo 123 bar 456 ...

The UNIX timestamp is wall clock time, to allow data from multiple
computers that are synchronised via NTP to be correlated.
Only part of the payload is now dumped by default to make the logs more
easily readable.

The test program now also adds the same format timestamp to its debug
messages.

Fix congestion window size after a triplicate ACK

Implement fast recovery according to RFC 5681.

Avoid sending packets smaller than the MTU if we don't need to.

If we have almost filled the congestion window but have more data in the
send buffer than we can send right now, wait until the congestion window
frees up to avoid sending small packets unnecessarily.

Implement slow start threshold according to RFC 5681.

Always announce the receive window size as the size of the receive buffer.

Since UTCP requires the application to handle incoming in-sequence data
immediately, the start of the receive buffer is always right after the
last ACKed byte, so we can always announce the size of the receive buffer
as the maximum receive window size.

Add a benchmark script.

This script sets up two network namespaces connected via a veth tunnel with
the netem qdisc to simulate "realistic" network conditions.

It first uses socat to transmit data via regular TCP, then transmits the
same amount of data using the UTCP test program. It prints the time it took
for both methods, and stores a packet trace for both methods so it can be
analyzed.

Add a Wireshark plugin to help dissect UTCP packets.

This assumes UTCP is being transported in plaintext over UDP port 9999.

Update test program to set a better default MTU.

Fix garbage being sent at start of UDP connection.

If utcp_send() was called right after utcp_connect_ex(..., UTCP_UDP),
and the handshake phase hadn't completed yet, we left some garbage in
the send buffer which wasn't cleared until two more calls to utcp_send()
were made.

Avoid a compiler warning when compiling with -DNDEBUG.

Fix retransmission timeout calculation.

The RTO calculation was missing a factor 4 multiplication of the
RTT variance, which caused it to set the RTO to a much lower value than
specified by RFC 6298. This would result in more retranmissions and a
lower throughput.

Correctly handle incoming retransmissions of SYN packets.

Replace two hardcoded timeout values with utcp->timeout.

Don't reset timers that were not set in utcp_reset_timers() and utcp_offline().

In utcp_reset_timers(), we were actually setting the connection timer even
if it was not set before, therefore causing spurious channel closures on
channels that did not have any unACKed data.

In utcp_offline(), we were setting the retransmission timer even if there
was nothing to retransmit.

Also always send an ACK back when the SYN or FIN bit is set.

Always send an ACK back when we receive data from the peer.

A previous ACK could get lost, causing the peer to resend data. If the
retransmission doesn't contain any new data, we would consider this data
to be outside our receive window, and then not resend our ACK.

Several fixes for handling UDP-like channels.

- Drop data sent before the connection is established.
- Relax checks on incoming ACK seqnos
- Always consider all data ACKed
- Disregard hdr.seq when a FIN packet is received
- Don't ACK pure data packets

Allow setting the MTU in the test program.

Call the poll callback with 0 whenever a connection is closed.

Don't abort when UTCP_NO_PARTIAL is set.

Add a flag to prevent partial writes on a UTCP connection.

Add a function to manually start the connection timeout timers.

If the application knows the peer is offline, it can call utcp_offline().
This will start the connection timers on all connections to that peer.
This can be undone by marking the peer online again. This will also reset
the retransmission timers.

Start the connection timeout timer when we have unACKed data.

Start it when we are have some data to send, and reset it whenever some of
the data is ACKed. Stop the timer if the peer has received all the data.

Also ensure the poll callback is called with len = 0 when the timeout is
hit.

Check for astyle version 3 before formatting the code.

Unfortunately, code formatters change their behaviour between versions.
The code currently requires astyle version 3.x, so check this before
running astyle. If the wrong version is installed, print an error.

Add functions to get the amount of bytes in the send and receive buffers.

utcp_get_sendq() returns the amount of bytes in the send buffer, which
corresponds to the amount of bytes not yet ACKed by the peer.

utcp_get_recvq() returns the amount of bytes in the receive buffer,
which may or may not have been acked already, but have not been read by
the application.

Keep a copy of the old receive callback before calling reset_connection().

The latter function clears the receive callback, so make a copy before
calling trying to call the receive callback for the final time.

Small fixes for utcp_abort_all_connections().

- Make utcp_reset_connection() a private function.
- Ensure we don't repeat any action when aborting a connection twice.
- Call the receive callback after resetting the connection, so the callback
  function can safely call utcp_close().

Add utcp_abort_all_connections function.

This adds a function to abort all open connections without invalidating
the utcp_connection_t handles. Its main purposes is when the application
knows communication with the peer is definitely not possible/desired anymore.
A RST packet will be sent to each connection's remote end, and the
receive callback will be invoked to indicate an error on each
connection.

Allow utcp_send() before a connection has been fully established.

This will put the data in the send buffer, and it will be sent when possible.
This also allows the socket to be shut down for writing before it has
reached the ESTABLISHED state.

Add more error messages to test program, allow socket reuse.

Fix all compiler warnings found using -Wall -W -pedantic.

Format the code using the Artistic Style formatter.

Convert sizeof foo to sizeof(foo).

While technically sizeof is an operator and doesn't need the parentheses
around expressions it operates on, except if they are type names, code
formatters don't seem to handle this very well.

Fix warnings when compiling with -Wall -W.

Call the receive callback for unclosed channels during utcp_exit().

This allows the application to clean up any resources associated with
these UTCP connections.

Fix SYN packet handling.

This fixes problems with SYN packets arriving out of the usual order.
This also adds a more proper handling of the aux field.

Allow timers to be reset.

The function utcp_reset_timers() will reset the retransmit timers of all
connections to zero, so they will fire immediately. The connection timeout will
be reset to the user timeout value, and if the RTO is larger than the
starting RTO, it will be set to the starting RTO.

Remove debug message.

Enable retransmit timer for SYN packets.

Call the poll callback with len = 0 on errors.

Add UDP semantics.

Basically, never retransmit, and whatever we get we immediately pass up to
the application. The only thing we do handle the TCP way is the FIN packet.

This also introduces the use of the aux entry in the header. We know that
older versions of UTCP ignore this field, and also ignore any extra data
in SYN packets, so we can add anything here in a backwards-compatible way.

Introduce utcp_connect_ex().

This takes an extra argument "flags", which can be used to change the type
of connection to create. Possible flags are UTCP_INORDER, UTCP_RELIABLE and
UTCP_FRAMED, which can be bitwise-or'd together, or UTCP_TCP or UTCP_UDP as
shortcuts for what is assumed will be common combinations of those flags.

Fix handling packets partially overlapping the start of the receive buffer.

Fix handling retransmitted data when the receive buffer is full.

Remove two unnecessary calls to abort().

Allow test program to compare input to a reference file.

Fix compiler warnings.

Fix buffer resizing logic in buffer_put_at().

When growing the buffer when it's not big enough for new data, the
current size is doubled repeatedly until it is big enough for the new
data. The required new size is stored in the variable "required",
however the doubling loop exited when the new size was at least
buf->used + len, which might be much smaller than "required" if an
out-of-order packet is received.

Only log debug messages in test program when UTCP_DEBUG is defined.

Add more debug messages.

Ensure utcp_close() works properly on a socket that is in the CLOSED state.

Log when dropping packets in the test program.

Define USEC_PER_SEC, use "sec" and "usec" in comments.

Add debug message when dropping a packet because all SACK entries are used.

Clarify description of sack_consume().

Make max() an inline function.

Don't use ?: without the middle argument.

Always check the return value of malloc().

Fix bugs in sack_consume() causing data corruption or abort()s.

Put in a lengthy comment with some ASCII-art to describe what we are
actually trying to do in this function.

Fix bug in retransmit().

The logic to check whether we actually have something to retransmit was
wrong, causing retransmit() to bail out early without setting or resetting
the timer. This also caused utcp_timeout() to return a negative value.

Ensure FIN packets start the retransmission timer as well.

Allow setting $DROPFROM without having to specify $DROPTO as well.

Simulate packet reordering.

With a configurable chance, delay a packet for a random amount of packets.

Fix a memory leak.

The receive buffer was never freed.

Make sure all of the packet header is set when retransmitting packets.

speed up utcp print_packet debug output and print in hex

handle overlapping packets

# Conflicts:
# utcp.c

Send ACKs also when receiving out-of-order data.

This is necessary to trigger the triplicate ACK detection on the sender.

Log when we start retransmission.

Get rid of an unused label.

Fix the logic for determining whether a packets has an acceptable ack seqno.

snd.last accurately tracks the last possible seqno that can be acked, so
use it. This fixes a case where retransmitted ACKs of a FIN were not handled
correctly.

Use the calculated RTO value to set the retransmission timer.

This significantly cuts down the time it takes to transfer data when there
is packet loss, because retransmission kicks in much earlier.

Measure RTT and calculate RTO.

Opportunistically measure RTT using only a single timer, without requiring
timestamps to be added to packets. Use the method described in RFC 6298 to
smoothly update the value of RTO.

Turn magic numbers into #defines.

Remove accidentily left #warning.

Minor changes in the test program.

- Add one to the timeout in milliseconds, to prevent roundoff errors from
  causing us to busy-loop unnecessarily.
- Log what we are polling for and what the timeout is.

Improve documentation of retransmission timeout handling.

Document difference between snd.nxt and snd.last.

Fix a memory leak on invalid invocation of utcp_init().

Add a receive buffer.

The receive buffer kicks in the moment we get a packet which is out of order.
We store the packet in the buffer, and keep track of up to 4 ranges of bytes
of received data. When retransmission fills the first gap, we send all the
buffered data (up to the second gap if applicable) to the application.

4 byte ranges seems to be a good value for up to moderate (20%) packet loss.
This algorithm greatly reduces the amount of useless packets being sent.
A future improvement is sending the SACK information in the ACK packets,
so the congestion window can be kept large while avoiding packets being
resent unnecessarily.

Fix check for return value of malloc(), allow initially zero length buffer.

Allow putting data in a buffer at an arbitrary offset.

Fix check for return value of malloc().

When debugging, set initial segment seqno to 0.

Show total bytes sent/received in test program.

Reset the snd.nxt pointer when starting packet retransmission.

When a packet was lost, and the send buffer contains more than two packets,
this only retransmitted the first packet from the send buffer, then when it
got acked it would continue with the tail of the buffer. Then it would have
to wait for another timeout to send the next packet from the start of the
send buffer. If the application is continuously sending data, then the send
buffer would never become empty and the problem would persist.

Fix a segfault when debugging is enabled.

Log timestamps during the test.

Allow dropping a selected range of packets during tests.

Add scripts testing filetransfer.

- txttest transfers a file into one direction.
- bidirtest transfers a file both ways simultaneously.

Handle direction argument of utcp_shutdown().

For TCP, only shutting down the send direction makes sense, however to
be compatible to the BSD sockets API, keep the direction argument, and
when someone tries to shut down the receive direction, just disable the
receive callback.

Note that on most operating systems, SHUT_RD actually doesn't do
anything at all, it won't prevent reads from returning data.

Also be a bit more strict, return EINVAL or ENOTCONN when appropriate.

Define UTCP_SHUT_RD/WR/RDWR.

Don't rely on <sys/socket.h> for the definitions of SHUT_RD/WR/RDWR, add
our own. They should be compatible.

Add a function to check for active connections.

If a connection sends data in one way, then the receiver will have shut
down data in the other way, and when the sender is finished he will also
shut down his direction, so the connection looks closed to the sender,
but the receiver might actually still miss the final packets. So UTCP
should keep running until the receiver has received a FINACK and is in the
TIME_WAIT state.

We consider UTCP to be active when there is at least one connection not in
the CLOSED or TIME_WAIT state.

The test program now uses this condition, which allows a transfer of a file
to complete without missing the last few bytes.

Allow changing the accept callbacks.

This is used in the test, in order to stop accepting new connections after
the first one.

Clarify read/write direction in test program.

Use '== -1' to check for errors from functions.

As made obvious by commit 123f53f, the type of ssize_t cannot be trusted
on Windows to actually be signed, so don't use '< 0', as the compiler
will optimize the test away. POSIX also specifies only that -1 signals
an error condition, not any other negative value.

Luckily, comparing an unsigned int to -1 still works as intended.