GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
- by the Free Software Foundation; either version 2, or (at your
+ by the Free Software Foundation; either version 3, or (at your
option) any later version.
GNUnet is distributed in the hope that it will be useful, but
/**
- * Method called whenever a given peer either connects or
- * disconnects (or list of connections was requested).
+ * Method called whenever a given peer connects.
*
* @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'
*/
-typedef void (*GNUNET_CORE_ClientEventHandler) (void *cls,
- const struct
- GNUNET_PeerIdentity * peer);
+typedef void (*GNUNET_CORE_ConnectEventHandler) (void *cls,
+ const struct
+ GNUNET_PeerIdentity * peer,
+ struct GNUNET_TIME_Relative latency,
+ uint32_t distance);
+
+/**
+ * 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
+ */
+typedef void (*GNUNET_CORE_PeerStatusEventHandler) (void *cls,
+ const struct
+ GNUNET_PeerIdentity * peer,
+ struct GNUNET_TIME_Relative latency,
+ uint32_t distance,
+ struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
+ struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
+ struct GNUNET_TIME_Absolute timeout);
+
+
+/**
+ * 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);
/**
* @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'
* @return GNUNET_OK to keep the connection open,
* GNUNET_SYSERR to close it (signal serious error)
*/
(*GNUNET_CORE_MessageCallback) (void *cls,
const struct GNUNET_PeerIdentity * other,
const struct GNUNET_MessageHeader *
- message);
+ message,
+ struct GNUNET_TIME_Relative latency,
+ uint32_t distance);
/**
/**
- * Connect to the core service. Note that the connection may
- * complete (or fail) asynchronously.
+ * Connect to the core service. Note that the connection may complete
+ * (or fail) asynchronously. This function primarily causes the given
+ * callback notification functions to be invoked whenever the
+ * specified event happens. The maximum number of queued
+ * notifications (queue length) is per client but the queue is shared
+ * across all types of notifications. So a slow client that registers
+ * for 'outbound_notify' also risks missing 'inbound_notify' messages.
+ * Certain events (such as connect/disconnect notifications) are not
+ * subject to queue size limitations.
*
* @param sched scheduler to use
* @param cfg configuration to use
* connected to the core service; note that timeout is only meaningful if init is not NULL
* @param connects function to call on peer connect, can be NULL
* @param disconnects function to call on peer disconnect / timeout, can be NULL
+ * @param status_events function to call on peer status changes, can be NULL
* @param inbound_notify function to call for all inbound messages, can be NULL
+ * note that the core 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 inbound_hdr_only set to GNUNET_YES if inbound_notify will only read the
* GNUNET_MessageHeader and hence we do not need to give it the full message;
- * can be used to improve efficiency, ignored if inbound_notify is NULLL
- * @param outbound_notify function to call for all outbound messages, can be NULL
+ * can be used to improve efficiency, ignored if inbound_notify is NULL
+ * note that the core 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 outbound_notify function to call for all outbound messages, can be NULL;
+ * note that the core is allowed to drop notifications about outbound
+ * messages if the client does not process them fast enough (for this
+ * notification type, a bounded queue is used)
* @param outbound_hdr_only set to GNUNET_YES if outbound_notify will only read the
* GNUNET_MessageHeader and hence we do not need to give it the full message
- * can be used to improve efficiency, ignored if outbound_notify is NULLL
+ * can be used to improve efficiency, ignored if outbound_notify is NULL
+ * note that the core is allowed to drop notifications about outbound
+ * messages if the client does not process them fast enough (for this
+ * notification type, a bounded queue is used)
* @param handlers callbacks for messages we care about, NULL-terminated
+ * note that the core 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 core service (only useful for disconnect until 'init' is called),
* NULL on error (in this case, init is never called)
*/
struct GNUNET_TIME_Relative timeout,
void *cls,
GNUNET_CORE_StartupCallback init,
- GNUNET_CORE_ClientEventHandler connects,
- GNUNET_CORE_ClientEventHandler disconnects,
+ GNUNET_CORE_ConnectEventHandler connects,
+ GNUNET_CORE_DisconnectEventHandler disconnects,
+ GNUNET_CORE_PeerStatusEventHandler status_events,
GNUNET_CORE_MessageCallback inbound_notify,
int inbound_hdr_only,
GNUNET_CORE_MessageCallback outbound_notify,
void GNUNET_CORE_disconnect (struct GNUNET_CORE_Handle *handle);
-// FIXME
+/**
+ * Handle for a request to the core to connect or disconnect
+ * from a particular peer. Can be used to cancel the request
+ * (before the 'cont'inuation is called).
+ */
struct GNUNET_CORE_PeerRequestHandle;
-// FIXME
+
+/**
+ * Request that the core should try to connect to a particular peer.
+ * Once the request has been transmitted to the core, the continuation
+ * function will be called. Note that this does NOT mean that a
+ * connection was successfully established -- it only means that the
+ * core will now try. Successful establishment of the connection
+ * will be signalled to the 'connects' callback argument of
+ * 'GNUNET_CORE_connect' only. If the core service does not respond
+ * 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 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)
+ * @param cont_cls closure for cont
+ * @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,
- const struct GNUNET_PeerIdentity * peer,
- GNUNET_SCHEDULER_Task cont,
- void *cont_cls);
+ const struct GNUNET_CONFIGURATION_Handle *cfg,
+ struct GNUNET_TIME_Relative timeout,
+ const struct GNUNET_PeerIdentity * peer,
+ GNUNET_SCHEDULER_Task cont,
+ void *cont_cls);
-// FIXME
-struct GNUNET_CORE_PeerRequestHandle *
-GNUNET_CORE_peer_request_disconnect (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
- const struct GNUNET_PeerIdentity * peer,
- GNUNET_SCHEDULER_Task cont,
- void *cont_cls);
-
-// FIXME
+/**
+ * Cancel a pending request to connect to a particular peer. Must not
+ * be called after the 'cont' function was invoked.
+ *
+ * @param req request handle that was returned for the original request
+ */
void
-GNUNET_CORE_peer_request_cancel (struct GNUNET_CORE_PeerRequestHandle *req);
+GNUNET_CORE_peer_request_connect_cancel (struct GNUNET_CORE_PeerRequestHandle *req);
/**
* @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 amount set to the amount that was actually reserved or unreserved
+ * @param amount set to the amount that was actually reserved or unreserved;
+ * either the full requested amount or zero (no partial reservations)
* @param preference current traffic preference for the given peer
*/
typedef void
(*GNUNET_CORE_PeerConfigurationInfoCallback) (void *cls,
const struct
GNUNET_PeerIdentity * peer,
- unsigned int bpm_in,
- unsigned int bpm_out,
- struct GNUNET_TIME_Relative
- latency, int amount,
- unsigned long long preference);
+ struct GNUNET_BANDWIDTH_Value32NBO bpm_in,
+ struct GNUNET_BANDWIDTH_Value32NBO bpm_out,
+ int amount,
+ uint64_t preference);
*/
struct GNUNET_CORE_InformationRequestContext;
+
/**
* Obtain statistics and/or change preferences for the given peer.
*
* @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 bpm_out set to the current bandwidth limit (sending) for this peer,
+ * @param bw_out set to the current bandwidth limit (sending) for this peer,
* caller should set "bpm_out" to "-1" to avoid changing
- * the current value; otherwise "bpm_out" will be lowered to
+ * 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; "bpm_out" might not increase
+ * us to disconnect from the peer; "bw_out" might not increase
* as specified since the upper bound is generally
* determined by the other peer!
* @param amount reserve N bytes for receiving, negative
* @return NULL on error
*/
struct GNUNET_CORE_InformationRequestContext *
-GNUNET_CORE_peer_get_info (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
- const struct GNUNET_PeerIdentity *peer,
- struct GNUNET_TIME_Relative timeout,
- uint32_t bpm_out,
- int32_t amount,
- uint64_t preference,
- GNUNET_CORE_PeerConfigurationInfoCallback info,
- void *info_cls);
+GNUNET_CORE_peer_change_preference (struct GNUNET_SCHEDULER_Handle *sched,
+ const struct GNUNET_CONFIGURATION_Handle *cfg,
+ const struct GNUNET_PeerIdentity *peer,
+ struct GNUNET_TIME_Relative timeout,
+ struct GNUNET_BANDWIDTH_Value32NBO bw_out,
+ int32_t amount,
+ uint64_t preference,
+ GNUNET_CORE_PeerConfigurationInfoCallback info,
+ void *info_cls);
/**
* @param irc context returned by the original GNUNET_CORE_peer_get_info call
*/
void
-GNUNET_CORE_peer_get_info_cancel (struct GNUNET_CORE_InformationRequestContext *irc);
+GNUNET_CORE_peer_change_preference_cancel (struct GNUNET_CORE_InformationRequestContext *irc);
+/**
+ * Obtain statistics and/or change preferences for the given peer.
+ *
+ * @param sched scheduler to use
+ * @param cfg configuration to use
+ * @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_iterate_peers (struct GNUNET_SCHEDULER_Handle *sched,
+ const struct GNUNET_CONFIGURATION_Handle *cfg,
+ GNUNET_CORE_ConnectEventHandler peer_cb,
+ void *cb_cls);
/**
* Handle for a transmission request.
GNUNET_CORE_notify_transmit_ready (struct
GNUNET_CORE_Handle
*handle,
- unsigned
- int
- priority,
+ uint32_t priority,
struct
GNUNET_TIME_Relative
maxdelay,
/**
* Cancel the specified transmission-ready notification.
*
- * @param h handle that was returned by "notify_transmit_ready".
+ * @param th handle that was returned by "notify_transmit_ready".
*/
void
GNUNET_CORE_notify_transmit_ready_cancel (struct GNUNET_CORE_TransmitHandle
- *h);
+ *th);
#if 0 /* keep Emacsens' auto-indent happy */
projects / oweals / gnunet.git / blobdiff