really reuse the dns-tunnel

[oweals/gnunet.git] / src / include / gnunet_mesh_service.h

diff --git a/src/include/gnunet_mesh_service.h b/src/include/gnunet_mesh_service.h
index 1677c714cc0676bac78ebee1f9b8ae1fe819e516..25744248bf69c61f29650d95fb6a52bfa3318dcf 100644 (file)
--- a/src/include/gnunet_mesh_service.h
+++ b/src/include/gnunet_mesh_service.h
@@ -61,6 +61,7 @@ struct GNUNET_MESH_Tunnel;
  * @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,
@@ -70,6 +71,7 @@ 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);
 
@@ -113,6 +115,12 @@ typedef void (GNUNET_MESH_TunnelEndHandler)(void *cls,
                                            void **tunnel_ctx);
 
 
+/**
+ * Type for an application.  Values defined in gnunet_applications.h
+ */
+typedef uint32_t GNUNET_MESH_ApplicationType;
+
+
 /**
  * Connect to the mesh service.
  *
@@ -123,6 +131,7 @@ typedef void (GNUNET_MESH_TunnelEndHandler)(void *cls,
  *                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)
  */
@@ -130,8 +139,8 @@ 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 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
@@ -248,13 +257,25 @@ GNUNET_MESH_peer_request_connect_add (struct GNUNET_MESH_Tunnel *tunnel,
                                      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);
+
+
 /**
  * Request that the mesh should try to connect to a peer supporting the given
  * message type.
  *
  * @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
@@ -268,7 +289,7 @@ GNUNET_MESH_peer_request_connect_add (struct GNUNET_MESH_Tunnel *tunnel,
 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_ApplicationType app_type,
                                          GNUNET_MESH_TunnelConnectHandler connect_handler,
                                          GNUNET_MESH_TunnelDisconnectHandler disconnect_handler,
                                          void *handler_cls);
@@ -300,6 +321,7 @@ struct GNUNET_MESH_TransmitHandle;
  * @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
@@ -319,6 +341,7 @@ GNUNET_MESH_notify_transmit_ready (struct
                                   struct
                                   GNUNET_TIME_Relative
                                   maxdelay,
+                                  const struct GNUNET_PeerIdentity *target,
                                   size_t
                                   notify_size,
                                   GNUNET_CONNECTION_TransmitReadyNotify
@@ -336,6 +359,13 @@ 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 */
 {