Defer handling netname conflicts when accepting an invitation.

In case no explicit netname of configuration directory is specified when
accepting an invitation, the netname specified in the invitation data is
used. However, this new netname is only known after making the connection
to the server. If the new netname conflicts with an existing one at the
client, we ask the user for a netname that doesn't conflict. However, we
should first finish accepting the invitation, so we don't run into the
problem that the server times out and cancels the invitation. So, we create
a random netname and store the files there, and only after we finish
accepting the invitation we ask the user for a better netname, and then
just rename the temporary directory to the final name.

Make absolutely sure we can write config files before accepting an invitation.

Choose a different Port when 655 isn't available when doing "tinc join".

Choose a different Port when 655 isn't available when doing "tinc init".

If port 655 cannot be bound to when using the init command, tinc will try to
find a random port number that can be bound to, and will add the appropriate
Port variable to its host config file. A warning will be printed as well.

Don't forget the Port variable when creating an invitation URL.

Allow control-C to stop tincd without stopping the tinc shell.

Warn when incorrect use of add or set causes variables to be removed.

Fix compression when using the SPTPS protocol.

Honour umask, let temporary key files inherit original's permissions.

During the init command, tinc changed the umask to 077 when writing the public
and private key files, to prevent the temporary copies from being world
readable. However, subsequently created files would therefore also be
unreadable for others. Now we don't change the umask anymore, therefore
allowing the user to choose whether the files are world readable or not by
setting the umask as desired. The private key files are still made unreadable
for others of course. Temporary files now inherit the permissions of the
original, and the tinc-up script's permissions now also honour the umask.

Further improve bandwidth estimation for type 2 MTU probe replies.

This patch adds timestamp information to type 2 MTU probe replies. This
timestamp can then be used by the recipient to estimate bandwidth more
accurately, as jitter in the RX direction won't affect the results.

Introduce lightweight PMTU probe replies.

When replying to a PMTU probe, tinc sends a packet with the same length
as the PMTU probe itself, which is usually large (~1450 bytes). This is
not necessary: the other node wants to know the size of the PMTU probes
that have been received, but encoding this information as the actual
reply length is probably the most inefficient way to do it. It doubles
the bandwidth usage of the PMTU discovery process, and makes it less
reliable since large packets are more likely to be dropped.

This patch introduces a new PMTU probe reply type, encoded as type "2"
in the first byte of the packet, that indicates that the length of the
PMTU probe that is being replied to is encoded in the next two bytes of
the packet. Thus reply packets are only 3 bytes long.

(This also protects against very broken networks that drop very small
packets - yes, I've seen it happen on a subnet of a national ISP - in
such a case the PMTU probe replies will be dropped, and tinc won't
enable UDP communication, which is a good thing.)

Because legacy nodes won't understand type 2 probe replies, the minor
protocol number is bumped to 3.

Note that this also improves bandwidth estimation, as it is able to
measure bandwidth in both directions independently (the node receiving
the replies is measuring in the TX direction) and the use of smaller
reply packets might decrease the influence of jitter.

Disable PMTU discovery when TCPOnly is set.

Obviously, PMTU discovery doesn't make much sense when we know we'll be
using TCP anyway.

Allow extra options to be passed to "tinc restart" again.

Forbid protocol version rollback.

When we know a node's ECDSA key, we only allow communication via the SPTPS
protocol.

Attribution for Etienne Dechamps.

Fix hash_function().

The hashing function that tinc uses is currently broken as it only looks
at the first 4 bytes of data.

This leads to interesting bugs, like the node UDP address cache being
subtly broken because two addresses with the same protocol and port (but
not the same IP address) will override each other. This is because
the first four bytes of sockaddr_in contains the IP protocol and port,
while the IP address itself is contained in the four remaining bytes
that are never used when the hash is computed.

Don't use vasprintf() anymore on Windows.

Windows doesn't actually support it, but MinGW provides it. However, with some versions of
MinGW it doesn't work correctly. Instead, we vsnprintf() to a local buffer and xstrdup() the
results.

Don't search in local directories for include files.

Tinc's source code doesn't rely on this anymore, and this gets rid of potential conflicts with
system headers.

Add missing definitions on Windows.

Fix warning "Both netname and configuration directory given" on Windows.

Fix combination of Mode = router and DeviceType = tap on Linux.

I believe I have found a bug in tinc on Linux when it is used with
Mode = router and DeviceType = tap. This combination is useful because
it allows global broadcast packets to be used in router mode. However,
when tinc receives a packet in this situation, it needs to make sure its
destination MAC address matches the address of the TAP adapter, which is
typically not the case since the sending node doesn't know the MAC
address of the recipient. Unfortunately, this is not the case on Linux,
which breaks connectivity.

Add connection rate limiting.

Tinc now strictly limits incoming connections from the same host to 1 per
second. For incoming connections from multiple hosts short bursts of incoming
connections are allowed (by default 100), but on average also only 1 connection
per second is allowed.

