TODO list for MeshLink
----------------------

* Check for remaining global variables and get rid of them.

* Write code for all the functions in meshlink.c (some can be moved from libmeshlink.c)
  Current stubs that need implementation:
  - meshlink_export()
  - meshlink_import()
  - meshlink_blacklist()

* Implement a simple single producer, single consumer queue for communication
  between the application and library threads. It is possible to do this without locks.

* Provide thread-safety to functions that return pointers to meshlink_node_t.
  - The mesh->nodes tree can be updated by the library thread at any time,
    so it must be protected by a mutex or rwlock.
  - Individial node_t's must never be freed or moved except in meshlink_close().

* meshlink_join():
  - add checks that we only join another mesh if we did not connect to any other node before.
  - only allow meshlink_join() when the library thread is not running.

* Allow meshlink_open() to be called with a NULL name, in anticipation of meshlink_join().
  - Do not allow meshlink_start() if no Name is set.

* Add a logging callback.
  - One in a meshlink_handle_t for everything that happens after meshlink_open().
  - Add a global one for library calls that don't involve a valid meshlink_handle_t *.
  - Get rid of "priority".

* Fill in mesh->errno whenever an error happens (= when a function returns false or NULL).

* Make the headers work correctly in a C++ environment.

* Add a header-only C++ wrapper API.

* Add autoconf/automake stuff to call Doxygen.

* Write a test suite for the library.

* Write a manual
  - Document API
  - Explain what MeshLink does and how it should be used in the application
  - Write simple examples for common operations
  - List possible ways of synchronisation between application and library threads
    - simple polling
    - pthread_cond?
    - pipe() to signal an event loop of the application's choice
    - whatever equivalent(s) there are on Windows

* Add a "channel" library to MeshLink.
  - Support multiple TCP- and UDP-like streams between two nodes.