* @param cls closure (set from GNUNET_MESH_connect)
* @param tunnel connection to the other end
* @param tunnel_ctx place to store local state associated with the tunnel
+ * @param sender who sent the message
* @param message the actual message
* @param atsi performance data for the connection
* @return GNUNET_OK to keep the connection open,
* GNUNET_SYSERR to close it (signal serious error)
*/
-typedef int
- (*GNUNET_MESH_MessageCallback) (void *cls,
- const struct GNUNET_MESH_Tunnel *tunnel,
- void **tunnel_ctx,
- const struct GNUNET_MessageHeader *message,
- const struct GNUNET_TRANSPORT_ATS_Information *atsi);
+typedef int (*GNUNET_MESH_MessageCallback) (void *cls,
+ struct GNUNET_MESH_Tunnel * tunnel,
+ void **tunnel_ctx,
+ const struct GNUNET_PeerIdentity *
+ sender,
+ const struct GNUNET_MessageHeader *
+ message,
+ const struct
+ GNUNET_TRANSPORT_ATS_Information *
+ atsi);
/**
* @param tunnel connection to the other end (henceforth invalid)
* @param tunnel_ctx place where local state associated with the tunnel is stored
*/
-typedef void (GNUNET_MESH_TunnelEndHandler)(void *cls,
- const struct GNUNET_MESH_Tunnel *tunnel,
- void **tunnel_ctx);
+typedef void (GNUNET_MESH_TunnelEndHandler) (void *cls,
+ const struct GNUNET_MESH_Tunnel *
+ tunnel, void **tunnel_ctx);
/**
- * Connect to the mesh service.
+ * Type for an application. Values defined in gnunet_applications.h
+ */
+typedef uint32_t GNUNET_MESH_ApplicationType;
+
+
+/**
+ * Connect to the mesh service.
*
* @param cfg configuration to use
* @param cls closure for the various callbacks that follow (including handlers in the handlers array)
* note that the mesh is allowed to drop notifications about inbound
* messages if the client does not process them fast enough (for this
* notification type, a bounded queue is used)
+ * @param stypes Application Types the client claims to offer
* @return handle to the mesh service
* NULL on error (in this case, init is never called)
*/
-struct GNUNET_MESH_Handle *
-GNUNET_MESH_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
- void *cls,
- GNUNET_MESH_TunnelEndHandler cleaner,
- const struct GNUNET_MESH_MessageHandler *handlers);
+struct GNUNET_MESH_Handle *GNUNET_MESH_connect (const struct
+ GNUNET_CONFIGURATION_Handle
+ *cfg, void *cls,
+ GNUNET_MESH_TunnelEndHandler
+ cleaner,
+ const struct
+ GNUNET_MESH_MessageHandler
+ *handlers,
+ const
+ GNUNET_MESH_ApplicationType
+ *stypes);
+
+/**
+ * Get the peer on the other side of this tunnel if it is just one. Return NULL otherwise
+ *
+ * @param tunnel the tunnel
+ * @return the peer or NULL
+ */
+const struct GNUNET_PeerIdentity *GNUNET_MESH_get_peer (const struct
+ GNUNET_MESH_Tunnel
+ *tunnel);
/**
* @param peer peer identity the tunnel stopped working with
*/
typedef void (*GNUNET_MESH_TunnelDisconnectHandler) (void *cls,
- const struct GNUNET_PeerIdentity *peer);
+ const struct
+ GNUNET_PeerIdentity *
+ peer);
/**
* @param atsi performance data for the connection
*/
typedef void (*GNUNET_MESH_TunnelConnectHandler) (void *cls,
- const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_TRANSPORT_ATS_Information *atsi);
+ const struct
+ GNUNET_PeerIdentity * peer,
+ const struct
+ GNUNET_TRANSPORT_ATS_Information
+ * atsi);
*
* @param h mesh handle
* @param timeout how long to try to establish a connection
- * @param num_peers length of the peers arrray
+ * @param num_peers length of the peers array
* @param peers list of candidates to connect to
* @param connect_handler function to call on successful connect (or timeout)
* @param disconnect_handler function to call on disconnect
* @param handler_cls closure for handler
* @return NULL on error (handler will not be called), otherwise handle for cancellation
*/
-struct GNUNET_MESH_Tunnel *
-GNUNET_MESH_peer_request_connect_any (struct GNUNET_MESH_Handle *h,
- struct GNUNET_TIME_Relative timeout,
- unsigned int num_peers,
- const struct GNUNET_PeerIdentity *peers,
- GNUNET_MESH_TunnelConnectHandler connect_handler,
- GNUNET_MESH_TunnelDisconnectHandler disconnect_handler,
- void *handler_cls);
+struct GNUNET_MESH_Tunnel *GNUNET_MESH_peer_request_connect_any (struct
+ GNUNET_MESH_Handle
+ *h,
+ struct
+ GNUNET_TIME_Relative
+ timeout,
+ unsigned int
+ num_peers,
+ const struct
+ GNUNET_PeerIdentity
+ *peers,
+ GNUNET_MESH_TunnelConnectHandler
+ connect_handler,
+ GNUNET_MESH_TunnelDisconnectHandler
+ disconnect_handler,
+ void
+ *handler_cls);
/**
*
* @param h mesh handle
* @param timeout how long to try to establish a connection
- * @param num_peers length of the peers arrray
+ * @param num_peers length of the peers array
* @param peers list of candidates to connect to
* @param connect_handler function to call on successful connect (or timeout);
* will be called for EACH of the peers in the list and
* @param handler_cls closure for handler
* @return NULL on error (handler will not be called), otherwise handle for cancellation
*/
-struct GNUNET_MESH_Tunnel *
-GNUNET_MESH_peer_request_connect_all (struct GNUNET_MESH_Handle *h,
- struct GNUNET_TIME_Relative timeout,
- unsigned int num_peers,
- const struct GNUNET_PeerIdentity *peers,
- GNUNET_MESH_TunnelConnectHandler connect_handler,
- GNUNET_MESH_TunnelDisconnectHandler disconnect_handler,
- void *handler_cls);
+struct GNUNET_MESH_Tunnel *GNUNET_MESH_peer_request_connect_all (struct
+ GNUNET_MESH_Handle
+ *h,
+ struct
+ GNUNET_TIME_Relative
+ timeout,
+ unsigned int
+ num_peers,
+ const struct
+ GNUNET_PeerIdentity
+ *peers,
+ GNUNET_MESH_TunnelConnectHandler
+ connect_handler,
+ GNUNET_MESH_TunnelDisconnectHandler
+ disconnect_handler,
+ void
+ *handler_cls);
/**
* @param timeout how long to try to establish a connection
* @param peer peer to add
*/
-void
-GNUNET_MESH_peer_request_connect_add (struct GNUNET_MESH_Tunnel *tunnel,
- struct GNUNET_TIME_Relative timeout,
- const struct GNUNET_PeerIdentity *peer);
+void GNUNET_MESH_peer_request_connect_add (struct GNUNET_MESH_Tunnel *tunnel,
+ struct GNUNET_TIME_Relative timeout,
+ const struct GNUNET_PeerIdentity
+ *peer);
+
+
+/**
+ * Request that a peer should be removed from the tunnel. The existing
+ * disconnect handler will be called ONCE if we were connected.
+ *
+ * @param tunnel handle to existing tunnel
+ * @param peer peer to remove
+ */
+void GNUNET_MESH_peer_request_connect_del (struct GNUNET_MESH_Tunnel *tunnel,
+ const struct GNUNET_PeerIdentity
+ *peer);
/**
*
* @param h mesh handle
* @param timeout how long to try to establish a connection
- * @param message_type message type that must be supported by the peer (MESH should
+ * @param app_type application type that must be supported by the peer (MESH should
* discover peer in proximity handling this type)
* @param connect_handler function to call on successful connect (or timeout);
* will be called for EACH of the peers in the list and
* @param handler_cls closure for handler
* @return NULL on error (handler will not be called), otherwise handle for cancellation
*/
-struct GNUNET_MESH_Tunnel *
-GNUNET_MESH_peer_request_connect_by_type (struct GNUNET_MESH_Handle *h,
- struct GNUNET_TIME_Relative timeout,
- uint16_t message_type,
- GNUNET_MESH_TunnelConnectHandler connect_handler,
- GNUNET_MESH_TunnelDisconnectHandler disconnect_handler,
- void *handler_cls);
+struct GNUNET_MESH_Tunnel *GNUNET_MESH_peer_request_connect_by_type (struct
+ GNUNET_MESH_Handle
+ *h,
+ struct
+ GNUNET_TIME_Relative
+ timeout,
+ GNUNET_MESH_ApplicationType
+ app_type,
+ GNUNET_MESH_TunnelConnectHandler
+ connect_handler,
+ GNUNET_MESH_TunnelDisconnectHandler
+ disconnect_handler,
+ void
+ *handler_cls);
/**
*
* @param req request handle that was returned for the original request
*/
-void
-GNUNET_MESH_peer_request_connect_cancel (struct GNUNET_MESH_Tunnel *req);
+void GNUNET_MESH_peer_request_connect_cancel (struct GNUNET_MESH_Tunnel *req);
/**
* @param cork is corking allowed for this transmission?
* @param priority how important is the message?
* @param maxdelay how long can the message wait?
+ * @param target destination for the message, NULL for multicast to all tunnel targets
* @param notify_size how many bytes of buffer space does notify want?
* @param notify function to call when buffer space is available;
* will be called with NULL on timeout or if the overall queue
* NULL if we can not even queue the request (insufficient
* memory); if NULL is returned, "notify" will NOT be called.
*/
-struct GNUNET_MESH_TransmitHandle *
-GNUNET_MESH_notify_transmit_ready (struct
- GNUNET_MESH_Tunnel
- *tunnel,
- int cork,
- uint32_t priority,
- struct
- GNUNET_TIME_Relative
- maxdelay,
- size_t
- notify_size,
- GNUNET_CONNECTION_TransmitReadyNotify
- notify,
- void
- *notify_cls);
+struct GNUNET_MESH_TransmitHandle *GNUNET_MESH_notify_transmit_ready (struct
+ GNUNET_MESH_Tunnel
+ *tunnel,
+ int cork,
+ uint32_t
+ priority,
+ struct
+ GNUNET_TIME_Relative
+ maxdelay,
+ const
+ struct
+ GNUNET_PeerIdentity
+ *target,
+ size_t
+ notify_size,
+ GNUNET_CONNECTION_TransmitReadyNotify
+ notify,
+ void
+ *notify_cls);
/**
*
* @param th handle that was returned by "notify_transmit_ready".
*/
-void
-GNUNET_MESH_notify_transmit_ready_cancel (struct GNUNET_MESH_TransmitHandle
- *th);
-
+void GNUNET_MESH_notify_transmit_ready_cancel (struct GNUNET_MESH_TransmitHandle
+ *th);
+
+void GNUNET_MESH_tunnel_set_head (struct GNUNET_MESH_Tunnel *tunnel,
+ void *head);
+void GNUNET_MESH_tunnel_set_tail (struct GNUNET_MESH_Tunnel *tunnel,
+ void *tail);
+void *GNUNET_MESH_tunnel_get_head (struct GNUNET_MESH_Tunnel *tunnel);
+void *GNUNET_MESH_tunnel_get_tail (struct GNUNET_MESH_Tunnel *tunnel);
+
+void GNUNET_MESH_tunnel_set_data (struct GNUNET_MESH_Tunnel *tunnel,
+ void *data);
+void *GNUNET_MESH_tunnel_get_data (struct GNUNET_MESH_Tunnel *tunnel);
#if 0 /* keep Emacsens' auto-indent happy */
{