#endif
#include "gnunet_util_lib.h"
+#include "gnunet_transport_service.h"
/**
* Version number of GNUnet-core API.
*
* @param cls closure
* @param peer peer identity this notification is about
- * @param latency reported latency of the connection with 'other'
- * @param distance reported distance (DV) to 'other'
+ * @param atsi performance data for the connection
*/
typedef void (*GNUNET_CORE_ConnectEventHandler) (void *cls,
const struct
- GNUNET_PeerIdentity * peer,
- struct GNUNET_TIME_Relative latency,
- uint32_t distance);
+ GNUNET_PeerIdentity *peer,
+ const struct GNUNET_TRANSPORT_ATS_Information *atsi);
+
/**
* Method called whenever a given peer has a status change.
*
* @param cls closure
* @param peer peer identity this notification is about
- * @param latency reported latency of the connection with 'other'
- * @param distance reported distance (DV) to 'other'
- * @param bandwidth_in available amount of inbound bandwidth
- * @param bandwidth_out available amount of outbound bandwidth
* @param timeout absolute time when this peer will time out
* unless we see some further activity from it
+ * @param bandwidth_in available amount of inbound bandwidth
+ * @param bandwidth_out available amount of outbound bandwidth
+ * @param atsi performance data for the connection
*/
typedef void (*GNUNET_CORE_PeerStatusEventHandler) (void *cls,
const struct
- GNUNET_PeerIdentity * peer,
- struct GNUNET_TIME_Relative latency,
- uint32_t distance,
+ GNUNET_PeerIdentity *peer,
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
- struct GNUNET_TIME_Absolute timeout);
+ struct GNUNET_TIME_Absolute timeout,
+ const struct GNUNET_TRANSPORT_ATS_Information *atsi);
/**
- * Method called whenever a given peer either disconnects.
+ * Method called whenever a peer disconnects.
*
* @param cls closure
* @param peer peer identity this notification is about
*/
typedef void (*GNUNET_CORE_DisconnectEventHandler) (void *cls,
const struct
- GNUNET_PeerIdentity * peer);
+ GNUNET_PeerIdentity *peer);
/**
* Functions with this signature are called whenever a message is
* received or transmitted.
*
- * @param cls closure
+ * @param cls closure (set from GNUNET_CORE_connect)
* @param peer the other peer involved (sender or receiver, NULL
* for loopback messages where we are both sender and receiver)
* @param message the actual message
- * @param latency reported latency of the connection with 'other'
- * @param distance reported distance (DV) to 'other'
+ * @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_CORE_MessageCallback) (void *cls,
- const struct GNUNET_PeerIdentity * other,
- const struct GNUNET_MessageHeader *
- message,
- struct GNUNET_TIME_Relative latency,
- uint32_t distance);
+ const struct GNUNET_PeerIdentity *other,
+ const struct GNUNET_MessageHeader *message,
+ const struct GNUNET_TRANSPORT_ATS_Information *atsi);
/**
* Certain events (such as connect/disconnect notifications) are not
* subject to queue size limitations.
*
- * @param sched scheduler to use
* @param cfg configuration to use
- * @param timeout after how long should we give up trying to connect to the core service?
+ * @param queue_size size of the per-peer message queue
* @param cls closure for the various callbacks that follow (including handlers in the handlers array)
* @param init callback to call on timeout or once we have successfully
* connected to the core service; note that timeout is only meaningful if init is not NULL
* NULL on error (in this case, init is never called)
*/
struct GNUNET_CORE_Handle *
-GNUNET_CORE_connect (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
- struct GNUNET_TIME_Relative timeout,
+GNUNET_CORE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
+ unsigned int queue_size,
void *cls,
GNUNET_CORE_StartupCallback init,
GNUNET_CORE_ConnectEventHandler connects,
/**
- * Disconnect from the core service.
+ * Disconnect from the core service. This function can only
+ * be called *after* all pending 'GNUNET_CORE_notify_transmit_ready'
+ * requests have been explicitly cancelled.
*
* @param handle connection to core to disconnect
*/
struct GNUNET_CORE_PeerRequestHandle;
+/**
+ * Type of function called upon completion.
+ *
+ * @param cls closure
+ * @param success GNUNET_OK on success (which for request_connect
+ * ONLY means that we transmitted the connect request to CORE,
+ * it does not mean that we are actually now connected!);
+ * GNUNET_NO on timeout,
+ * GNUNET_SYSERR if core was shut down
+ */
+typedef void (*GNUNET_CORE_ControlContinuation)(void *cls, int success);
+
+
/**
* Request that the core should try to connect to a particular peer.
* Once the request has been transmitted to the core, the continuation
* to our connection attempt within the given time frame, 'cont' will
* be called with the TIMEOUT reason code.
*
- * @param sched scheduler to use
- * @param cfg configuration to use
+ * @param h core handle
* @param timeout how long to try to talk to core
* @param peer who should we connect to
* @param cont function to call once the request has been completed (or timed out)
* @return NULL on error (cont will not be called), otherwise handle for cancellation
*/
struct GNUNET_CORE_PeerRequestHandle *
-GNUNET_CORE_peer_request_connect (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_CORE_peer_request_connect (struct GNUNET_CORE_Handle *h,
struct GNUNET_TIME_Relative timeout,
const struct GNUNET_PeerIdentity * peer,
- GNUNET_SCHEDULER_Task cont,
+ GNUNET_CORE_ControlContinuation cont,
void *cont_cls);
/**
- * Function called with statistics about the given peer.
+ * Function called with perference change information about the given peer.
*
* @param cls closure
* @param peer identifies the peer
- * @param bpm_in set to the current bandwidth limit (receiving) for this peer
- * @param bpm_out set to the current bandwidth limit (sending) for this peer
- * @param latency current latency estimate, "FOREVER" if we have been
- * disconnected
+ * @param bandwidth_out available amount of outbound bandwidth
* @param amount set to the amount that was actually reserved or unreserved;
* either the full requested amount or zero (no partial reservations)
+ * @param res_delay if the reservation could not be satisfied (amount was 0), how
+ * long should the client wait until re-trying?
* @param preference current traffic preference for the given peer
*/
typedef void
(*GNUNET_CORE_PeerConfigurationInfoCallback) (void *cls,
const struct
- GNUNET_PeerIdentity * peer,
- struct GNUNET_BANDWIDTH_Value32NBO bpm_in,
- struct GNUNET_BANDWIDTH_Value32NBO bpm_out,
- int amount,
+ GNUNET_PeerIdentity *peer,
+ struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
+ int32_t amount,
+ struct GNUNET_TIME_Relative res_delay,
uint64_t preference);
/**
* Obtain statistics and/or change preferences for the given peer.
+ * You can only have one such pending request per peer.
*
- * @param sched scheduler to use
- * @param cfg configuration to use
+ * @param h core handle
* @param peer identifies the peer
* @param timeout after how long should we give up (and call "info" with NULL
* for "peer" to signal an error)?
* @param bw_out set to the current bandwidth limit (sending) for this peer,
- * caller should set "bpm_out" to "-1" to avoid changing
+ * caller should set "bpm_out" to "GNUNET_BANDWIDTH_VALUE_MAX" to avoid changing
* the current value; otherwise "bw_out" will be lowered to
* the specified value; passing a pointer to "0" can be used to force
* us to disconnect from the peer; "bw_out" might not increase
* @return NULL on error
*/
struct GNUNET_CORE_InformationRequestContext *
-GNUNET_CORE_peer_change_preference (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_CORE_peer_change_preference (struct GNUNET_CORE_Handle *h,
const struct GNUNET_PeerIdentity *peer,
struct GNUNET_TIME_Relative timeout,
struct GNUNET_BANDWIDTH_Value32NBO bw_out,
/**
* Cancel request for getting information about a peer.
+ * Note that an eventual change in preference, trust or bandwidth
+ * assignment MAY have already been committed at the time,
+ * so cancelling a request is NOT sure to undo the original
+ * request. The original request may or may not still commit.
+ * The only thing cancellation ensures is that the callback
+ * from the original request will no longer be called.
*
* @param irc context returned by the original GNUNET_CORE_peer_get_info call
*/
GNUNET_CORE_peer_change_preference_cancel (struct GNUNET_CORE_InformationRequestContext *irc);
+/**
+ * Iterate over all connected peers.
+ *
+ * @param cfg configuration handle
+ * @param peer_cb function to call with the peer information
+ * @param cb_cls closure for peer_cb
+ * @return GNUNET_OK on success, GNUNET_SYSERR on errors
+ */
+int
+GNUNET_CORE_iterate_peers (const struct GNUNET_CONFIGURATION_Handle *cfg,
+ GNUNET_CORE_ConnectEventHandler peer_cb,
+ void *cb_cls);
+
+/**
+ * Iterate over all currently connected peers.
+ * Calls peer_cb with each connected peer, and then
+ * once with NULL to indicate that all peers have
+ * been handled.
+ *
+ * @param cfg configuration to use
+ * @param peer the specific peer to check for
+ * @param peer_cb function to call with the peer information
+ * @param cb_cls closure for peer_cb
+ *
+ * @return GNUNET_OK if iterating, GNUNET_SYSERR on error
+ */
+int
+GNUNET_CORE_is_peer_connected (const struct GNUNET_CONFIGURATION_Handle *cfg,
+ struct GNUNET_PeerIdentity *peer,
+ GNUNET_CORE_ConnectEventHandler peer_cb,
+ void *cb_cls);
+
+
/**
* Handle for a transmission request.
*/
/**
* Ask the core 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.
+ * given number of bytes to the specified "target". Must only be
+ * called after a connection to the respective peer has been
+ * established (and the client has been informed about this).
+ *
*
* @param handle connection to core service
+ * @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 who should receive the message,
* use NULL for this peer (loopback)
* @param notify_size how many bytes of buffer space does notify want?
- * @param notify function to call when buffer space is available
+ * @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; will also be called
+ * with 'NULL' buf if the peer disconnects; since the disconnect
+ * signal will be emmitted even later, clients MUST cancel
+ * all pending transmission requests DURING the disconnect
+ * handler (unless they ensure that 'notify' never calls
+ * 'GNUNET_CORE_notify_transmit_ready').
* @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
GNUNET_CORE_notify_transmit_ready (struct
GNUNET_CORE_Handle
*handle,
+ int cork,
uint32_t priority,
struct
GNUNET_TIME_Relative
projects / oweals / gnunet.git / blobdiff