Channels can now actually be opened.

[meshlink] / src / meshlink.h

diff --git a/src/meshlink.h b/src/meshlink.h
index 7cf1f4445a5e780f20472dbfdac61b5432232381..17545ed289b4c464dadc9e0ba53ca7108a74348b 100644 (file)
--- a/src/meshlink.h
+++ b/src/meshlink.h
@@ -88,10 +88,8 @@ extern __thread meshlink_errno_t meshlink_errno;
 #ifndef MESHLINK_INTERNAL_H
 
 struct meshlink_handle {
-       char *name;
-       char *appname;
-       dev_class_t devclass;
-       void *priv;
+       char *name;       ///< Textual name of ourself. It is stored in a nul-terminated C string, which is allocated by MeshLink.
+       void *priv;       ///< Private pointer which may be set freely by the application, and is never used or modified by MeshLink.
 };
 
 struct meshlink_node {
@@ -100,6 +98,8 @@ struct meshlink_node {
 };
 
 struct meshlink_channel {
+       struct meshlink_node *node; ///< Pointer to the peer of this channel.
+       void *priv;                 ///< Private pointer which may be set freely by the application, and is never used or modified by MeshLink.
 };
 
 #endif // MESHLINK_INTERNAL_H
@@ -497,8 +497,6 @@ extern void meshlink_blacklist(meshlink_handle_t *mesh, meshlink_node_t *node);
  *                      If the application rejects the incoming channel by returning false,
  *                      then this handle is invalid after the callback returns
  *                      (the callback does not need to call meshlink_channel_close() itself in this case).
- *  @param node         The node from which this channel is being initiated.
- *                      The pointer is guaranteed to be valid until meshlink_close() is called.
  *  @param port         The port number the peer wishes to connect to.
  *  @param data         A pointer to a buffer containing data already received, or NULL in case no data has been received yet. (Not yet used.)
  *                      The pointer is only valid during the lifetime of the callback.
@@ -508,7 +506,7 @@ extern void meshlink_blacklist(meshlink_handle_t *mesh, meshlink_node_t *node);
  *  @return             This function should return true if the application accepts the incoming channel, false otherwise.
  *                      If returning false, the channel is invalid and may not be used anymore.
  */
-typedef bool (*meshlink_channel_accept_cb_t)(meshlink_handle_t *mesh, meshlink_channel_t *channel, meshlink_node_t *node, uint16_t port, const void *data, size_t len);
+typedef bool (*meshlink_channel_accept_cb_t)(meshlink_handle_t *mesh, meshlink_channel_t *channel, uint16_t port, const void *data, size_t len);
 
 /// A callback for receiving data from a channel.
 /** This function is called whenever data is received from a remote node on a channel.
@@ -640,28 +638,31 @@ extern void meshlink_hint_address(meshlink_handle_t *mesh, meshlink_node_t *node
  *
  *  @param mesh         A handle which represents an instance of MeshLink.
  *  @param edges        A pointer to a previously allocated array of pointers to
- *                     meshlink_edge_t, or NULL in which case MeshLink will
- *                     allocate a new array. The application CANNOT supply an
- *                     array it allocated itself with malloc, but CAN use
- *                     the return value from the previous call to this function
- *                     (which is the preferred way).
+ *                      meshlink_edge_t, or NULL in which case MeshLink will
+ *                      allocate a new array. The application CANNOT supply an
+ *                      array it allocated itself with malloc, but CAN use
+ *                      the return value from the previous call to this function
+ *                      (which is the preferred way).
  *                      The pointers in the array are valid until meshlink_close() is called.
+ *                      ATTENTION: The pointers and values should never be modified
+ *                      by the application!!!
  *  @param nmemb        A pointer to a variable holding the number of nodes that
- *                     are stored in the array. In case the @a nodes @a
- *                     argument is not NULL, MeshLink might call realloc()
- *                     on the array to change its size.
+ *                      are stored in the array. In case the @a nodes @a
+ *                      argument is not NULL, MeshLink might call realloc()
+ *                      on the array to change its size.
  *                      The contents of this variable will be changed to reflect
  *                      the new size of the array.
- *  
  *  @return             A pointer to an array containing pointers to all known 
- *                     edges, or NULL in case of an error.
- *                     If the @a edges @a argument was not NULL, then the
- *                     retun value can be either the same value or a different
- *                     value. If the new values is NULL, then the old array
- *                     will have been freed by Meshlink.
- *                     The caller must call free() on each element of this
- *                     array (but not the contents of said elements),
- *                     as well as the array itself when it is finished.
+ *                      edges, or NULL in case of an error.
+ *                      If the @a edges @a argument was not NULL, then the
+ *                      retun value can be either the same value or a different
+ *                      value. If the new values is NULL, then the old array
+ *                      will have been freed by Meshlink.
+ *                      The caller must call free() on each element of this
+ *                      array (but not the contents of said elements),
+ *                      as well as the array itself when it is finished.
+ *                      ATTENTION: The pointers and values should never be modified
+ *                      by the application!!!
  */
 extern meshlink_edge_t **meshlink_get_all_edges_state(meshlink_handle_t *mesh, meshlink_edge_t **edges, size_t *nmemb);