Feature external ip address

* Basic external_ip_address support

* Added support for port parsing for external IP address

* Cleanup some logging

Added monitor & external commands to the groupchat example

Never automatically try to bind to ports >= 32768.

RFC 6335 says operating systems should use ports 49152-65535 for
ephemeral ports. However, Linux and several other operating systems use
32768-65535 by default. Make sure we don't bind in that range, as a
single outgoing TCP connection that uses the same port for the local end
as MeshLink wants to use for the listening port can cause problems.

Add a test for the discovery algorithm.

Create two nodes and link them, then change their ports and check if
they can still find each other.

Add a test for changing ports and handling of port conflicts.

Check send buffer instead of receive buffer size when calling channel_poll().

Add a callback that notifies when the MeshLink thread starts and stops.

This callback is called from within the MeshLink thread, right after it
starts and right before it stops.

Account for SPTPS overhead.

Add missing metering testcases.

Add extra metering scenarios.

Add a metering test.

This checks bandwidth usage for several minutes while doing PMTU probing,
being idle, and transferring data over a channel via a relay.

Improved node traffic counters.

Drop counters for packets, keep byte counters. But distinguish between
application data (channel traffic) and meta-data (including UDP probes).
Also track how much data we forward for other nodes.

The counters can be read by devtool_get_node_status(), and a new function
devtool_reset_node_counters() has been added that will zero the counters.

Add meshlink_get_node_tiny().

This allows querying if a node is connected using the tiny MeshLink
version.

Handle raw packets from tiny peers.

Tiny peers don't support UTCP channels, but send raw packets directly over
the meta connection.

Handle connections from nodes using MeshLink-tiny.

Add a new flags field to the ID request. Currently this is only set by tiny
nodes. If we see the peer set it, don't send our edges to the peer, and
don't forward any information from other nodes.

Use multicast to respond to mDNS requests.

On macOS, it seems unicast responses are not received if another process
is also listening on the same port. Try to use multicast for response
packets instead, if we can discovery the interface of the incoming
request.

Silence warnings about printing function pointers.

Cast function pointers first to intptr_t, then to void *. This silences
a warning from GCC that we are not actually allowed to print function
pointers using %p, which is not an issue on the platforms we support.

Ignore ADD_EDGE messages we know are outdated.

A node reconnecting after a network error might send outdated ADD_EDGE
messages. If we see this for an edge we own, we send back a correction.
However, if we don't own the edge but we are one of the edges endpoints,
we ignore it and let the other side, which is the owner, take care of
sending a correction.

This change avoids us from incorrectly learning an old session ID for a
node, which might cause channels to that node to be closed prematurely.

Add log messages for all API entry points with effects.

At MESHLINK_DEBUG level, log all API entry points except the
meshlink_get_*() functions.

Log the amount of metadata received at DEBUG level.

Improve logging of connection attemps.

Ensure all causes for a connection to be activated or terminated are
logged at INFO level or higher. But remove the "Closing connection with"
message for connections that were never activated.

Fix potential incorrect destruction of channels.

utcp_abort_all_connections() was called when a node is blacklisted or a
a node reconnects with a different session ID. In both cases, all active
channels should be closed. However, utcp_abort_all_connections() also freed
the UTCP connection object, which would cause a double free when the
application freed the corresponding meshlink_channel object.

Rename utcp_abort_all_connections() to utcp_reset_all_connections(), and
have it not invalidate any handles.

Fix uninitialized data being passed to sendmsg().

Found by Valgrind.

Fix several memory leaks.

Found by the AddressSanitizer.

Clear send and receive buffers before channel close/error callbacks.

When there is an error that would cause the poll callback to be called
with length zero, make sure we drop the buffers first, so that calls to
meshlink_channel_get_sendq() will also return zero. This allows poll
callbacks that wait for the send buffer to be emptied to work correctly.

Add back the AC_PROG_CC_C99 check.

This macro is deprecated in 2.70 and will cause a warning to be
generated, but it is still necessary when using autoconf 2.69 in
combination with a compiler that does not enable C99 features by
default.

