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.

Handle retransmissions in CLOSE_WAIT, CLOSING and LAST_ACK states.

Add fin_wanted() function that checks whether a FIN bit should be set on a packet.

Call abort() only when debugging is enabled.

Guard against NULL pointer dereferencing.

Prevent FIN bit from being sent too early.

Due to a logic bug in ack(), the FIN bit could be set on a too early packet,
if utcp_shutdown() was called with a full send buffer.

Properly handle arbitrary size files being piped into the test program.

utcp_get_sndbuf_free() should return 0 if utcp_send() would fail.

Remove unconditional debug messages.

Recover from dropped packets after receiving a triplicate ACK.

When this happens, reset the nxt pointer so we start retransmitting from the last acknowledged
packet, at the same speed as ACKs are coming in.

Send ACKs without a payload upon receiving an out-of-order packet.

This is necessary so the peer can detect "triplicate ACKs", which signal dropped packets, and at the
same time keeps the TCP self-clocking active.

Change utcp_timeout() to return a struct timeval.

This is what MeshLink uses internally as well, and prevents confusion over which units the old int
return value had.

Don't call abort() in retransmit().

The retransmission timer can sometimes get called when in one of the
closing states. This is not implemented yet, but it's better to just
ignore those cases for now than to abort().

Disable callbacks when closing a connection.

When an application calls utcp_close() on a previously established
connection, the utcp_connection is kept around to handle FIN(ACK)
packets. However, the peer could still send some data, which should not
trigger the receive callback.

Remove debugging messages.

Fix and refactor send buffer code.

Make generic buffer handling functions and use those. A problem was
found when resizing a buffer; if new data to be put into the buffer was
more than twice as large as the current buffer size, the code would not
reallocate the buffer large enough.

Fix free_connection() moving the wrong memory.

Only call the poll callback when state is ESTABLISHED or CLOSE_WAIT.

Fix retransmit().

Don't put a VLA in a struct, C99 does not allow it.

Add some missing definitions for Windows.

Add a poll callback to UTCP connections.

The callback is called whenever the send buffer of a connection is more
than half empty when utcp_timeout() is called. An argument is passed to
the callee informing him of the maximum number of bytes that will be
accepted when calling utcp_send().

Set priv field in utcp_connect().

Implement slow start.

Various small fixes, clarifications.

Fix memory and resource leaks.

Set FIN bit in ack().

Start implementation of congestion avoidance.

We try to implement RFC 2001.

Improve Makefile.

Allow debug messages to be compiled out.

Add socket option functions names similar to setsockopt()/ioctl() ones.

Add a .gitignore file.

Move private struct declarations e.a. to utcp_priv.h.

Add utcp_set_mtu().

Handle FIN_WAIT_1 state when retransmitting.

Increase sndbuf when necessary.

Redo receive logic.

Update README.

Allow variable packet loss rates to be set in the test program.

Print both incoming and outgoing packets.

Update snd.una when receiving an ACK in the SYN_RECEIVED state.

Start implementing timeout handling.

- Initial connection timeout (1 minute by default)
- Retransmission of SYN, SYNACK and normal data packets

Pass buffers as const.

Rename UTCP to README.

Segmentize outgoing packets.

Do proper modulo 2^32 comparisons of sequence numbers.

Do port numbers properly.

- Outgoing connections automatically get a port number >= 32768 assigned.
- *connect() and *accept() get a port number as argument.
- Connections are now stored in a sorted array with O(log(N)) lookup time.

Build both binaries.

Start of UTCP.