Check validity of Ed25519 key during an upgrade.

Do not disconnect when no ecdsa key is known yet.

This is the normal case when we support the experimental protocol,
but the other side is a tinc 1.0 which does not.

Fix compiler warnings.

Query the Linux device for its MAC address.

On Linux, tinc doesn't know the MAC address of the TAP device until the
first read. This means that if no packets are sent through the
interface, tinc won't be able to figure out which MAC address to tag
incoming packets with. As a result, it is impossible to receive any
packet until at least one packet has been sent.

When IPv6 is disabled Linux does not spontanously send any packets
when the interface comes up. At first users wonder why the node is not
responding to ICMP pings, and then as soon as at least one packet is
sent through the interface, pings mysteriously start working, resulting
in user confusion.

This change fixes that problem by making sure tinc is aware of the
device's MAC address even before the first packet is sent.

Make sure to discover MTU with relays.

Currently, when tinc sends UDP SPTPS datagrams through a relay, it
doesn't automatically start discovering PMTU with the relay. This means
that unless something else triggers PMTU discovery, tinc will keep using
TCP when sending packets through the relay.

This patches fixes the issue by explicitly establishing UDP tunnels with
relays.

Don't send MTU probes to nodes we can't reach directly.

Currently, we send MTU probes to each node we receive a key for, even if
we know we will never send UDP packets to that node because of
indirection. This commit disables MTU probing between nodes that have
direct communication disabled, otherwise MTU probes end up getting sent
through relays.

With the legacy protocol this was never a problem because we would never
request the key of a node with indirection enabled; with SPTPS this was
not a problem until we introduced relaying because send_sptps_data()
would simply ignore indirections, but this is not the case anymore.

Note that the fix is implemented in a quick and dirty way, by disabling
the call to send_mtu_probe() in ans_key_h(); this is not a clean fix
because there's no code to resume sending MTU probes in case the
indirection disappears because of a graph change.

Add UDP datagram relay support to SPTPS.

This commit changes the layout of UDP datagrams to include a 6-byte
destination node ID at the very beginning of the datagram (i.e. before
the source node ID and the seqno). Note that this only applies to SPTPS.

Thanks to this new field, it is now possible to send SPTPS datagrams to
nodes that are not the final recipient of the packets, thereby using
these nodes as relay nodes. Previously SPTPS was unable to relay packets
using UDP, and required a fallback to TCP if the final recipient could
not be contacted directly using UDP. In that sense it fixes a regression
that SPTPS introduced with regard to the legacy protocol.

This change also updates tinc's low-level routing logic (i.e.
send_sptps_data()) to automatically use this relaying facility if at all
possible. Specifically, it will relay packets if we don't have a
confirmed UDP link to the final recipient (but we have one with the next
hop node), or if IndirectData is specified. This is similar to how the
legacy protocol forwards packets.

When sending packets directly without any relaying, the sender node uses
a special value for the destination node ID: instead of setting the
field to the ID of the recipient node, it writes a zero ID instead. This
allows the recipient node to distinguish between a relayed packet and a
direct packet, which is important when determining the UDP address of
the sending node.

On the relay side, relay nodes will happily relay packets that have a
destination ID which is non-zero *and* is different from their own,
provided that the source IP address of the packet is known. This is to
prevent abuse by random strangers, since a node can't authenticate the
packets that are being relayed through it.

This change keeps the protocol number from the previous datagram format
change (source IDs), 17.4. Compatibility is still preserved with 1.0 and
with pre-1.1 releases. Note, however, that nodes running this code won't
understand datagrams sent from nodes that only use source IDs and
vice-versa (not that we really care).

There is one caveat: in the current state, there is no way for the
original sender to know what the PMTU is beyond the first hop, and
contrary to the legacy protocol, relay nodes can't apply MSS clamping
because they can't decrypt the relayed packets. This leads to
inefficient scenarios where a reduced PMTU over some link that's part of
the relay path will result in relays falling back to TCP to send packets
to their final destinations.

Another caveat is that once a packet gets sent over TCP, it will use
TCP over the entire path, even if it is technically possible to use UDP
beyond the TCP-only link(s).

Arguably, these two caveats can be fixed by improving the
metaconnection protocol, but that's out of scope for this change. TODOs
are added instead. In any case, this is no worse than before.