Add a test case for meshlink_channel_abort() in combination with AIO.

Ensure aux field is initialized in RST packets.

The aux field was left uninitialized. This didn't cause any harm, but
was caught by valgrind.

Add meshlink_channel_abort().

This is similar to meshlink_channel_close(), but resets the UTCP channel
instead of doing a normal FIN shutdown. It will also drop the send and
receive buffers.

Fix a potential segmentation fault when log level is set to DEBUG.

Increase DNS resolution timeout during join to 30 seconds

Fix a compile error on macOS when using an older version of autoconf.

With autoconf 2.69, the USE_SYSTEM_EXTENSIONS macro did not enable
_DARWIN_C_SOURCE, which could cause a compile error. This is fixed in
autoconf 2.71, but in order to provide some backwards compatibility, we
manually enable _DARWIN_C_SOURCE for now.

Fix a compiler warning.

Fix compiler warnings about comparing signed and unsigned sizes.

Move noinst_PROGRAMS to EXTRA_PROGRAMS.

The main product is the library, example programs should not be built by
default. Move them to EXTRA_PROGRAMS so they can still be built with a
manual make command.

Also add framework options when $host_os contains ios.

Use SCNetworkReachability on macOS and iOS to detect network changes.

Unfortunately, using SCDynamicStore*() functions to monitor network changes
is not supported in iOS. Instead, we now use SCNetworkReachability*()
functions which are supported on both macOS and iOS.

Fix a compiler warning.

Clang doesn't like trailing commas in enums when compiling C++ code if no
-std= flag is passed.

Fix warnings from autoconf 2.71.

This fixes the use of deprecated functions. Also bump the minimum required
version of autoconf to 2.69.

Check if SO_REUSEPORT is defined before using it.

Remove the catta submodule.

Add meshlink_hint_network_change().

This is intended to be used when there is no way for MeshLink to get
notifications of local network changes. It forces MeshLink to scan all
network interfaces for changes in up/down status and new/removed addresses,
and will immediately check if all connections to other nodes are still
alive.

Handle network change detection on macOS and iOS.

Apple has no usable PFROUTE sockets anymore, instead network change
detection should be done via SystemConfiguration callbacks. However,
actually parsing the messages is very annoying in C, so we only use it to
get notified of changes, we use getifaddrs() to get the actual list of
network interfaces and addresses.

The only issue is that interface up/down state changes do not result in a
notification, only interface and address addition/removal.

Improved mDNS compliance.

Split the mDNS packets into separate request and response packets, and only
send responses when we receive a valid request.

It's now possible to find local MeshLink nodes using tools like dns-sd and
avahi-browse, if told to explicitly search for the _appname._tcp service.

Set SO_REUSEPORT on the multicast sockets.

On Linux this doesn't make any difference, but on macOS this is required
if any other process has already opened an mDNS multicast socket locally,
otherwise bind() will fail.

Add local discovery support for macOS.

This implements the pfroute counterpart to Linux's netlink interface.
Pfroute doesn't allow easy querying the current interfaces and addresses,
so we use getifaddrs() for that.

Fix outgoing connection attempts after local discovery.

We were trying the wrong port due to a forgotten byteswap. Also, if no
address was known at all for a node, there might be an outgoing structure
for it that would never be retried.

Remove debug messages.

When receiving an mDNS request, send a unicast response back.

Group discovery related variables together.

Resend mDNS packets on all known addresses if meshlink_reset_timers() is called.

Ensure we compile discovery.c unconditionally.

Don't link with Catta anymore.

Send and receive multicast mDNS packets.

We don't actually support the full mDNS spec, we just send something that
passes for a valid mDNS packet, and expect other nodes to send packets back
with exactly the same format. All other mDNS packets will be ignored.

Keep track of interfaces and local addresses.

Parse Netlink NEW/DELLINK and NEW/DELADDR messages.

Parse link and address information. Also send GETLINK and GETADDR
messages to the Netlink socket, so we get the current state of the
interfaces and addresses.

Monitor a Netlink socket on Linux.

