*/
typedef void (*log_cb_t)(mesh *mesh, log_level_t level, const char *text);
+/// A callback for listening for incoming channels.
+/** @param mesh A handle which represents an instance of MeshLink.
+ * @param node A handle for the node that wants to open a channel.
+ * @param port The port number the peer wishes to connect to.
+ *
+ * @return This function should return true if the application listens for the incoming channel, false otherwise.
+ */
+typedef bool (*meshlink_channel_listen_cb_t)(struct meshlink_handle *mesh, struct meshlink_node *node, uint16_t port);
+
/// A callback for accepting incoming channels.
/** @param mesh A handle which represents an instance of MeshLink.
* @param channel A handle for the incoming channel.
(void)peer;
}
+ /// This functions is called to determine if we are listening for incoming channels.
+ /**
+ * The function is run in MeshLink's own thread.
+ * It is therefore important that the callback uses apprioriate methods (queues, pipes, locking, etc.)
+ * to pass data to or from the application's thread.
+ * The callback should also not block itself and return as quickly as possible.
+ *
+ * @param node A handle for the node that wants to open a channel.
+ * @param port The port number the peer wishes to connect to.
+ *
+ * @return This function should return true if the application accepts the incoming channel, false otherwise.
+ */
+ virtual bool channel_listen(node *node, uint16_t port) {
+ /* by default accept all channels */
+ (void)node;
+ (void)port;
+ return true;
+ }
+
/// This functions is called whenever another node attempts to open a channel to the local node.
/**
* If the channel is accepted, the poll_callback will be set to channel_poll and can be
meshlink_set_node_duplicate_cb(handle, &node_duplicate_trampoline);
meshlink_set_log_cb(handle, MESHLINK_DEBUG, &log_trampoline);
meshlink_set_error_cb(handle, &error_trampoline);
+ meshlink_set_channel_listen_cb(handle, &channel_listen_trampoline);
meshlink_set_channel_accept_cb(handle, &channel_accept_trampoline);
meshlink_set_connection_try_cb(handle, &connection_try_trampoline);
return meshlink_start(handle);
return meshlink_set_canonical_address(handle, node, address, port);
}
- /// Set the canonical Address for the local node.
- /** This function sets the canonical Address for the local node.
- * This address is stored permanently until it is changed by another call to this function,
- * unlike other addresses associated with a node,
- * such as those added with meshlink_hint_address() or addresses discovered at runtime.
+ /// Add an invitation address for the local node.
+ /** This function adds an address for the local node, which will be used only for invitation URLs.
+ * This address is not stored permanently.
+ * Multiple addresses can be added using multiple calls to this function.
*
* @param address A nul-terminated C string containing the address, which can be either in numeric format or a hostname.
* @param port A nul-terminated C string containing the port, which can be either in numeric or symbolic format.
*
* @return This function returns true if the address was added, false otherwise.
*/
- bool set_canonical_address(const char *address, const char *port = NULL) {
- return meshlink_set_canonical_address(handle, get_self(), address, port);
+ bool add_invitation_address(const char *address, const char *port) {
+ return meshlink_add_invitation_address(handle, address, port);
+ }
+
+ /// Clears all invitation address for the local node.
+ /** This function removes all addresses added with meshlink_add_invitation_address().
+ */
+ void clear_invitation_addresses() {
+ return meshlink_clear_invitation_addresses(handle);
}
/// Add an Address for the local node.
/** This function adds an Address for the local node, which will be used for invitation URLs.
+ * @deprecated This function is deprecated, use set_canonical_address() and/or add_invitation_address().
*
* @param address A string containing the address, which can be either in numeric format or a hostname.
*
* @return This function returns true if the address was added, false otherwise.
*/
- bool add_address(const char *address) {
- return meshlink_add_address(handle, address);
+ bool add_address(const char *address) __attribute__((__deprecated__("use set_canonical_address() and/or add_invitation_address() instead"))) {
+ return meshlink_set_canonical_address(handle, get_self(), address, NULL);
}
/** This function performs tries to discover the local node's external address
meshlink_set_invitation_timeout(handle, timeout);
}
+ /// Set the scheduling granularity of the application
+ /** This should be set to the effective scheduling granularity for the application.
+ * This depends on the scheduling granularity of the operating system, the application's
+ * process priority and whether it is running as realtime or not.
+ * The default value is 10000 (10 milliseconds).
+ *
+ * @param granularity The scheduling granularity of the application in microseconds.
+ */
+ void set_granularity(long granularity) {
+ meshlink_set_scheduling_granularity(handle, granularity);
+ }
+
/// Invite another node into the mesh.
/** This function generates an invitation that can be used by another node to join the same mesh as the local node.
* The generated invitation is a string containing a URL.
* This is useful if new nodes are blacklisted by default.
*
* \memberof meshlink_node
- * @param node A pointer to a struct meshlink_node describing the node to be whitelisted.
+ * @param name The name of the node to whitelist.
*
* @return This function returns true if the node has been whitelisted, false otherwise.
*/
/** This sets the timeout after which unresponsive channels will be reported as closed.
* The timeout is set for all current and future channels to the given node.
*
- * @param channel A handle for the channel.
+ * @param node The node to set the channel timeout for.
* @param timeout The timeout in seconds after which unresponsive channels will be reported as closed.
* The default is 60 seconds.
*/
return meshlink_channel_get_recvq(handle, channel);
}
+ /// Get the maximum segment size of a channel.
+ /** This returns the amount of bytes that can be sent at once for channels with UDP semantics.
+ *
+ * @param channel A handle for the channel.
+ *
+ * @return The amount of bytes in the receive buffer.
+ */
+ size_t channel_get_mss(channel *channel) {
+ return meshlink_channel_get_mss(handle, channel);
+ };
+
/// Enable or disable zeroconf discovery of local peers
/** This controls whether zeroconf discovery using the Catta library will be
* enabled to search for peers on the local network. By default, it is enabled.
meshlink_set_dev_class_fast_retry_period(handle, devclass, fast_retry_period);
}
+ /// Set device class maximum timeout
+ /** This sets the maximum timeout for outgoing connection retries for a given device class.
+ *
+ * @param devclass The device class to update
+ * @param maxtimeout The maximum timeout between reconnection attempts, in seconds. The default is 900.
+ */
+ void set_dev_class_maxtimeout(dev_class_t devclass, int maxtimeout) {
+ meshlink_set_dev_class_maxtimeout(handle, devclass, maxtimeout);
+ }
+
/// Set which order invitations are committed
/** This determines in which order configuration files are written to disk during an invitation.
* By default, the invitee saves the configuration to disk first, then the inviter.
meshlink_set_inviter_commits_first(handle, inviter_commits_first);
}
+ /// Set the URL used to discover the host's external address
+ /** For generating invitation URLs, MeshLink can look up the externally visible address of the local node.
+ * It does so by querying an external service. By default, this is http://meshlink.io/host.cgi.
+ * Only URLs starting with http:// are supported.
+ *
+ * @param url The URL to use for external address queries, or NULL to revert back to the default URL.
+ */
+ void set_external_address_discovery_url(const char *url) {
+ meshlink_set_external_address_discovery_url(handle, url);
+ }
+
private:
// non-copyable:
mesh(const mesh &) /* TODO: C++11: = delete */;
that->connection_try(static_cast<node *>(peer));
}
+ static bool channel_listen_trampoline(meshlink_handle_t *handle, meshlink_node_t *node, uint16_t port) {
+ if(!(handle->priv)) {
+ return false;
+ }
+
+ meshlink::mesh *that = static_cast<mesh *>(handle->priv);
+ return that->channel_listen(static_cast<meshlink::node *>(node), port);
+ }
+
static bool channel_accept_trampoline(meshlink_handle_t *handle, meshlink_channel *channel, uint16_t port, const void *data, size_t len) {
if(!(handle->priv)) {
return false;
projects / meshlink / blobdiff