In addition, this change increases SPTPS datagram overhead by another
6 bytes for the destination ID, on top of the existing 6-byte overhead
from the source ID.

Prepend source node ID information to UDP datagrams.

This commit changes the layout of UDP datagrams to include the 6-byte ID
(i.e. node name hash) of the node that crafted the packet at the very
beginning of the datagram (i.e. before the seqno). Note that this only
applies to SPTPS.

This is implemented at the lowest layer, i.e. in
handle_incoming_vpn_data() and send_sptps_data() functions. Source ID is
added and removed there, in such a way that the upper layers are unaware
of its presence.

This is the first stepping stone towards supporting UDP relaying in
SPTPS, by providing information about the original sender in the packet
itself. Nevertheless, even without relaying this commit already provides
a few benefits such as being able to reliably determine the source node
of a packet in the presence of an unknown source IP address, without
having to painfully go through all node keys. This makes tinc's behavior
much more scalable in this regard.

This change does not break anything with regard to the protocol: It
preserves compatibility with 1.0 and even with older pre-1.1 releases
thanks to a minor protocol version change (17.4). Source ID information
won't be included in packets sent to nodes with minor version < 4.

One drawback, however, is that this change increases SPTPS datagram
overhead by 6 bytes (the size of the source ID itself).

Change vpn_packet_t::seqno from uint32_t to uint8_t[4].

This is to make sure on-wire vpn_packet_t fields are always 1-byte
aligned, otherwise padding could get in the way.

Introduce node IDs.

This introduces a new type of identifier for nodes, which complements
node names: node IDs. Node IDs are defined as the first 6 bytes of the
SHA-256 hash of the node name. They will be used in future code in lieu
of node names as unique node identifiers in contexts where space is at
a premium (such as VPN packets).

The semantics of node IDs is that they are supposed to be unique in a
tinc graph; i.e. two different nodes that are part of the same graph
should not have the same ID, otherwise things could break. This
solution provides this guarantee based on realistic probabilities:
indeed, according to the birthday problem, with a 48-bit hash, the
probability of at least one collision is 1e-13 with 10 nodes, 1e-11
with 100 nodes, 1e-9 with 1000 nodes and 1e-7 with 10000 nodes. Things
only start getting hairy with more than 1 million nodes, as the
probability gets over 0.2%.

Invalidate UDP information on address changes.