When an incoming connection exceeds the limit, tinc will keep the connection in
a tarpit; the connection will be kept open but it is ignored completely. Only
one connection is in a tarpit at a time to limit the number of useless open
connections.

Set $NAME when calling host-up/down and subnet-up/down scripts.

Add the LocalDiscoveryAddress option.

When LocalDiscovery is enabled, tinc normally sends broadcast packets during
PMTU discovery to the broadcast address (255.255.255.255 or ff02::1). This
option lets tinc use a different address.

At the moment only one LocalDiscoveryAddress can be specified.

Use strerror() instead of gai_strerror() when err == EAI_SYSTEM.

Allow the log output to be stopped with control-C in tinc's shell.

Better optional argument handling.

Some options can take an optional argument. However, in this case GNU getopt
requires that the optional argument is right next to the option without
whitespace inbetween. If there is whitespace, getopt will treat it as a
non-option argument, but tincd ignored those without a warning. Now tincd will
allow optional arguments with whitespace inbetween, and will give an error when
it encounters any other non-option arguments.

The tinc binary now requires that all options for itself are given before the
command.

Add an invitation protocol.

Using the tinc command, an administrator of an existing VPN can generate
invitations for new nodes. The invitation is a small URL that can easily
be copy&pasted into email or live chat. Another person can have tinc
automatically setup the necessary configuration files and exchange keys
with the server, by only using the invitation URL.

The invitation protocol uses temporary ECDSA keys. The invitation URL
consists of the hostname and port of the server, a hash of the server's
temporary ECDSA key and a cookie. When the client wants to accept an
invitation, it also creates a temporary ECDSA key, connects to the server
and says it wants to accept an invitation. Both sides exchange their
temporary keys. The client verifies that the server's key matches the hash
in the invitation URL. After setting up an SPTPS connection using the
temporary keys, the client gives the cookie to the server. If the cookie
is valid, the server sends the client an invitation file containing the
client's new name and a copy of the server's host config file. If everything
is ok, the client will generate a long-term ECDSA key and send it to the
server, which will add it to a new host config file for the client.

The invitation protocol currently allows multiple host config files to be
send from the server to the client. However, the client filters out
most configuration variables for its own host configuration file. In
particular, it only accepts Name, Mode, Broadcast, ConnectTo, Subnet and
AutoConnect. Also, at the moment no tinc-up script is generated.

When an invitation has succesfully been accepted, the client needs to start
the tinc daemon manually.

Fix port number in pidfile.

Add a newline when logging to stderr in the tinc binary.

Improve base64 encoding/decoding, add URL-safe variant.

b64decode() now returns length 0 when an invalid character was encountered.

Annotate the xalloc functions.

Most important is the annotation of xasprintf() with the format attribute,
which allows the compiler to give warnings about the format string and
arguments.

Send a new key when we receive packets from a node we don't have a valid key for.

Enable and fix warnings from automake.

Modified some error messages in src/sptps.c.

Don't try to handle incoming data if sptps_start() has not been called yet.

Fix potential NULL pointer dereferences.

Don't free ephemeral ECDH keys twice.

ecdh_compute_shared() was changed to immediately delete the ephemeral key after
the shared secret was computed.  Therefore, the pointer to the ecdh_t struct
should be zeroed so it won't be freed again when a struct sptps_t is freed.

Use read_host_config() where appropriate.

Fix check for presence of ECDSA public key for outgoing connections.

At this point, c->config_tree may or may not be NULL, but this does not tell us whether it is an
outgoing connection or not. For incoming connections, we do not know the peer's name yet,
so we always have to claim ECDSA support. For outgoing connections, we always need to check
whether we have the peer's ECDSA public key, so that if we don't, we correctly tell the peer that
we want to upgrade.

Enable the SPTPS protocol by default.

Add a few more checks and warnings in the crypto functions.

Fix warnings for functions marked __attribute((warn_unused_result)).

Add __attribute__((warn_unused_result)) to crypto functions.

Add more __attribute__((malloc)) where appropriate.

Add generic crypto headers.

They should have been included in commit 9b9230a.

Rename xmalloc_and_zero() to xzalloc().

The former name is more or less only used by tinc, the latter is used by other
projects as well, and shorter as well.

Use conditional compilation for cryptographic functions.

This gets rid of the rest of the symbolic links. However, as a consequence, the
crypto header files have now moved to src/, and can no longer contain
library-specific declarations. Therefore, cipher_t, digest_t, ecdh_t, ecdsa_t
and rsa_t are now all opaque types, and only pointers to those types can be
used.

Use conditional compilation for device.c.

This requires the automake option "subdir-objects" to be enabled, and it
becomes more critical to specify the exact path to local header files.

Modernize the configure script a bit.

Don't try to create tinc.conf when using set or add commands.

It is almost certainly an error. If one really wants to create a new tinc.conf
file, one should use the init command.

Releasing 1.1pre7.

Drop packets forwarded via TCP if they are too big (CVE-2013-1428).

