Ensure buf->offset is always smaller than buf->size.

Before we allowed buf->offset to be equal to buf->size. This caused an
issue where buffer_call() would call the callback twice, once for 0 bytes
at the end of the buffer, and once for len bytes at the start of the buffer.
This would cause the callback function to think the channel had encountered
an error.

Ensure we retransmit the SYNACK packet if we didn't get an ACK back for it.

We didn't start the retransmission timer when we got an incoming connection,
and we didn't send an ACK back when we received a retransmitted SYNACK
without any data.

Return an error if we can't allocate the packet buffer during utcp_init().

Add a callback that is triggered when the retransmission timeout expires.

This can be used by the application to detect potential network problems.

Avoid calling malloc() in fast_retransmit().

Fix potential segmentation fault when the receive callback is not set.

A few calls to the callback function were missing a check that the
callback function pointer was non-NULL.

Avoid calling the poll callback for UDP style channels.

We still call it on connection establishment and on errors, but we don't
call it when we have space free in the send buffer.

Handle the case where we reduce the buffer size below the amount currently used.

Handle incoming packets that don't fit into the receive buffer.

If the receive buffer size is reduced while there are still incoming
packets in flight, it can be that those will not fit inside the receive
buffer. Instead of calling abort(), just handle as much of the packet as
we can fit in the receive buffer, or handle the whole packet if it is in
order since we bypass the receive buffer in that case.

Fix generating invalid retransmit timeouts.

If the retransmit timeout was more than a second we could end up
generating a timeout that was both invalid (tv_nsec >= 1e9) and too
large.

Make RTT variables per-connection.

We do congestion management per connection, so we should also track RTT per
connection.

Fix RTT measurement.

Commit 723d8c8b2d96834135f00c0ac4147282e1f0cc2c introduced a bug where we
fail to subtract two timespecs correctly, resulting in incorrect RTT values.

Add IPv4 style fragments for UDP style channels.

Add a More Fragments (MF) bit to the ctl field in the header, and reuse the
wnd field for the fragment offset.

We only handle fragments that are received in-order. But this allows an
application to not care about the maximum segment size.

Turn constants back into macros.

Constants initialized with expressions are not allowed by all compilers.

Fix a memory leak.

Add a tool to generate a stream with a configurable bitrate.

This generates a stream with a configurable average bitrate and number of
frames sent per second. The stream has embedded timestamps and counters,
which can be used by the same program to verify the integrity of an
incoming stream and to print the latency between sender and receiver.

Fix data corruption.

This was caused by the code handling incoming retransmissions not reading
from the receive buffer correctly after the change to ringbuffers.

Fix buffer resizing.

Fix building without UTCP_DEBUG.

Don't call the poll callback unnecessarily.

Currently we call the poll callback if there is any free space in the send
buffer, every time we call utcp_timeout(). However, if the application
does not send anything inside the callback, then it most likely won't send
anything the next time if the free space in the send buffer did not change.
So only call the callback when more space has been made available in the
send buffer.

Add utcp_set_clock_granularity().

This overrides the value gotten from clock_getres(), and is intended for
use by an application that knows it might not call utcp_timeout()
exactly on time.

Use clock_gettime() instead of gettimeofday().

It is more portable, and allows reading out the monotonic clock. On some
systems it is also faster than gettimeofday().

Add utcp_get_mss().

Implement ringbuffers.

This avoids a memmove() call every time data in the send buffer is
ACKed. Instead, we now have a memmove() every time the send buffer is
grown, but this happens only a few times at most.

Allocate a persistent packet buffer.

Instead of allocating a new packet buffer every time we generate a packet,
we pre-allocate it and keep it around. We only reallocate when the MTU
increases.

Add better debugging of UDP style connections.

Report packets that are out of order, either because of reordering or
packet loss.

Distinguish between MTU and MSS.

Have the application set the maximum size of a UTCP packet (= MTU), and from
that derive the maximum size of the payload of a UTCP packet (= MSS).

Reset the retransmission timer when receiving duplicate ACKs.

While we are getting duplicate ACKs, and are likely in fast recovery,
keep resetting the retransmission timer, so that if fast recovery takes
longer than the RTO, we don't trigger a slow start.

When we do get a real timeout during fast recovery, reset the duplicate
ACK counter to signal we are no longer in fast recovery.

We also should not do anything when receiving duplicate ACKs when all
data has already been ACKed.

Minor improvements to the benchmark script and graph output.

Use flightsize instead of cwnd to set ssthresh.

Report initial ssthresh value as 0 while debugging.

The initial is actually UINT_MAX, but since this makes it hard to plot a
graph of it with autoscaling axes, show it as 0 instead. This removes the
hack where ssthresh is set to sndbuf.maxsize at the start of a connection,
which is wrong when the application overrides the send buffer size later.

Make global variables and functions static in the test program.

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.