Monitor a PFROUTE socket on *BSD and macOS.

Catta is not handling network changes correctly on *BSD and macOS. In
particular, after the initial startup, interfaces that go up and down
do not cause a callback to be generated, so MeshLink is not notified of
the changes.

To ensure MeshLink responds rapidly to network changes on these
platforms, we open a PFROUTE socket and monitor it ourself. We only
check the message type, and don't track exactly what addresses get added
or removed.

Fix buffer shrinking logic in UTCP.

Don't set the maximum size to low values; keep it at the minimum of the
previous size or of the default maximum size. If it is set to something
smaller than one MTU, this would prevent receiving packets from the
peer, and channel traffic would not progress and not close properly.

We also don't move memory when shrinking the internal buffer, so we
should keep the size large enough so the last byte in the buffer is
covered when the offset is non-zero.

Reduce UTCP memory usage.

Don't allocate a send buffer by default, since an application might only
want to receive data. Also try to shrink the send and receive buffers on
channel close, or even free them if the buffers are empty.

Fix compilation error on macOS.

For some reason, macOS doesn't define asprintf() if you #define both
_GNU_SOURCE and _POSIX_C_SOURCE but no other feature macros.

Make sure we #define _POSIX_C_SOURCE.

Some functions, such as clock_gettime(), officially require _POSIX_C_SOURCE
to be set to a minimum version in order to be usable.

Ensure we don't use external buffers after a channel is closed.

Fix a memory leak.

Add missing #include in test/utils.h.

Fix potential channel buffer corruption when using an application-provided buffer.

If data was still in MeshLink's internal buffer in a wrapped state, and
the application called meshlink_set_channel_*buf_storage(), the wrong
amount of data was copied into the new buffer.

Allow sending up to 16 MiB in one go over a UDP channel.

The application should set the channel send and receive buffers to be
able to hold the largest packet it expects to transmit and receive.

Allow a different location for the lock file.

In order to reduce the write load on the configuration directory as much as
possible, allow the location of the lock file to be set by the application
to somewhere outside the configuration directory. On Linux, it can be put
in /dev/shm.

Add missing config file update on receiving a proactive REQ_KEY request.

A REQ_KEY request from a node that wants our key can contain their key as
well. The node status was not set to dirty in this case, which could
prevent their key from being written to disk with the default settings, but
this actually always forgot to write the key to disk with storage policy
set to KEYS_ONLY.

Immediately write host config file when a new key is received.

When we receive a new public key, we should immediately call
node_write_config() to ensure it gets saved if the storage policy is
KEYS_ONLY.

Expand the storage policy test to check for correctness during invitations.

Don't allow meshlink_join() when the storage policy is DISABLED.

It does not make sense to allow this, since we need to write host config
files during a join, otherwise MeshLink's directory would be left in an
invalid state.

Add a test for the various storage policies.

Don't clear node dirty flag in meshlink_stop().

It's node_write_config() itself that should unset the dirty flag, depending
on the storage policy and if storage succeeded. Otherwise, we risk that
setting the storage policy back to ENABLED after calling meshlink_stop()
will not cause pending updates to be written out by meshlink_close().

Add meshlink_set_storage_policy().

This allows control over when MeshLink stores configuration files:

- MESHLINK_STORAGE_ENABLED: on all updates
- MESHLINK_STORAGE_KEYS_ONLY: only on new keys and black/whitelist updates
- MESHLINK_STORAGE_DISABLED: never

Allow the application to provide channel send/receive buffers.

This adds two new functions to allow the application to allocate send
and/or receive buffers for channels:

meshlink_set_channel_rcvbuf_storage(mesh, channel, buf, size)
meshlink_set_channel_sndbuf_storage(mesh, channel, buf, size)

Add meshlink_set_channel_flags().

This allows changing some of the flags of a channel. Currently it can be
used to change MESHLINK_CHANNEL_NO_PARTIAL and MESHLINK_CHANNEL_DROP_LATE.

Add missing checks for NULL mesh pointers in the public API.