Normally all requests sent via the meta connections are checked so that they
cannot be larger than the input buffer. However, when packets are forwarded via
meta connections, they are copied into a packet buffer without checking whether
it fits into it. Since the packet buffer is allocated on the stack, this in
effect allows an authenticated remote node to cause a stack overflow.

This issue was found by Martin Schobert.

Fix completion of add/del/get/set commands.

Describe the SPTPS protocol in the manual.

Also mention that Cipher, Digest and MACLength have no influence on the SPTPS protocol,
since that uses a fixed ciphersuite.

Remove references to the config keyword.

Rename tincctl to tinc.

Include README.android in the tarballs.

Avoid calling time(NULL).

In most cases we can use the cached time.

Allow changing configuration with tincctl without the "config" keyword.

This saves typing some characters, and forces one to be more explicit about the
desired command (get, set).

Better default output file for generated public keys.

Flush output buffers in the tap reader thread on Windows.

This is basically a port of commit 50fcfea1 to 1.1.

Use UDP when using sptps_test in datagram mode.

Releasing 1.1pre6.

Fix compiler warnings on some BSD variants.

Fix compiler warnings on Windows.

Fix a tiny memory leak.

Found by cppcheck.

Don't expect a response from tincd after sending REQ_STOP.

Let the GUI use UNIX sockets if available.

Derive UNIX socket filename from PID filename.

Don't send proxy requests for incoming connections.

Fix segmentation fault when trying to connect via a SOCKS5 proxy.

Check for writability when waiting for a socket to finish connecting.

We were checking only for readability, which is not a problem for normal
connections, since the server side of a connection will always send an ID
request. But when using a proxy, the proxy server doesn't send anything before
the client, so tinc would not see that its connection to the proxy had already
been established.

Fix tincd terminating immediately on Windows.

Remove direct inclusion of OpenSSL headers in net_packet.c and tincd.c.

Detect increases in PMTU.

Tinc never restarts PMTU discovery unless a node becomes unreachable. However,
it can be that the PMTU was very low during the initial discovery, but has
increased later. To detect this, tinc now tries to send an extra packet every
PingInterval, with a size slightly higher than the currently known PMTU. If
this packet is succesfully received back, we partially restart PMTU discovery
to find out the new maximum.

Conflicts:
src/net_packet.c

Get microsecond time resolution on Windows.

Fix a typo.

Fix datagram SPTPS.

Commit dd07c9fc1f37bed8d1f67ffe7b203f61e7914edf broke the reception of datagram
SPTPS packets, by undoing the conversion of the sequence number to host byte
order before comparison. This caused error messages like "Packet is 16777215
seqs in the future, dropped (1)".

Releasing 1.1pre5.

Fix tincctl init when /etc/tinc does not yet exist.

Remove possible definition of timersub(), which is also in dropin.h.

Make sure PriorityInheritance also works in switch mode.

Conflicts:
src/route.c

Allow connections via UNIX sockets.

This is mainly useful for control connections. The client must still present
the control cookie from the PID file.

Fix compilation of UML and VDE device support.

Move make_names() and related variables to its own source file.

Handle SIGINT gracefully.

Fix the minimum spanning tree algorithm.

Tinc uses Kruskal's algorithm to calculate a MST. However, this was broken in
commit 6e80da3370249caa1082c23c3ef55f338d1e9e74. Revert back to the working
algorithm from tinc 1.0.

Thanks to Cheng LI for spotting the problem.

Estimate RTT, bandwidth and packet loss between nodes.

Without adding any extra traffic, we can measure round trip times, estimate the
bandwidth and packet loss between nodes. The RTT and bandwidth can be measured
by timing the MTU probe packets. The RTT is the difference between the time a
burst of MTU probes was sent and when the first reply is received. The
bandwidth can be estimated by multiplying the size of the probe packets by the
time between succesive received probe replies of the same burst. The packet
loss can be estimated for incoming traffic by comparing how many packets have
actually been received to the increase in the sequence numbers.

The estimates are not perfect. Especially bandwidth is difficult to measure,
the only accurate way is to continuously send as much data as possible, but
that is obviously not desirable. The packet loss rate is also almost always
a few percent when sending a lot of data over the VPN via TCP, since TCP
*needs* packet loss to work properly.

Count the number of correctly received UDP packets.

Keep track of the number of correct, non-replayed UDP packets that have been
received, regardless of their content. This can be compared to the sequence
number to determine the real packet loss.

Add the tincctl exchange and exchange-all commands.

These are identical to an export/export-all followed by an import, and make
it simpler to exchange host config files with other nodes.

Check HMAC before sequence number.

Always complain if too many arguments are given for tincctl commands.

Better error messages when using -L, -R or -U on platforms that do not support it.

Don't complain about garbage if we skipped importing a host file.

Mention that the -L, -R and -U options are not supported on all platforms.

Note that tincctl import is only meant to work with data from tincctl export.

Note that node Names are case sensitive.

Fix a typo.

Fix support for tunemu on iOS devices.

The actual code was fine but the #ifdefs tested for the wrong preprocessor
variable.

Conflicts:
src/bsd/device.c
src/process.c