Fix a potential NULL-pointer dereference when generating invitations.

Closes #47 on GitHub.

Use getsockname() to get a listening sockets actual address in meshlink_stop().

This should be better than sending a packet to the listening address,
which might be a link-local address for which a valid scope-id is
necessary, and which might not be in listen_socket.sa.

Ensure -export-symbols-regex is not lost.

An earlier commit accidentily caused libmeshlink_la_LDFLAGS to be
overwritten later in src/Makefile.am, and this caused
-export-symbols-regex to be dropped, thereby exposing internal symbols
of the library.

Enable Catta by default, as documented.

Try to be smarter generating invitation URLs.

If we have a symbol hostname associated with us, use that. Otherwise, try
to find out which external addresses we have for both IPv4 and IPv6. If we
cannot connect to www.meshlink.io, then use the local address used for
outgoing connections as a fallback. Also, don't forget to add a port number
in all cases.

The generated invitation URL can now contain two addresses in the hostname
part, separated by a comma.

Allow multiple addresses in an invitation URL.

This allows the address field in an invitation URL to be a
comma-separated list. The goal is to allow both IPv4 and IPv6 addresses
to be encoded in a single URL.

This commit also ensures that if a hostname is given, that all address
records associated with that hostname are tried.

Fix all compiler warnings found using -Wall -W -pedantic.

Using both GCC 8 and Clang 7.

Check the return value of check_port().

When initializing a new MeshLink instance, fail if there is no port
available for listening. When starting an already configured instance,
if no Port statement is found in the local node's host config file,
select and add a new one.

Only set -fno-strict-overflow if -fwrapv is not available.

When -fwrapv is set, -fno-strict-overflow has no effect. Clang then
decides to give an obnoxious warning.

Use AX_PTHREAD to set the proper pthread flags.

Don't use SOL_IP and SOL_IPV6.

These macros do not exist on all platforms, instead one should use
IPPROTO_IP and IPPROTO_IPV6. This fixes a bug on macOS where the
IPV6_V6ONLY flag would not be applied and could result in IPv4 sockets
not working.

devtools.h must not rely on internal types.

Properly initialize mesh->outpacketqueue.

Add a devtool function to query the status of a given node.

Remove PROXY_EXEC support.

This calls fork(), which is not desirable from a library.

Ensure make distcheck runs without errors.

Remove unused/obsolete checks from configure.ac and unused functions from dropin.c.

Format the examples and test suite.

Update astylerc and reformat the code.

Changes:

- Add braces to one-line if/else statements.
- Add empty lines around control blocks.
- Indent multi-line #defines with tabs.

Fix compiling with -Wall -W.

Add an --enable-install-tests option to configure.

This will enable the installation of the test binaries when running
make install. This feature is intended to make continuous integration
easier.

Automatically configure and compile catta.

Really bind to a free port if the configured port is not available.

Make member variables in public structs more const.

Check that autoconnect works as expected.

Move meshlink_get_all_edges_state() to devtools_get_all_edges().

There should be no reason for the application to query the list of edges,
so move this functionality to devtools.[ch].

Also, flatten the array to reduce the amount of memory allocations and
bookkeeping necessary.

Fix errors found by Clang's static analyzer.

Fix compiler warnings.

Force -Wall.

AM_INIT_AUTOMAKE should ensure -Wall is set, but for some reason it doesn't.
Force it by adding it to AM_CPPFLAGS.

Remove unused/duplicate autoconf/automake definitions.

Get rid of ->hostname.

This takes up memory and is only used for logging.

Remember recently used addresses of other nodes.

Only keep at most 5 Address hints.

Close meta-connections in meshlink_stop().

If we stop MeshLink for an extended time, we don't want to have open
sockets lying around that we don't take care of. Terminate all of them.

Add a test for a constellation of three nodes.

In particular, test whether two nodes that have been introduced to each
other via a third node can still continue to communicate with each other
when the third node goes offline.

Don't install the example programs.

Don't build SPTPS test programs.

Test cornercases of MeshLink channels.

- Ensure we can open a channel before starting MeshLink.
- Check that opening channels to a peer that has unregistered its accept
  callback will not result in the poll callback to be called with a non-
  zero length.

Add utility functions to create paired MeshLink instances.

This also adds a start_meshlink_pair() function which starts the two instances
and waits for them to establish a connection with each other. A condition
variable is used to avoid having to poll.

Don't accept channels if we set channel_accept_cb to NULL.

Properly destroy unclosed channels at meshlink_close() time.

Reset UTCP timers after a succesful key exchange.

The problem is that MeshLink does key exchange with peers on-demand. One
has to start a channel for key exchange to be initiated, but it also tries
to send the first SYN packet immediately. This will not work, and then it
has to wait for the retransmit timer to expire before it will try to send
the SYN again. Since the retransmit timer is increased exponentially, this
can potentially take a long time. So when key exchange is finished, we now
force a reset of the timers of all UTCP connections with the peer.

Enforce spaces around operators.

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.

Remove hack to wait for a valid key.

This was obviously only necessary because the missing retransmits of SYN
packets. Now, if a channel is opened before we have finished the key
exchange with the peer, UTCP will retry after a second.

Allow Catta to be disabled.

Normally, we want to enable Catta, however for testing it produces a lot
of unwanted network packets and log messages.

Drop dependency on zlib.

It's not used, since nothing in the code enables compression. If the
application wants to use compression, it should perform this itself.

Enable silent build rules.

Update all header guards.

Don't start with underscores, as those are reserved for system
libraries. Make sure all start with MESHLINK_, and that they appear at
the top of the file.

Add an astylerc file and reformat all code.