Add warning messages when checking for bad fds after select() returns an error.

Never call timeout_set() outside callbacks if no callback is set.

We should never try to update a timer if it was never added to the event
loop. There were a few places that didn't have an explicit check to
prevent this from happening.

Try to recover from select() returning an error.

If we get an error back from select(), it could be because one of the
filedescriptors is in a bad state. This shouldn't occur, but if it does,
just call all the registered I/O callbacks to have them check for errors.
Only quit the event loop if the error persists.

Also fix some I/O callbacks that didn't expect to be called when the
filedescriptor isn't signalled.

Fix a socket fd leak.

Due to a logic error, whenever an interface went down and up, one or
more socket fds could be leaked. A long running process on a roaming
device or an unstable network could therefore run out of fds.

Check the return value of catta_simple_poll_get().

This ensures we gracefully handle the case of Catta not being able to bind
to the NETLINK_ROUTE socket.

Use AI_* instead of NI_* constants for getaddrinfo().

Send our canonical address to nodes we want to communicate with.

This ensures canonical addresses are propagated automatically, and can be
used when making meta and UDP connections.

Clean up the request jump table.

Use C99 designated array initializers to ensure the jump table and list of
request names is kept in sync with the enums.

Use the canonical address during UDP probes.

It is possible that a node has a canonical address, but due to NAT or other
reasons, the meta-connections with that node use other addresses. If UDP is
only possible to the canonical address, then we need to include that during
the initial UDP probing phase.

Add missing calls to init_sync_flag() in test cases.

Fix deleting configuration directories with hidden files.

We incorrectly skipped files starting with a dot when deleting directories.
This is a problem on macOS, which might add .DS_Store files.

Fix potential NULL pointer dereference.

It is possible that an attempt is made to forward a request to a node
that is not reachable via meta-connections. This would trigger an assert
in debug builds, or cause a segmentation fault in release builds. Add
checks before attempts to send a request to node->nexthop->connection.

Don't try to renew SPTPS keys for unreachable nodes.

This caused other functions that incorrectly used status.validkey to check
if they could send data to a node to pass a NULL pointer to send_request(),
causing a crash about an hour after a node went offline.

Only reset UDP SPTPS sessions if the session ID changed.

Previously we reset the SPTPS session if we detected if a node was
unreachable. However, that node might not think it was unreachable,
leading to only one side to reset the SPTPS connection. This would then
take some time to resolve itself.

We already had code to detect whether a node was restarted, so we use
that to detect if, once a node becomes reachable again, it remembers the
old SPTPS session or whether we have to start a new one. This should be
deterministic and not depend on the exact timing of events.

Also send the blacklist notification when we already have a connection.

Instead of just closing the connection, and having to wait for the
reconnection to happen to send the blacklist notification, we do it
immediately when meshlink_blacklist() is called.

Add a callback that notifies the application when it is blacklisted.

If an outgoing connection is made to a node that blacklists the local node,
a callback can now be set that informs the application of it.

Fix Doxygen errors.

Add API functions to query the blacklist status of nodes.

Check blacklist status before committing an invitation.

Although we delete invitation files when blacklisting a node, there is a
race condition where an invitation connection is created right before the
invitee is blacklisted. So check that the node is blacklisted right before
committing the node config file to disk.

Remove invitation files when blacklisting or forgetting a node.

When a new connection is activated, terminate any pending connections to the same peer.

This prevents issues mainly in the test suite where peers try to connect to
each other simultaneously, and have to terminate one of the connections.
Before both connections would succeed, and both would be terminated, leading
to a loop of reconnections until enough randomness got in to break the tie.

Don't reset the UDP SPTPS session when a node becomes reachable.

Only do this when it becomes unreachable. This fixes an issue where right
after a meta-connection is established, the initiator sends a proactive
REQ_KEY, before the peer really becomes reachable according to the graph.
When the latter happened, it would reset the session so far, causing a new
REQ_KEY to be sent, which could cross the ANS_KEY from the peer. This would
resolve itself after a few seconds, but causes an unnecessary delay that is
easy to trigger.