[GNUnet-SVN] r14918 - gnunet/src/mesh

[gnunet]

Author: bartpolot
Date: 2011-04-07 17:18:48 +0200 (Thu, 07 Apr 2011)
New Revision: 14918

Modified:
   gnunet/src/mesh/gnunet-service-mesh.c
   gnunet/src/mesh/mesh_api_new.c
Log:
Work in progress, fix compile error


Modified: gnunet/src/mesh/gnunet-service-mesh.c
===================================================================
--- gnunet/src/mesh/gnunet-service-mesh.c       2011-04-07 14:51:15 UTC (rev 
14917)
+++ gnunet/src/mesh/gnunet-service-mesh.c       2011-04-07 15:18:48 UTC (rev 
14918)
@@ -255,6 +255,7 @@
     uint32_t                    max_speed;
 };
 
+
 typedef uint32_t MESH_PathID;
 /**
  * Information regarding a path
@@ -277,7 +278,7 @@
     GNUNET_PEER_Id              *peers;
 };
 
-typedef uint32_t MESH_TunnelID;
+
 /**
  * Struct containing all information regarding a tunnel
  * For an intermediate node the improtant info used will be:

Modified: gnunet/src/mesh/mesh_api_new.c
===================================================================
--- gnunet/src/mesh/mesh_api_new.c      2011-04-07 14:51:15 UTC (rev 14917)
+++ gnunet/src/mesh/mesh_api_new.c      2011-04-07 15:18:48 UTC (rev 14918)
@@ -55,6 +55,7 @@
     GNUNET_MESH_TunnelConnectHandler            connect_handler;
     GNUNET_MESH_TunnelDisconnectHandler         disconnect_handler;
     GNUNET_PEER_Id                              *peers;
+    void                                        *cls;
 };
 
 
@@ -62,14 +63,15 @@
  * 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)
+ * @param cls closure for the various callbacks that follow
+ *            (including handlers in the handlers array)
  * @param cleaner function called when an *inbound* tunnel is destroyed
  * @param handlers callbacks for messages we care about, NULL-terminated
- *                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)
+ *                 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)
  * @return handle to the mesh service 
- *           NULL on error (in this case, init is never called)
+ *         NULL on error (in this case, init is never called)
  */
 struct GNUNET_MESH_Handle *
 GNUNET_MESH_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
@@ -84,18 +86,22 @@
     return h;
 }
 
+
 /**
  * Disconnect from the mesh service.
  *
  * @param handle connection to mesh to disconnect
  */
 void GNUNET_MESH_disconnect (struct GNUNET_MESH_Handle *handle) {
+    
+    GNUNET_free(handle);
     return;
 }
 
+
 /**
- * Create a new tunnel (we're initiator and will be allowed to add/remove 
peers and
- * to broadcast).
+ * Create a new tunnel (we're initiator and will be allowed to add/remove peers
+ * and to broadcast).
  *
  * @param h mesh handle
  * @param connect_handler function to call when peers are actually connected
@@ -104,8 +110,10 @@
  */
 struct GNUNET_MESH_Tunnel *
 GNUNET_MESH_tunnel_create (struct GNUNET_MESH_Handle *h,
-                           GNUNET_MESH_TunnelConnectHandler connect_handler,
-                           GNUNET_MESH_TunnelDisconnectHandler 
disconnect_handler,
+                           GNUNET_MESH_TunnelConnectHandler
+                           connect_handler,
+                           GNUNET_MESH_TunnelDisconnectHandler
+                           disconnect_handler,
                            void *handler_cls) {
     GNUNET_MESH_Tunnel *tunnel;
     tunnel = GNUNET_malloc(sizeof(GNUNET_MESH_Tunnel));
@@ -113,10 +121,110 @@
     tunnel->connect_handler = connect_handler;
     tunnel->disconnect_handler = disconnect_handler;
     tunnel->peers = NULL;
+    tunnel->cls = handler_cls;
 
     return tunnel;
 }
 
+
+/**
+ * Request that a peer should be added to the tunnel.  The existing
+ * connect handler will be called ONCE with either success or failure.
+ *
+ * @param tunnel handle to existing tunnel
+ * @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) {
+    static GNUNET_PEER_Id       peer_id;
+    
+    peer_id = GNUNET_PEER_intern(peer);
+    
+    /* FIXME ACTUALLY DO STUFF */
+    tunnel->peers = &peer;
+    tunnel->connect_handler(tunnel->cls, peer, NULL);
+    return;
+}
+
+
+/**
+ * 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) {
+    /* FIXME ACTUALLY DO STUFF */
+    tunnel->peers = NULL;
+    tunnel->disconnect_handler(tunnel->cls, peer);
+    return;
+}
+
+
+/**
+ * Request that the mesh should try to connect to a peer supporting the given
+ * message type.
+ *
+ * @param tunnel handle to existing tunnel
+ * @param timeout how long to try to establish a connection
+ * @param app_type application type that must be supported by the peer (MESH
+ *                 should discover peer in proximity handling this type)
+ */
+void
+GNUNET_MESH_peer_request_connect_by_type (struct GNUNET_MESH_Tunnel *tunnel,
+                                          struct GNUNET_TIME_Relative timeout,
+                                          GNUNET_MESH_ApplicationType
+                                          app_type) {
+    return;
+}
+
+
+/**
+ * Ask the mesh to call "notify" once it is ready to transmit the
+ * given number of bytes to the specified "target".  If we are not yet
+ * connected to the specified peer, a call to this function will cause
+ * us to try to establish a connection.
+ *
+ * @param tunnel tunnel to use for transmission
+ * @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
+ *        for this peer is larger than queue_size and this is currently
+ *        the message with the lowest priority
+ * @param notify_cls closure for notify
+ * @return non-NULL if the notify callback was queued,
+ *         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,
+                                   const struct GNUNET_PeerIdentity *target,
+                                   size_t notify_size,
+                                   GNUNET_CONNECTION_TransmitReadyNotify
+                                   notify,
+                                   void *notify_cls) {
+    struct GNUNET_MESH_Handle   *handle;
+
+    handle = GNUNET_malloc(sizeof(GNUNET_MESH_Handle));
+
+    return handle;
+}
+
+
 #if 0                           /* keep Emacsens' auto-indent happy */
 {
 #endif