DEV_CLASS_STATIONARY = 1,
DEV_CLASS_PORTABLE = 2,
DEV_CLASS_UNKNOWN = 3,
- _DEV_CLASS_MAX = 3
+ DEV_CLASS_COUNT
} dev_class_t;
/// Invitation flags
static const uint32_t MESHLINK_CHANNEL_ORDERED = 2; // Data is delivered in-order to the application.
static const uint32_t MESHLINK_CHANNEL_FRAMED = 4; // Data is delivered in chunks of the same length as data was originally sent.
static const uint32_t MESHLINK_CHANNEL_DROP_LATE = 8; // When packets are reordered, late packets are ignored.
+static const uint32_t MESHLINK_CHANNEL_NO_PARTIAL = 16; // Calls to meshlink_channel_send() will either send all data or nothing.
static const uint32_t MESHLINK_CHANNEL_TCP = 3; // Select TCP semantics.
static const uint32_t MESHLINK_CHANNEL_UDP = 0; // Select UDP semantics.
/// Open or create a MeshLink instance that uses encrypted storage.
/** This function opens or creates a MeshLink instance.
- * The state is stored in the configuration directory passed in the variable @a confbase @a.
+ * The state is stored in the configuration directory passed in the variable @a confbase.
* If the configuration directory does not exist yet, for example when it is the first time
* this instance is opened, the configuration directory will be automatically created and initialized.
* However, the parent directory should already exist, otherwise an error will be returned.
* first set callbacks, and then call meshlink_start().
*
* @param confbase The directory in which MeshLink will store its configuration files.
- * After the function returns, the application is free to overwrite or free @a confbase @a.
+ * After the function returns, the application is free to overwrite or free @a confbase.
* @param name The name which this instance of the application will use in the mesh.
- * After the function returns, the application is free to overwrite or free @a name @a.
+ * After the function returns, the application is free to overwrite or free @a name.
* @param appname The application name which will be used in the mesh.
- * After the function returns, the application is free to overwrite or free @a name @a.
+ * After the function returns, the application is free to overwrite or free @a name.
* @param devclass The device class which will be used in the mesh.
* @param key A pointer to a key used to encrypt storage.
* @param keylen The length of the key in bytes.
* first set callbacks, and then call meshlink_start().
*
* @param name The name which this instance of the application will use in the mesh.
- * After the function returns, the application is free to overwrite or free @a name @a.
+ * After the function returns, the application is free to overwrite or free @a name.
* @param appname The application name which will be used in the mesh.
- * After the function returns, the application is free to overwrite or free @a name @a.
+ * After the function returns, the application is free to overwrite or free @a name.
* @param devclass The device class which will be used in the mesh.
*
* @return A pointer to a meshlink_handle_t which represents this instance of MeshLink, or NULL in case of an error.
*
* It is allowed to call this function even if MeshLink is already started, in which case it will return true.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
- *
+ *
* @param submesh Name of the new Sub-Mesh to create.
*
* @return A pointer to a meshlink_submesh_t which represents this instance of SubMesh, or NULL in case of an error.
* The pointer is valid until meshlink_close() is called.
*/
-meshlink_submesh_t *meshlink_submesh_open(meshlink_handle_t *mesh, const char *submesh);
+meshlink_submesh_t *meshlink_submesh_open(meshlink_handle_t *mesh, const char *submesh);
/// Start MeshLink.
/** This function causes MeshLink to open network sockets, make outgoing connections, and
*
* It is allowed to call this function even if MeshLink is already started, in which case it will return true.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
*
* @return This function will return true if MeshLink has successfully started, false otherwise.
* This function always succeeds. It is allowed to call meshlink_stop() even if MeshLink is already stopped or has never been started.
* Channels that are still open will remain valid, but any communication via channels will stop as well.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
*/
extern void meshlink_stop(meshlink_handle_t *mesh);
* If called at a proper time with a valid handle, this function always succeeds.
* If called within a callback or with an invalid handle, the result is undefined.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
*/
extern void meshlink_close(meshlink_handle_t *mesh);
* to hand the data over to the application's thread.
* The callback should also not block itself and return as quickly as possible.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
* @param cb A pointer to the function which will be called when another node sends data to the local node.
* If a NULL pointer is given, the callback will be disabled.
* to hand the data over to the application's thread.
* The callback should also not block itself and return as quickly as possible.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
* @param cb A pointer to the function which will be called when host node attempts to make
* the connection to another node. If a NULL pointer is given, the callback will be disabled.
extern void meshlink_set_connection_try_cb(meshlink_handle_t *mesh, meshlink_connection_try_cb_t cb);
/// A callback reporting node status changes.
-/** @param mesh A handle which represents an instance of MeshLink.
+/** @param mesh A handle which represents an instance of MeshLink.
* @param node A pointer to a meshlink_node_t describing the node whose status changed.
* This pointer is valid until meshlink_close() is called.
* @param reachable True if the node is reachable, false otherwise.
* to hand the data over to the application's thread.
* The callback should also not block itself and return as quickly as possible.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
* @param cb A pointer to the function which will be called when another node's status changes.
* If a NULL pointer is given, the callback will be disabled.
*/
extern void meshlink_set_node_status_cb(meshlink_handle_t *mesh, meshlink_node_status_cb_t cb);
+/// A callback reporting node path MTU changes.
+/** @param mesh A handle which represents an instance of MeshLink.
+ * @param node A pointer to a meshlink_node_t describing the node whose status changed.
+ * This pointer is valid until meshlink_close() is called.
+ * @param pmtu The current path MTU to the node, or 0 if UDP communication is not (yet) possible.
+ */
+typedef void (*meshlink_node_pmtu_cb_t)(meshlink_handle_t *mesh, meshlink_node_t *node, uint16_t pmtu);
+
+/// Set the node extended status callback.
+/** This functions sets the callback that is called whenever certain connectivity parameters for a node change.
+ * The callback is run in MeshLink's own thread.
+ * It is therefore important that the callback uses apprioriate methods (queues, pipes, locking, etc.)
+ * to hand the data over to the application's thread.
+ * The callback should also not block itself and return as quickly as possible.
+ *
+ * \memberof meshlink_handle
+ * @param mesh A handle which represents an instance of MeshLink.
+ * @param cb A pointer to the function which will be called when another node's extended status changes.
+ * If a NULL pointer is given, the callback will be disabled.
+ */
+extern void meshlink_set_node_pmtu_cb(meshlink_handle_t *mesh, meshlink_node_pmtu_cb_t cb);
+
/// A callback reporting duplicate node detection.
/** @param mesh A handle which represents an instance of MeshLink.
* @param node A pointer to a meshlink_node_t describing the node which is duplicate.
* to hand the data over to the application's thread.
* The callback should also not block itself and return as quickly as possible.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
* @param cb A pointer to the function which will be called when a duplicate node is detected.
* If a NULL pointer is given, the callback will be disabled.
* In case it is NULL, the callback will be called for errors that happen outside the context of a valid mesh instance.
* Otherwise, it will be called for errors that happen in the context of the given mesh instance.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink, or NULL.
* @param level An enum describing the minimum severity level. Debugging information with a lower level will not trigger the callback.
* @param cb A pointer to the function which will be called when another node sends data to the local node.
* The application should not send packets that are larger than the path MTU, which can be queried with meshlink_get_pmtu().
* The application should take care of getting an acknowledgement and retransmission if necessary.
*
+ * \memberof meshlink_node
* @param mesh A handle which represents an instance of MeshLink.
* @param destination A pointer to a meshlink_node_t describing the destination for the data.
* @param data A pointer to a buffer containing the data to be sent to the source.
* and the path MTU can change at any point in time due to changes in the Internet.
* Therefore, although this should only occur rarely, it can still happen that packets that do not exceed this size get dropped.
*
+ * \memberof meshlink_node
* @param mesh A handle which represents an instance of MeshLink.
* @param destination A pointer to a meshlink_node_t describing the destination for the data.
*
/// Get a handle for our own node.
/** This function returns a handle for the local node.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
*
* @return A pointer to a meshlink_node_t which represents the local node.
/// Get a handle for a specific node.
/** This function returns a handle for the node with the given name.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
* @param name The name of the node for which a handle is requested.
* After this function returns, the application is free to overwrite or free @a name.
/// Get a handle for a specific submesh.
/** This function returns a handle for the submesh with the given name.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
* @param name The name of the submesh for which a handle is requested.
- * After this function returns, the application is free to overwrite or free @a name @a.
+ * After this function returns, the application is free to overwrite or free @a name.
*
* @return A pointer to a meshlink_submesh_t which represents the requested submesh,
* or NULL if the requested submesh does not exist.
/** This function returns a fingerprint of the node's public key.
* It should be treated as an opaque blob.
*
+ * \memberof meshlink_node
* @param mesh A handle which represents an instance of MeshLink.
* @param node A pointer to a meshlink_node_t describing the node.
*
/// Get a list of all nodes.
/** This function returns a list with handles for all known nodes.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
* @param nodes A pointer to a previously allocated array of pointers to meshlink_node_t, or NULL in which case MeshLink will allocate a new array.
* The application can supply an array it allocated itself with malloc, or the return value from the previous call to this function (which is the preferred way).
/** This function signs data using the local node's MeshLink key.
* The generated signature can be securely verified by other nodes.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
* @param data A pointer to a buffer containing the data to be signed.
* @param len The length of the data to be signed.
/// Get the list of all nodes by device class.
/** This function returns a list with handles for all the nodes that matches with the given @a devclass.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
* @param devclass Device class of the nodes for which the list has to be obtained.
* @param nodes A pointer to a previously allocated array of pointers to meshlink_node_t, or NULL in which case MeshLink will allocate a new array.
/// Get the list of all nodes by Submesh.
/** This function returns a list with handles for all the nodes that matches with the given @a Submesh.
*
+ * \memberof meshlink_submesh
* @param mesh A handle which represents an instance of MeshLink.
* @param submesh Submesh handle of the nodes for which the list has to be obtained.
* @param nodes A pointer to a previously allocated array of pointers to meshlink_node_t, or NULL in which case MeshLink will allocate a new array.
/// Get the node's device class.
/** This function returns the device class of the given node.
*
+ * \memberof meshlink_node
* @param mesh A handle which represents an instance of MeshLink.
* @param node A pointer to a meshlink_node_t describing the node.
*
/// Get the node's submesh handle.
/** This function returns the submesh handle of the given node.
*
+ * \memberof meshlink_node
* @param mesh A handle which represents an instance of MeshLink.
* @param node A pointer to a meshlink_node_t describing the node.
*
/// Verify the signature generated by another node of a piece of data.
/** This function verifies the signature that another node generated for a piece of data.
*
+ * \memberof meshlink_node
* @param mesh A handle which represents an instance of MeshLink.
* @param source A pointer to a meshlink_node_t describing the source of the signature.
* @param data A pointer to a buffer containing the data to be verified.
* If a canonical Address is set for the local node,
* it will be used for the hostname part of generated invitation URLs.
*
+ * \memberof meshlink_node
* @param mesh A handle which represents an instance of MeshLink.
* @param node A pointer to a meshlink_node_t describing the node.
* @param address A nul-terminated C string containing the address, which can be either in numeric format or a hostname.
/// Add an Address for the local node.
/** This function adds an Address for the local node, which will be used for invitation URLs.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
* @param address A nul-terminated C string containing the address, which can be either in numeric format or a hostname.
*
* There is no guarantee it will be able to resolve the external address.
* Failures might be because by temporary network outages.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
*
* @return This function returns a pointer to a C string containing the discovered external address,
* There is no guarantee it will be able to resolve the external address.
* Failures might be because by temporary network outages.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
* @param address_family The address family to check, for example AF_INET or AF_INET6. If AF_UNSPEC is given,
* this might return the external address for any working address family.
* This function will fail if it couldn't find a local address for the given address family.
* If hostname resolving is requested, this function may block for a few seconds.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
* @param address_family The address family to check, for example AF_INET or AF_INET6. If AF_UNSPEC is given,
* this might return the local address for any working address family.
*
* Read the description of meshlink_get_external_address() for the limitations of this function.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
*
* @return This function returns true if the address was added, false otherwise.
/// Get the network port used by the local node.
/** This function returns the network port that the local node is listening on.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
*
* @return This function returns the port number, or -1 in case of an error.
* that the other nodes may no longer be able to initiate connections to the local node,
* since they will try to connect to the previously configured port.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
* @param port The port number to listen on. This must be between 0 and 65535.
* If the port is set to 0, then MeshLink will listen on a port
* Note that timeouts are only checked at the time a node tries to join using an invitation.
* The default timeout for invitations is 1 week.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
* @param timeout The timeout for invitations in seconds.
*/
* This URL should be passed by the application to the invitee in a way that no eavesdroppers can see the URL.
* The URL can only be used once, after the user has joined the mesh the URL is no longer valid.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
* @param submesh A handle which represents an instance of SubMesh.
* @param name A nul-terminated C string containing the name that the invitee will be allowed to use in the mesh.
*
* Calling this function is equal to callen meshlink_invite_ex() with flags set to 0.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
* @param submesh A handle which represents an instance of SubMesh.
* @param name A nul-terminated C string containing the name that the invitee will be allowed to use in the mesh.
* There is no guarantee it will perform a successful join.
* Failures might be caused by temporary network outages, or by the invitation having expired.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
* @param invitation A nul-terminated C string containing the invitation URL.
* After this function returns, the application is free to overwrite or free @a invitation.
*
* Note that to create a working connection between two nodes, both must call meshink_export() and both must meshlink_import() each other's data.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
*
* @return This function returns a nul-terminated C string that contains the exported key and addresses, or NULL in case of an error.
*
* Note that to create a working connection between two nodes, both must call meshink_export() and both must meshlink_import() each other's data.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
* @param data A nul-terminated C string containing the other node's exported key and addresses.
* After this function returns, the application is free to overwrite or free @a data.
* The local node will drop any existing connections to that node,
* and will not send data to it nor accept any data received from it any more.
*
+ * \memberof meshlink_node
* @param mesh A handle which represents an instance of MeshLink.
* @param node A pointer to a meshlink_node_t describing the node to be blacklisted.
*/
* The local node will allow connections to and from that node,
* and will send data to it and accept any data received from it.
*
+ * \memberof meshlink_node
* @param mesh A handle which represents an instance of MeshLink.
* @param node A pointer to a meshlink_node_t describing the node to be whitelisted.
*/
* The whitelist/blacklist status of a node may be changed afterwards with the
* meshlink_whitelist() and meshlink_blacklist() functions.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
* @param blacklist True if new nodes are to be blacklisted, false if whitelisted.
*/
*
* If no accept callback is set, incoming channels are rejected.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
* @param cb A pointer to the function which will be called when another node sends data to the local node.
* If a NULL pointer is given, the callback will be disabled.
* to hand the data over to the application's thread.
* The callback should also not block itself and return as quickly as possible.
*
+ * \memberof meshlink_channel
* @param mesh A handle which represents an instance of MeshLink.
* @param channel A handle for the channel.
* @param cb A pointer to the function which will be called when another node sends data to the local node.
* to pass data to or from the application's thread.
* The callback should also not block itself and return as quickly as possible.
*
+ * \memberof meshlink_channel
* @param mesh A handle which represents an instance of MeshLink.
* @param channel A handle for the channel.
* @param cb A pointer to the function which will be called when data can be sent to another node.
*/
extern void meshlink_set_channel_poll_cb(meshlink_handle_t *mesh, meshlink_channel_t *channel, meshlink_channel_poll_cb_t cb);
+/// Set the send buffer size of a channel.
+/** This function sets the desired size of the send buffer.
+ * The default size is 128 kB.
+ *
+ * \memberof meshlink_channel
+ * @param mesh A handle which represents an instance of MeshLink.
+ * @param channel A handle for the channel.
+ * @param size The desired size for the send buffer.
+ * If a NULL pointer is given, the callback will be disabled.
+ */
+extern void meshlink_set_channel_sndbuf(meshlink_handle_t *mesh, meshlink_channel_t *channel, size_t size);
+
+/// Set the receive buffer size of a channel.
+/** This function sets the desired size of the receive buffer.
+ * The default size is 128 kB.
+ *
+ * \memberof meshlink_channel
+ * @param mesh A handle which represents an instance of MeshLink.
+ * @param channel A handle for the channel.
+ * @param size The desired size for the send buffer.
+ * If a NULL pointer is given, the callback will be disabled.
+ */
+extern void meshlink_set_channel_rcvbuf(meshlink_handle_t *mesh, meshlink_channel_t *channel, size_t size);
+
/// Open a reliable stream channel to another node.
/** This function is called whenever a remote node wants to open a channel to the local node.
* The application then has to decide whether to accept or reject this channel.
* When the application does no longer need to use this channel, it must call meshlink_close()
* to free its resources.
*
+ * \memberof meshlink_node
* @param mesh A handle which represents an instance of MeshLink.
* @param node The node to which this channel is being initiated.
* @param port The port number the peer wishes to connect to.
* Calling this function is equivalent to calling meshlink_channel_open_ex()
* with the flags set to MESHLINK_CHANNEL_TCP.
*
+ * \memberof meshlink_node
* @param mesh A handle which represents an instance of MeshLink.
* @param node The node to which this channel is being initiated.
* @param port The port number the peer wishes to connect to.
*
* Shutting down the receive direction is also possible, and is equivalent to setting the receive callback to NULL.
*
+ * \memberof meshlink_channel
* @param mesh A handle which represents an instance of MeshLink.
* @param channel A handle for the channel.
* @param direction Must be one of SHUT_RD, SHUT_WR or SHUT_RDWR, otherwise this call will not have any affect.
* It is allowed to call this function at any time on a valid handle, even inside callback functions.
* If called with a valid handle, this function always succeeds, otherwise the result is undefined.
*
+ * \memberof meshlink_channel
* @param mesh A handle which represents an instance of MeshLink.
* @param channel A handle for the channel.
*/
/// Transmit data on a channel
/** This queues data to send to the remote node.
*
+ * \memberof meshlink_channel
* @param mesh A handle which represents an instance of MeshLink.
* @param channel A handle for the channel.
* @param data A pointer to a buffer containing data sent by the source, or NULL if there is no data to send.
* @param len The length of the data, or 0 if there is no data to send.
*
* @return The amount of data that was queued, which can be less than len, or a negative value in case of an error.
+ * If MESHLINK_CHANNEL_NO_PARTIAL is set, then the result will either be len,
+ * 0 if the buffer is currently too full, or -1 if len is too big even for an empty buffer.
*/
extern ssize_t meshlink_channel_send(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *data, size_t len);
+/// A callback for cleaning up buffers submitted for asynchronous I/O.
+/** This callbacks signals that MeshLink has finished using this buffer.
+ * The ownership of the buffer is now back into the application's hands.
+ *
+ * @param mesh A handle which represents an instance of MeshLink.
+ * @param channel A handle for the channel which used this buffer.
+ * @param data A pointer to a buffer containing the enqueued data.
+ * @param len The length of the buffer.
+ * @param priv A private pointer which was set by the application when submitting the buffer.
+ */
+typedef void (*meshlink_aio_cb_t)(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *data, size_t len, void *priv);
+
+/// A callback for asynchronous I/O to and from filedescriptors.
+/** This callbacks signals that MeshLink has finished using this filedescriptor.
+ *
+ * @param mesh A handle which represents an instance of MeshLink.
+ * @param channel A handle for the channel which used this filedescriptor.
+ * @param fd The filedescriptor that was used.
+ * @param len The length of the data that was successfully sent or received.
+ * @param priv A private pointer which was set by the application when submitting the buffer.
+ */
+typedef void (*meshlink_aio_fd_cb_t)(meshlink_handle_t *mesh, meshlink_channel_t *channel, int fd, size_t len, void *priv);
+
+/// Transmit data on a channel asynchronously
+/** This registers a buffer that will be used to send data to the remote node.
+ * Multiple buffers can be registered, in which case data will be sent in the order the buffers were registered.
+ * While there are still buffers with unsent data, the poll callback will not be called.
+ *
+ * \memberof meshlink_channel
+ * @param mesh A handle which represents an instance of MeshLink.
+ * @param channel A handle for the channel.
+ * @param data A pointer to a buffer containing data sent by the source, or NULL if there is no data to send.
+ * After meshlink_channel_aio_send() returns, the buffer may not be modified or freed by the application
+ * until the callback routine is called.
+ * @param len The length of the data, or 0 if there is no data to send.
+ * @param cb A pointer to the function which will be called when MeshLink has finished using the buffer.
+ * @param priv A private pointer which is passed unchanged to the callback.
+ *
+ * @return True if the buffer was enqueued, false otherwise.
+ */
+extern bool meshlink_channel_aio_send(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *data, size_t len, meshlink_aio_cb_t cb, void *priv);
+
+/// Transmit data on a channel asynchronously from a filedescriptor
+/** This will read up to the specified length number of bytes from the given filedescriptor, and send it over the channel.
+ * The callback may be returned early if there is an error reading from the filedescriptor.
+ * While there is still with unsent data, the poll callback will not be called.
+ *
+ * \memberof meshlink_channel
+ * @param mesh A handle which represents an instance of MeshLink.
+ * @param channel A handle for the channel.
+ * @param fd A file descriptor from which data will be read.
+ * @param len The length of the data, or 0 if there is no data to send.
+ * @param cb A pointer to the function which will be called when MeshLink has finished using the filedescriptor.
+ * @param priv A private pointer which is passed unchanged to the callback.
+ *
+ * @return True if the buffer was enqueued, false otherwise.
+ */
+extern bool meshlink_channel_aio_fd_send(meshlink_handle_t *mesh, meshlink_channel_t *channel, int fd, size_t len, meshlink_aio_fd_cb_t cb, void *priv);
+
+/// Receive data on a channel asynchronously
+/** This registers a buffer that will be filled with incoming channel data.
+ * Multiple buffers can be registered, in which case data will be received in the order the buffers were registered.
+ * While there are still buffers that have not been filled, the receive callback will not be called.
+ *
+ * \memberof meshlink_channel
+ * @param mesh A handle which represents an instance of MeshLink.
+ * @param channel A handle for the channel.
+ * @param data A pointer to a buffer that will be filled with incoming data.
+ * After meshlink_channel_aio_receive() returns, the buffer may not be modified or freed by the application
+ * until the callback routine is called.
+ * @param len The length of the data.
+ * @param cb A pointer to the function which will be called when MeshLink has finished using the buffer.
+ * @param priv A private pointer which is passed unchanged to the callback.
+ *
+ * @return True if the buffer was enqueued, false otherwise.
+ */
+extern bool meshlink_channel_aio_receive(meshlink_handle_t *mesh, meshlink_channel_t *channel, const void *data, size_t len, meshlink_aio_cb_t cb, void *priv);
+
+/// Receive data on a channel asynchronously and send it to a filedescriptor
+/** This will read up to the specified length number of bytes from the channel, and send it to the filedescriptor.
+ * The callback may be returned early if there is an error writing to the filedescriptor.
+ * While there is still unread data, the receive callback will not be called.
+ *
+ * \memberof meshlink_channel
+ * @param mesh A handle which represents an instance of MeshLink.
+ * @param channel A handle for the channel.
+ * @param fd A file descriptor to which data will be written.
+ * @param len The length of the data.
+ * @param cb A pointer to the function which will be called when MeshLink has finished using the filedescriptor.
+ * @param priv A private pointer which was set by the application when submitting the buffer.
+ *
+ * @return True if the buffer was enqueued, false otherwise.
+ */
+extern bool meshlink_channel_aio_fd_receive(meshlink_handle_t *mesh, meshlink_channel_t *channel, int fd, size_t len, meshlink_aio_fd_cb_t cb, void *priv);
+
/// Get channel flags.
/** This returns the flags used when opening this channel.
*
+ * \memberof meshlink_channel
* @param mesh A handle which represents an instance of MeshLink.
* @param channel A handle for the channel.
*
/** This returns the amount of bytes in the send buffer.
* These bytes have not been received by the peer yet.
*
+ * \memberof meshlink_channel
* @param mesh A handle which represents an instance of MeshLink.
* @param channel A handle for the channel.
*
/** This returns the amount of bytes in the receive buffer.
* These bytes have not been processed by the application yet.
*
+ * \memberof meshlink_channel
* @param mesh A handle which represents an instance of MeshLink.
* @param channel A handle for the channel.
*
/** This function indicates to meshlink that the given hostname is likely found
* at the given IP address and port.
*
+ * \memberof meshlink_node
* @param mesh A handle which represents an instance of MeshLink.
* @param node A pointer to a meshlink_node_t describing the node to add the address hint for.
* @param addr The IP address and port which should be tried for the
extern void meshlink_hint_address(meshlink_handle_t *mesh, meshlink_node_t *node, const struct sockaddr *addr);
/// 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.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
* @param enable Set to true to enable discovery, false to disable.
*/
extern void meshlink_enable_discovery(meshlink_handle_t *mesh, bool enable);
/// Performs key rotation for an encrypted storage
-
/** This rotates the (master) key for an encrypted storage and discards the old key
* if the call succeeded. This is an atomic call.
*
+ * \memberof meshlink_handle
* @param mesh A handle which represents an instance of MeshLink.
* @param key A pointer to the new key used to encrypt storage.
* @param keylen The length of the new key in bytes.
*
* @return This function returns true if the key rotation for the encrypted storage succeeds, false otherwise.
*/
-extern bool meshlink_encrypted_key_rotate(meshlink_handle_t *mesh, const void *new_key, size_t new_keylen);
+extern bool meshlink_encrypted_key_rotate(meshlink_handle_t *mesh, const void *key, size_t keylen);
+
+/// Set device class timeouts
+/** This sets the ping interval and timeout for a given device class.
+ *
+ * \memberof meshlink_handle
+ * @param mesh A handle which represents an instance of MeshLink.
+ * @param devclass The device class to update
+ * @param pinginterval The interval between keepalive packets, in seconds. The default is 60.
+ * @param pingtimeout The required time within which a peer should respond, in seconds. The default is 5.
+ * The timeout must be smaller than the interval.
+ */
+extern void meshlink_set_dev_class_timeouts(meshlink_handle_t *mesh, dev_class_t devclass, int pinginterval, int pingtimeout);
#ifdef __cplusplus
}
projects / meshlink / blobdiff