This allows astyle to be used as a pre-commit hook.

Remove avahi submodule.

Use new version of UTCP which also return errors via the poll callback.

Don't call abort() when no channel receive callback is set.

If binding to the configured port fails, ask the OS to provide a port.

This will still allow MeshLink to make outgoing connections to other
nodes.

Call srand() at startup.

Restart the mesh after a failed join() in the other examples as well.

Restart the mesh even after a failed join().

Set a timeout of 5 seconds on sockets in meshlink_join() and get_external_address().

Document that meshlink_join() and meshlink_get_external_address() are blocking.

Add meshlink_channel_open_ex().

This allows flags to be passed to the underlying UTCP connection, which
determines what kind of connection semantics to use.

Allow '-' in node names.

This allows URL-safe base64 encoding to be used in node names.

Ensure consistent use of SPTPS session labels.

Fix meshlink_stop() calling pthread_mutex_lock() twice.

Remove debug messages incorrectly marked as warnings.

Update the C++ header file.

Add the meshlink_get_port() and meshlink_set_port() functions.

The latter can be used to change the port on which MeshLink
listens. It may only be called when the mesh is not running.

Add modify_config_file() to allow overwriting existing configuration values.

Fix processing of mixed ID and SPTPS data.

When making a connection with another peer, the ID message and the first
SPTPS data is sent using separate send() calls, but they can be merged
along the way to the other side. When receiving the ID message, we
accidentily discarded the rest of the received packet. Handle this
properly.

The problem was found to trigger much more often on Linux kernel 4.4 in
KVM.

Add meshlink_get_external_address() and meshlink_add_external_address().

These functions try to discover the local node's external address by
contacting the meshlink.io server. The get function just returns the
discovered address as a string, the add function adds it as an Address,
so it will end up in the list of addresses when calling
meshlink_export().

Use free_known_addresses() to free memory allocated by get_known_addresses().

We know what struct addrinfo looks like, but the standard says nothing about
how it is allocated. So we cannot trust freeaddrinfo() to work correctly on
the struct addrinfo list we allocated ourselves in get_known_addresses().
To make a distinction by allocations from the latter and from str2addrinfo(),
we keep two pointers (*ai and *aip) in struct outgoing, and use the freeing
function that is appropriate for each.

Fix resource leaks found by cppcheck.

Make repeated calls to meshlink_start() without meshlink_stop() safe.

Fix race condition when calling meshlink_stop() immediately after meshlink_start().

The event loop didn't react to event_loop_stop() if it wasn't started yet
(because that is done in mesh->thread). The solution is to add a
event_loop_start() function that is to be called by meshlink_start().

Send a UDP packet to ourself instead of doing a dummy connect().

This is simpler, hopefully with less chance of failing.

Fix check for succesful opening of UDP ports.

Fix meshlink_stop() on Mac OS X.

Mac OS X doesn't like shutdown(SHUT_RDWR) on listening sockets, and also
doesn't allow reopening a listening socket right after closing the
previous one on the same port. So avoid the whole business of closing
and reopening sockets by stopping the event loop and then doing a dummy
connect() to ourself to ensure select() in the network thread returns
immediately.

# Conflicts:
# src/meshlink.c

meshlink_start() now fails when the listening socket could not be opened.

Libtool wants AM_PROG_AR.

Add meshlink_get_self().

This returns a handle for the local node. This can also be used to determine
our own name using meshlink_get_self(mesh)->name.

Fix the basicpp test.

Add a function to destroy a MeshLink instance.

This will remove all configuration files related to a MeshLink instance.

Fix incorrect SPTPS session labels.

To prevent a MITM from being able to splice different SPTPS sessions
together, each session has a unique label. snprintf() was used to fill a
buffer with the label, however the buffer was not big enough for the whole
label. Linux made sure the last byte of the buffer was a NUL character,
Windows did not, resulting in the two unable to connect to each other.

Double the default size of the replay window in SPTPS.

Remove unused replay window and RTT/bandwidth estimation code.

The replay window handling is done by SPTPS. The replaywin member of node_t
was not used at all. Somehwat related, there was RTT and bandwidth
estimation code that didn't work anymore and is not used anyway.

Determine the local node's address(es) and add them to its host config file.

Use the "UDP connect() to an external IP address" trick to determine the
local node's addresses in a platform independent way, without sending any
actual packets. Do this at meshlink_open() time, so the application has
immediate access to them when calling meshlink_export().

Don't append duplicate entries to configuration files.

Automatically detected addresses are appended to host config files by
Catta. However, it doesn't check whether the address is already known.
Have append_config_file() check that it doesn't write duplicate entries.

Fix a memory leak when retrying outgoing connections.

When retry_outgoing_handler() calls setup_outgoing_connection(), it can
be that the old configuration is still in memory. So clean that up
before reading in new configuration data.

Ignore address hints for our local node.

Catta also sees itself, which causes MeshLink to add address hints for
its own node. That causes link-local addresses to be added. When calling
meshlink_invite(), the first link-local address would then be used for
the invitation URL, which is not desirable.

fix for autoconnect (prevent ping pong)

Return an appropriate value from channel_accept.

Check in trampoline callbacks that mesh instance is not destructed.

Update UTCP to the latest commit, which changes the return value of utcp_timeout().

Conflicts:
src/utcp

Make echo-fork handle arbitrary long streams of data.

Call stop in close, as stated in documentation.

Updated echo-fork test program.

Cleaned up test example.

Test case for sending large messages.

fix private key file read and write on windows (binary read/write)

Make sure header src and dst are always null-terminated.

hack to wait for SPTPS to complete before opening a channel