From 47afb3b4c553e503e0fed668c9d9f31c43518410 Mon Sep 17 00:00:00 2001 From: Bart Polot Date: Thu, 7 Apr 2011 15:18:48 +0000 Subject: Work in progress, fix compile error --- src/mesh/gnunet-service-mesh.c | 3 +- src/mesh/mesh_api_new.c | 126 ++++++++++++++++++++++++++++++++++++++--- 2 files changed, 119 insertions(+), 10 deletions(-) (limited to 'src') diff --git a/src/mesh/gnunet-service-mesh.c b/src/mesh/gnunet-service-mesh.c index e927d2737..145807338 100644 --- a/src/mesh/gnunet-service-mesh.c +++ b/src/mesh/gnunet-service-mesh.c @@ -255,6 +255,7 @@ struct PeerInfo uint32_t max_speed; }; + typedef uint32_t MESH_PathID; /** * Information regarding a path @@ -277,7 +278,7 @@ struct Path 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: diff --git a/src/mesh/mesh_api_new.c b/src/mesh/mesh_api_new.c index f7b0e9034..2c292f7f1 100644 --- a/src/mesh/mesh_api_new.c +++ b/src/mesh/mesh_api_new.c @@ -55,6 +55,7 @@ struct GNUNET_MESH_Tunnel { GNUNET_MESH_TunnelConnectHandler connect_handler; GNUNET_MESH_TunnelDisconnectHandler disconnect_handler; GNUNET_PEER_Id *peers; + void *cls; }; @@ -62,14 +63,15 @@ struct GNUNET_MESH_Tunnel { * 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 @@ GNUNET_MESH_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, 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 @@ void GNUNET_MESH_disconnect (struct GNUNET_MESH_Handle *handle) { */ 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 @@ GNUNET_MESH_tunnel_create (struct GNUNET_MESH_Handle *h, 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 -- cgit v1.2.3