Currently, when tinc receives an UDP packet from an unexpected address
(i.e. an address different from the node's current address), it just
updates its internal UDP address record and carries on like nothing
happened.

This poses two problems:

 - It assumes that the PMTU for the new address is the same as the
   old address, which is risky. Packets might get dropped if the PMTU
   turns out to be smaller (or if UDP communication on the new address
   turns out to be impossible).

 - Because the source address in the UDP packet itself is not
   authenticated (i.e. it can be forged by an attacker), this
   introduces a potential vulnerability by which an attacker with
   control over one link can trick a tinc node into dumping its network
   traffic to an arbitrary IP address.

This commit fixes the issue by invalidating UDP/PMTU state for a node
when its UDP address changes. This will trigger a temporary fallback
to indirect communication until we get confirmation via PMTU discovery
that the node is indeed sitting at the other end of the new UDP address.

Fix protocol version check for type 2 MTU probe replies.

Currently tinc only uses type 2 MTU probe replies if the recipient uses
protocol version 17.3. It should of course support any higher minor
protocol version as well.

tinc-gui: Use /usr/bin/env to resolve path to python

Preemptively mirror REQ_PUBKEY messages from nodes with unknown keys.

In this commit, if a node receives a REQ_PUBKEY message from a node it
doesn't have the key for, it will send a REQ_PUBKEY message in return
*before* sending its own key.

The rationale is to prevent delays when establishing communication
between two nodes that see each other for the first time. These delays
are caused by the first SPTPS packet being dropped on the floor, as
shown in the following typical exchange:

node1: No Ed25519 key known for node2
REQ_PUBKEY ->
<- ANS_PUBKEY
node1: Learned Ed25519 public key from node2
REQ_SPTPS_START ->
node2: No Ed25519 key known for zyklos
<- REQ_PUBKEY
ANS_PUBKEY ->
node2: Learned Ed25519 public key from node1
-- 10-second delay --
node1: No key from node2 after 10 seconds, restarting SPTPS
REQ_SPTPS_START ->
<- SPTPS ->
node1: SPTPS key exchange with node2 succesful
node2: SPTPS key exchange with node1 succesful

With this patch, the following happens instead:

node1: No Ed25519 key known for node2
REQ_PUBKEY ->
node2: Preemptively requesting Ed25519 key for node1
<- REQ_PUBKEY
<- ANS_PUBKEY
ANS_PUBKEY ->
node2: Learned Ed25519 public key from node1
node1: Learned Ed25519 public key from node2
REQ_SPTPS_START ->
<- SPTPS ->
node1: SPTPS key exchange with node2 succesful
node2: SPTPS key exchange with node1 succesful

Fix default device path selection on BSD.

Currently, if DeviceType = tap but Mode = router, the default
device path is /dev/tun0, which is wrong. This commit fixes that.

Ignore the Interface option if device rename is impossible.

There are platforms on which it is impossible to rename the TUN/TAP
device. An example is Mac OS X (tuntapx). On these platforms,
specifying the Interface option will not rename the interface, but
the specified name will still be passed to tinc-up scripts and the
like, resulting in potential confusion for the user.

Fix default TAP device on Darwin.

On Darwin (tuntapx), the first TAP device is /dev/tap0, not /dev/tun0.

Fix wrong identifier in SO_NOSIGPIPE call.

f134bd0c9c2213fbbb3967f3d784759cb65e2c76 broke the Mac OS X build by
introducing a reference to an identifier, c, that doesn't exist.

Don't enable the device if the reachable count is zero.

A logic bug was introduced in bd451cfe1512fa69eac35a60dbe6df17bfc39154
in which running graph() several times with zero reachable nodes had
the effect of calling device_enable() (instead of keeping the device
disabled).

This results in weird behavior when DeviceStandby is enabled, especially
on Windows where calling device_enable() several times in a row corrupts
I/O structures for the device, rendering it unusable.

Fix undefined HOST_NAME_MAX on Windows.

The Windows build was broken by commit
826ad11e419db90b66b3f76a90b54df021bb39fc which introduced a dependency
on the HOST_NAME_MAX macro, which is not defined on Windows. According
to MSDN for gethostname(), the maximum length of the returned string
is 256 bytes (including the terminating null byte), so let's use that
as a fallback.

Remove Google from the list of copyright owners.

Google released copyright to me for my own contributions.

tincctl: Use replace_name to properly replace and validate input hostnames

utils: Refactor check_id out of protocol for global access

utils: Refactor get_name's functionality into util for global access

Clarify copyright ownership for code authored by Etienne Dechamps.

commandline.test: Adding test that fetching non-existing config setting really fails.

Fix exit code of "tinc get".

Successfully getting an existing variable ("tinc get name") should
not result in an error exitcode (1) from the tinc command.

This changes the result of test/commandline.test from FAIL to PASS.

Handle TAP-Win32 immediate reads correctly.

The handling of TAP-Win32 virtual network device reads that complete
immediately (ReadFile() returns TRUE) is incorrect - instead of
starting a new read, tinc will continue listening for the overlapped
read completion event which will never fire. As a result, tinc stops
receiving packets on the interface.

Only read from TAP-Win32 if the device is enabled.

With newer TAP-Win32 versions (such as the experimental
tap-windows6 9.21.0), tinc is unable to read from the virtual network
device:

    Error while reading from (null) {23810A13-BCA9-44CE-94C6-9AEDFBF85736}: No such file or directory

This is because these new drivers apparently don't accept reads when
the device is not in the connected state (media status).

This commit fixes the issue by making sure we start reading no sooner
than when the device is enabled, and that we stop reading when the
device is disabled. This also makes the behavior somewhat cleaner,
because it doesn't make much sense to read from a disabled device
anyway.

Add a non-interactive mode to tinc commands.

Some tinc commands, such as "tinc generate-keys", use the terminal to
ask the user for information. This can be bypassed by making sure
there is no terminal, which is trivial on *nix but might require
jumping through some hoops on Windows depending on how the command is
invoked.

This commit adds a --batch option that ensures tinc will never ask the
user for input, even if it is attached to a terminal.

Revert "Use git description as the tinc version."

This reverts commit e024b7a2c50e23311834e6d180e5acc72783b339. Automatic version
number generation needs a little bit more work to get it working correctly in
all cases.

Merge branch 'keysegfault' of https://github.com/dechamps/tinc into 1.1

Merge branch 'tincstart' of https://github.com/dechamps/tinc into 1.1

Merge branch 'ctrl' of https://github.com/dechamps/tinc into 1.1

Merge branch 'winwarnings' of https://github.com/dechamps/tinc into 1.1

Verify seqno early in sptps_verify_datagram().

This is a slight optimization for sptps_verify_datagram(), which might
come in handy since this function is called in a loop via try_harder().

It turns out that since sptps_verify_datagram() doesn't update any
state, it doesn't matter in which order verifications are done. However,
it does affect performance since it's much cheaper to check the seqno
than to try to decrypt the packet.

Since this function is called with the wrong node most of the time, it
makes verification vastly faster for the majority of calls because the
seqno will be wrong in most cases.

Add documentation about using system-assigned ports.

There are two caveats to be aware of which are documented in this
commit:

 - Because the system will likely assign different ports when binding
   several times to different address families, it is recommended to
   only use a single address family, otherwise other nodes will only
   get one port among the several that were assigned, possibly breaking
   communication.

 - AutoConnect won't work in this scenario, because it relies on the UDP
   port being the same as the TCP port, which is not the case when using
   system-assigned ports.

Improve subprocess behavior in tinc start command.

When invoking tincd, tinc start currently uses the execvp() function,
which doesn't behave well in a console as the console displays a new
prompt before the subprocess finishes (which makes me suspect the exit
value is not handled at all). This new code uses spawnvp() instead,
which seems like a better fit.

Fix "tinc start" on Windows when the path contains spaces.

When invoking "tinc start" with spaces in the path, the following
happens:

    > "c:\Program Files (x86)\tinc\tinc.exe" start
    c:\Program: unrecognized argument 'Files'
    Try `c:\Program --help' for more information.

This is caused by inconsistent handling of command line strings between
execvp() and the spawned process' CRT, as documented on MSDN:
http://msdn.microsoft.com/library/431x4c1w.aspx

Shutdown cleanly when receiving a Windows console shutdown request.

This commit makes tinc exit cleanly on Windows when hitting CTRL+C at
the console or when the user logs off. This change has no effect when
running tinc as a service.

Check if devops is valid before closing the device.

This fixes a segfault that occurs on exit if tinc fails before the
device is initialized (for example, if it fails to read the private
key).

Fix unsafe use of strncpy() and sprintf().

The strncpy() problem was found by cppcheck.

Fix a potential file descriptor leak.

Found by cppcheck.

Resolve KEY_EVENT conflict between Windows and ncurses.

This fixes the following compiler warning when building for Windows:

In file included from top.c:24:0:
/usr/local/mingw/ncurses/include/curses.h:1478:0: error: "KEY_EVENT" redefined [-Werror]
 #define KEY_EVENT 0633  /* We were interrupted by an event */
 ^
In file included from /usr/share/mingw-w64/include/windows.h:74:0,
                 from /usr/share/mingw-w64/include/winsock2.h:23,
                 from have.h:46,
                 from system.h:26,
                 from top.c:20:
/usr/share/mingw-w64/include/wincon.h:101:0: note: this is the location of the previous definition
 #define KEY_EVENT 0x1
 ^

Remove unused device stats variables.

This removes a bunch of variables that are never actually used anywhere.

This fixes the following compiler warning when building for Windows:

mingw/device.c:46:17: error: ‘device_total_in’ defined but not used [-Werror=unused-variable]
 static uint64_t device_total_in = 0;
                  ^

Remove unused variable in TAP-Win32 setup_device().

This fixes the following compiler warning when building for Windows:

mingw/device.c: In function ‘setup_device’:
mingw/device.c:92:9: error: unused variable ‘thread’ [-Werror=unused-variable]
  HANDLE thread;
           ^

Fix callback signature for TAP-Win32 device_handle_read().

This fixes the following compiler warning when building for Windows:

mingw/device.c: In function ‘setup_device’:
mingw/device.c:186:2: error: passing argument 2 of ‘io_add_event’ from incompatible pointer type [-Werror]
  io_add_event(&device_read_io, device_handle_read, NULL, CreateEvent(NULL, TRUE, FALSE, NULL));
  ^
In file included from mingw/../net.h:27:0,
                 from mingw/../subnet.h:24,
                 from mingw/../conf.h:34,
                 from mingw/device.c:26:
mingw/../event.h:61:13: note: expected ‘io_cb_t’ but argument is of type ‘void (*)(void *)’
 extern void io_add_event(io_t *io, io_cb_t cb, void* data, WSAEVENT event);

Remove an unnecessary pointer dereference in execute_script().

This fixes the following compiler warning when building for Windows:

script.c: In function ‘execute_script’:
script.c:52:5: error: value computed is not used [-Werror=unused-value]
     *q++;
          ^

Only declare the origpriority variable if we support priority.

This fixes the following compiler warning when building for Windows:

net_packet.c: In function ‘send_udppacket’:
net_packet.c:633:6: error: unused variable ‘origpriority’ [-Werror=unused-variable]
  int origpriority = origpkt->priority;
        ^

Reserve legacy active bit in connection_status_t.

This is so the positions of the other bits don't change, making it easier to
debug problems with different versions of tinc.

Also fix the padding so connection_status_t is exactly 32 bits.

Remove redundant connection_t::status.active field.

The only places where connection_t::status.active is modified is in
ack_h() and terminate_connection(). In both cases, connection_t::edge
is added and removed at the same time, and that's the only places
connection_t::edge is set. Therefore, the following is true at all
times:

    !c->status.active == !c->edge

This commit removes the redundant state information by getting rid of
connection_t::status.active, and using connection_t::edge instead.

Don't initialize outpkt to an unused value.

in receive_udppacket(), we initialize outpkt to a default value but the
value is never read anywhere, as every read is preceded by a write.

This issue was found by the clang static analyzer tool:
http://clang-analyzer.llvm.org/

Handle the "no local address" case in send_sptps_data().

If choose_local_address() is unable to find a local address (e.g.
because of old nodes that don't send their local address information),
then send_sptps_data() ends up using uninitialized variables for the
socket and address.

This regression was introduced in
415910897122da0073a862784d148802ca390020. The commit took care of
handling that case in send_udppacket() but was missing the same fix
for send_sptps_data().

This bug was found by the clang static analyzer tool:
http://clang-analyzer.llvm.org/

Fix incorrect format qualifiers.

Based on a patch from Etienne Dechamps. We avoid the use of %hhx, since even
though it is C99, not all compilers support it yet. We use %x instead, since
it's guaranteed that the minimum size of function arguments on the stack or in
registers is that of an int.

Fix a typo (FORTIFY_SOURCE).

Fix typos in the manual page

Fix segmentation fault when dumping subnets.

Fix compiler warnings.

Fix event loop io tree inconsistency on Windows.

On Windows, the event loop io tree uses the Windows Event handle to
differentiate between io_t objects. Unfortunately, there is a bug in
the io_add_event() function (introduced in
2f9a1d4ab5ff51b05a5e8cc41a1528fdeb36c723) as it sets the event after
inserting the object into the tree, resulting in objects appearing in
io_tree out of order.

This can lead to crashes on Windows as the event loop is unable to
determine which events fired.

Make sure myport is set correctly when running with Port = 0.

Setting the Port configuration variable to zero can be used to make tinc
listen on a system-assigned port. Unfortunately, in this scenario myport
will be zero, which means that tinc won't transmit its actual UDP
listening port to other nodes. This breaks UDP hole punching and local
discovery.

Fix tinc event loop reentrancy from timeout handlers.

Commit 611217c96ec684799882cf330f40a0936131b6b5 introduced a regression
because it accidentally reordered the timeout handler calls and the
fdset setup code. This means that any io_add(), io_del() or io_set()
calls in timeout handlers would be ignored in the current event loop
iteration, resulting in erratic behavior.

The most visible symptom is when a metaconnection timeout occurs and the
connection is closed; the timeout handler closes the socket but it still
ends up in the select() call, typically resulting in the following
crash:

    Error while waiting for input: Bad file descriptor

Canonicalize IPv6 addresses as per RFC 5952 before printing them.

Currently we don't do any shortening on IPv6 addresses (aside from
removing trailing zeroes) before printing them. This commit makes
textual addresses smaller by shortening them according to the rules
described in RFC 5952. This is also the canonical textual representation
for IPv6 addresses, thus making them easier to compare.

Don't print subnet prefix lengths and weights for one-host subnets.

This commit suppresses subnet prefix length output (/xx) for subnets
that only contain one address (/32 for IPv4, /128 for IPv6). It also
suppresses weight information if the subnet is using the default
weight. This improves readability of net2str() output in the majority
of cases.

When printing MAC addresses, always use trailing zeroes.

tinc currently prints MAC addresses without trailing zeroes, for example:

    1:2:3:4:5:6

This looks weird and is inconsistent with how MAC addresses are
displayed everywhere else. This commit adds trailing zeroes, so the
above address will be printed as the following:

    01:02:03:04:05:06

Rewrite, fix and improve str2net().

This is a complete rewrite of the str2net() function. Besides
refactoring duplicate code, this new code brings the following fixes
and improvements:

 - Fixes handling of leading/trailing double colon in IPv6 addresses.
   For example, with the previous code the address
   2001:0db8:85a3:0000:0000:8a2e:0370:: is interpreted as a MAC address,
   and ::0db8:85a3:0000:0000:8a2e:0370:7334 is rejected.

 - Catches more invalid cases, such as garbage at the end of the string.

 - Adds support for dotted quad notation in IPv6 (e.g. ::1.2.3.4).

See RFC 4291, section 2.2 for details on the textual format of IPv6
addresses.

Use git description as the tinc version.

Instead of using a hardcoded version number in configure.ac, this makes
tinc use the live version reported by "git describe", queried on-the-fly
during the build process and regenerated for every build.

This provides several advantages:
 - Less redundancy: git is now the source of truth for version
   information, no need to store it in the repository itself.
 - Simpler release process: just creating a git tag automatically
   updates the version. No need to change files.
 - More useful version information: tinc will now display the number of
   commits since the last tag as well as the commit the binary is built
   from, following the format described in git-describe(1).

Here's an example of tincd --version output:

  tinc version release-1.1pre10-48-gc149315 (built Jun 29 2014 15:21:10, protocol 17.3)

When building directly from a release tag, this would like the following:

  tinc version release-1.1pre10 (built Jun 29 2014 15:21:10, protocol 17.3)

(Note that the format is slightly different - because of the way the
tags are named, it says "release-1.1pre10" instead of just "1.1pre10")

Regenerate build date and time every time tinc is built.

This prevents the date and time shown in version information from
getting stale because of partial builds. With these changes, date and
time information is written to a dedicated object file that gets rebuilt
every time make is run, even if there are no changes.

Make IPv4 multicast space 224.0.0.0/4 broadcast by default.

We already do this for IPv6 multicast space (ff00::/8), so why not
extend it to IPv4.

Make broadcast addresses configurable.

This adds a new option, BroadcastSubnet, that allows the user to
declare broadcast subnets, i.e. subnets which are considered broadcast
addresses by the tinc routing layer. Previously only the global IPv4
and IPv6 broadcast addresses were supported by virtue of being
hardcoded.

This is useful when using tinc in router mode with Ethernet virtual
devices, as it can be used to provide broadcast support for a local
broadcast address (e.g. 10.42.255.255) instead of just the global
address (255.255.255.255).

This is implemented by removing hardcoded broadcast addresses and
introducing "broadcast subnets", which are subnets with a NULL owner.
By default, behavior is unchanged; this is accomplished by adding
the global broadcast addresses for Ethernet, IPv4 and IPv6 at start
time.

Implement sptps_verify_datagram().

Implementation of sptps_verify_datagram() was left as a TODO. This
causes problems when using SPTPS in tinc, because this function is
used in try_mac(), which itself is used in try_harder() to locate
nodes sending UDP packets from unexpected addresses. In the current
state this function always returns true, resulting in UDP addresses
of random nodes getting changed which makes UDP communication
fragile and unreliable. In addition, this makes UDP communication
impossible through port translation and local discovery.

This commit adds the missing implementation, thus fixing the issue.

Enable LocalDiscovery by default.

Recent improvements to the local discovery mechanism makes it cheaper,
more network-friendly, and now it cannot make things worse (as opposed
to the old mechanism). Thus there is no reason not to enable it by
default.

Remove broadcast-based local discovery mechanism.

The new local address based local discovery mechanism is technically
superior to the old broadcast-based one. In fact, the old algorithm
can technically make things worse by e.g. sending broadcasts over the
VPN itself and then selecting the VPN address as the node's UDP
address. This cannot happen with the new mechanism.

Note that this means old nodes that don't send their local addresses in
ADD_EDGE messages can't be discovered, because there is no address to
send discovery packets to. Old nodes can still discover new nodes by
sending them broadcasts, though.

Use edge local addresses for local discovery.

This introduces a new way of doing local discovery: when tinc has
local address information for the recipient node, it will send local
discovery packets directly to the local address of that node, instead
of using broadcast packets.

This new way of doing local discovery provides numerous advantages compared to
using broadcasts:

 - No broadcast packets "polluting" the local network;

 - Reliable even if the sending host has multiple network interfaces (in
   contrast, broadcasts will only be sent through one unpredictable
   interface)

 - Works even if the two hosts are not on the same broadcast domain. One
   example is a large LAN where the two hosts might be on different local
   subnets. In fact, thanks to UDP hole punching this might even work if
   there is a NAT sitting in the middle of the LAN between the two nodes!

 - Sometimes a node is reachable through its "normal" address, and via a
   local subnet as well. One might think the local subnet is the best route
   to the node in this case, but more often than not it's actually worse -
   one example is where the local segment is a third party VPN running in
   parallel, or ironically it can be the local segment formed by the tinc
   VPN itself! Because this new algorithm only checks the addresses for
   which an edge is already established, it is less likely to fall into
   these traps.

Add local address information to edges.

In addition to the remote address, each edge now stores the local address from
the point of view of the "from" node. This information is then made available
to other nodes through a backwards-compatible extension to ADD_EDGE messages.

This information can be used in future code to improve packet routing.

Give getsockopt() a reference to a socklen_t.

Merge branch 'winevents-clean' of https://github.com/dechamps/tinc into 1.1

Remove the TAP-Win32 reader thread.

tinc is using a separate thread to read from the TAP device on Windows.
The rationale was that the notification mechanism for packets arriving
on the virtual network device is based on Win32 events, and the event
loop did not support listening to these events.

Thanks to recent improvements, this event loop limitation has been
lifted. Therefore we can get rid of the separate thread and simply add
the Win32 "incoming packet" event to the event loop, just like a socket.
The result is cleaner code that's easier to reason about.

Use a Windows event to stop tinc when running as a service.

Currently, when the tinc service handler callback (which runs in a
separate thread) receives a service shutdown request, it calls
event_exit() to request the event loop to exit.

This approach has a few issues:

 - The event loop will only notice the exit request when the next event
   fires. This slows down tinc service shutdown. In some extreme cases
   (DeviceStandby enabled, long PingTimeout and no connections),
   shutdown can take ages.

 - Strictly speaking, because of the absence of memory barriers, there
   is no guarantee that the event loop will even notice an exit request
   coming from another thread. I suppose marking the "running" variable
   as "volatile" is supposed to alleviate that, but it's unclear whether
   that provides any guarantees with modern systems and compilers.

This commit fixes the issue by leveraging the new event loop Windows
interface, using a custom Windows event that is manually set when
shutdown is requested.

Make the event loop expose a Windows event interface.

This allows event loop users to specify Win32 events to wait on,
thus making the event loop more flexible.

Use native Windows events for the event loop.

This commit changes the event loop to use WSAEventSelect() and
WSAWaitForMultipleEvents() on Windows. This paves the way for making the
event loop more flexible on Windows by introducing the required
infrastructure to make the event loop wait on any Win32 event.

This commit only affects the internal implementation of the event
module. Externally visible behavior remains strictly unchanged (for
now).

Fix connection event error handling.

Commit 86a99c6b999671ed444711139db1937617e802a0 changed the way we
handle connection events to protect against spurious event loop
callbacks. Unfortunately, it turns out that calling connect() twice on
the same socket results in different behaviors depending on the platform
(even though it seems well defined in POSIX). On Windows this resulted
in the connection handling code being unable to react to connection
errors (such as connection refused), always hitting the timeout; on
Linux this resulted in spurious error messages about connect() returning
success.

In POSIX and on Linux, using connect() on a socket where the previous
attempt failed will attempt to connect again, resulting in unnecessary
network activity. Using getsockopt(SO_ERROR) before connect() solves
that, but introduces a race condition if a connection failure happens
between the two calls.

For this reason, this commit switches from connect() to a zero-sized
send() call, which is more consistent (though not completely, see the
truth table in the comments) and simpler to use for that purpose. Note
that Windows explictly support empty send() calls; POSIX says nothing
on the subject, but testing shows it works at least on Linux.

(Surprisingly enough, Windows seems more POSIX-compliant than Linux on
this one!)

Protect against spurious connection events.

The event loop does not guarantee that spurious write I/O events do not
happen; in fact, they are guaranteed to happen on Windows when
event_flush_output() is called. Because handle_meta_io() does not check
for spurious events, a metaconnection socket might appear connected even
though it's not, and will fail immediately when sending the ID request.

This commit fixes this issue by making handle_meta_io() check the
connection status before assuming the socket is connected. It seems that
the only reliable way to do that is to try to call connect() again and
look at the error code, which will be EISCONN if the socket is
connected, or EALREADY if it's not.

Fix errno references when handling socket errors.

When using socket functions, "sockerrno" is supposed to be used to
retrieve the error code as opposed to "errno", so that it is translated
to the correct call on Windows (WSAGetLastError() - Windows does not
update errno on socket errors). Unfortunately, the use of sockerrno is
inconsistent throughout the tinc codebase, as errno is often used
incorrectly on socket-related calls.

This commit fixes these oversights, which improves socket error
handling on Windows.

Fix Windows includes.

These Windows include lines are capitalized, which causes the build to fail
when cross-compiling from Linux to Windows using MinGW as the MinGW headers
are entirely lower case.

Remove the warnings when IP_DONTFRAGMENT/IPV6-DONTFRAG is not supported.

There is nothing we can do about it, and tinc will run fine anyway.

Add support to link against libresolv Mac OS X

reload /etc/resolv.conf in SIGALRM handler

Make DeviceStandby control network interface link status on Windows.

Besides controlling when tinc-up and tinc-down get called, this commit makes
DeviceStandby control when the virtual network interface "cable" is "plugged"
on Windows. This is more user-friendly as the status of the tinc network can
be seen just by looking at the state of the network interface, and it makes
Windows behave better when isolated.

Add DeviceStandby option to only enable the device when nodes are reachable.

This adds a new DeviceStandby option; when it is disabled (the default),
behavior is unchanged. If it is enabled, tinc-up will not be called during
tinc initialization, but will instead be deferred until the first node is
reachable, and it will be closed as soon as no nodes are reachable.

This is useful because it means the device won't be set up until we are fairly
sure there is something listening on the other side. This is more user-friendly,
as one can check on the status of the tinc network connection just by checking
the status of the network interface. Besides, it prevents the OS from thinking
it is connected to some network when it is in fact completely isolated.

Cleanly remove the device FD from the event loop before closing it.

Make device close cleaner.

Move Solaris if_fd to local scope.

This variable is never used outside of setup_device(), therefore there is no
reason to declare it in global scope.

Clarify man page regarding the IndirectData option

Unconditionally return non-zero exit code when "tinc del" does not find the requested variable.

Return non-zero exit code when "tinc get" does not find the requested variable.

Fix base64 decoding of Ed25519 keys.

Allow Cipher and Digest "none".

This is for backwards compatibility with tinc 1.0, it has no effect on
the SPTPS protocol.

Implement a PEM-like format for Ed25519 keys.

We don't require compatibility with any other software, but we do want Ed25519 keys to work
the same as RSA keys for now.

Rename ECDSA to Ed25519.

Add sanity checks when generating new RSA keys.

The key size should be a multiple of 8 bits, and it should be between 1024 and
8192 bits.