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
#endif
#include "gnunet_util_lib.h"
+#include "gnunet_transport_service.h"
/**
* Version number of GNUnet-core API.
/**
- * Method called whenever a given peer either connects.
+ * 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'
+ * @param atsi performance data for the connection
+ * @param atsi_count number of records in 'atsi'
*/
typedef void (*GNUNET_CORE_ConnectEventHandler) (void *cls,
- const struct
- GNUNET_PeerIdentity * peer,
- struct GNUNET_TIME_Relative latency,
- uint32_t distance);
-
+ const struct
+ GNUNET_PeerIdentity * peer,
+ const struct
+ GNUNET_ATS_Information * atsi,
+ unsigned int atsi_count);
/**
- * 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);
+ const struct
+ 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
+ * @param atsi_count number of records in 'atsi'
* @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);
+typedef int (*GNUNET_CORE_MessageCallback) (void *cls,
+ const struct GNUNET_PeerIdentity *
+ other,
+ const struct GNUNET_MessageHeader *
+ message,
+ const struct GNUNET_ATS_Information
+ * atsi, unsigned int atsi_count);
/**
/**
- * Function called after GNUNET_CORE_connect has succeeded
- * (or failed for good). Note that the private key of the
- * peer is intentionally not exposed here; if you need it,
- * your process should try to read the private key file
- * directly (which should work if you are authorized...).
+ * Function called after GNUNET_CORE_connect has succeeded (or failed
+ * for good). Note that the private key of the peer is intentionally
+ * not exposed here; if you need it, your process should try to read
+ * the private key file directly (which should work if you are
+ * authorized...).
*
* @param cls closure
* @param server handle to the server, NULL if we failed
* @param my_identity ID of this peer, NULL if we failed
- * @param publicKey public key of this peer, NULL if we failed
*/
-typedef void
- (*GNUNET_CORE_StartupCallback) (void *cls,
- struct GNUNET_CORE_Handle * server,
- const struct GNUNET_PeerIdentity *
- my_identity,
- const struct
- GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *
- publicKey);
+typedef void (*GNUNET_CORE_StartupCallback) (void *cls,
+ struct GNUNET_CORE_Handle * server,
+ const struct GNUNET_PeerIdentity *
+ my_identity);
/**
- * 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
- * @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
- * @param pre_connects function to call on peer pre-connect (no session key yet), can be 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 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_CORE_Handle *
-GNUNET_CORE_connect (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
- struct GNUNET_TIME_Relative timeout,
- void *cls,
+GNUNET_CORE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
+ unsigned int queue_size, void *cls,
GNUNET_CORE_StartupCallback init,
- GNUNET_CORE_ConnectEventHandler pre_connects,
GNUNET_CORE_ConnectEventHandler connects,
GNUNET_CORE_DisconnectEventHandler disconnects,
GNUNET_CORE_MessageCallback inbound_notify,
/**
- * 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
*/
-void GNUNET_CORE_disconnect (struct GNUNET_CORE_Handle *handle);
-
-
-/**
- * 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;
-
-
-/**
- * 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 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,
- struct GNUNET_TIME_Relative timeout,
- const struct GNUNET_PeerIdentity * peer,
- GNUNET_SCHEDULER_Task cont,
- void *cont_cls);
-
-
-/**
- * Request that the core should try to disconnect from 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 cut -- it only means that the
- * core will now try. Typically this will work pretty much
- * immediately, but it is at least in theory also possible that a
- * reconnect is also triggered rather quickly. Successful creation
- * and destruction of connections will be signalled to the 'connects'
- * and 'disconnects' callback arguments 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 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_disconnect (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
- struct GNUNET_TIME_Relative timeout,
- const struct GNUNET_PeerIdentity * peer,
- GNUNET_SCHEDULER_Task cont,
- void *cont_cls);
-
-
-/**
- * Cancel a pending request to connect or disconnect from/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);
-
-
-/**
- * Function called with statistics 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 amount set to the amount that was actually reserved or unreserved
- * @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,
- int amount,
- uint64_t preference);
-
-
-
-/**
- * Context that can be used to cancel a peer information request.
- */
-struct GNUNET_CORE_InformationRequestContext;
-
-/**
- * Obtain statistics and/or change preferences for the given peer.
- *
- * @param sched scheduler to use
- * @param cfg configuration to use
- * @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,
- * caller should set "bpm_out" to "-1" to avoid changing
- * the current value; otherwise "bpm_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
- * as specified since the upper bound is generally
- * determined by the other peer!
- * @param amount reserve N bytes for receiving, negative
- * amounts can be used to undo a (recent) reservation;
- * @param preference increase incoming traffic share preference by this amount;
- * in the absence of "amount" reservations, we use this
- * preference value to assign proportional bandwidth shares
- * to all connected peers
- * @param info function to call with the resulting configuration information
- * @param info_cls closure for info
- * @return NULL on error
- */
-struct GNUNET_CORE_InformationRequestContext *
-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,
- uint32_t bpm_out,
- int32_t amount,
- uint64_t preference,
- GNUNET_CORE_PeerConfigurationInfoCallback info,
- void *info_cls);
-
-
-/**
- * Cancel request for getting information about a peer.
- *
- * @param irc context returned by the original GNUNET_CORE_peer_get_info call
- */
void
-GNUNET_CORE_peer_change_preference_cancel (struct GNUNET_CORE_InformationRequestContext *irc);
+GNUNET_CORE_disconnect (struct GNUNET_CORE_Handle *handle);
/**
/**
* 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
* memory); if NULL is returned, "notify" will NOT be called.
*/
struct GNUNET_CORE_TransmitHandle *
-GNUNET_CORE_notify_transmit_ready (struct
- GNUNET_CORE_Handle
- *handle,
- uint32_t priority,
- struct
- GNUNET_TIME_Relative
- maxdelay,
- const
- struct
- GNUNET_PeerIdentity
- *target,
- size_t
- notify_size,
- GNUNET_CONNECTION_TransmitReadyNotify
- notify,
- void
- *notify_cls);
+GNUNET_CORE_notify_transmit_ready (struct GNUNET_CORE_Handle *handle, 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);
/**
* 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);
+
+
+
+
+
+/**
+ * Iterate over all connected peers. Calls peer_cb with each
+ * connected peer, and then once with NULL to indicate that all peers
+ * have been handled. Normal users of the CORE API are not expected
+ * to use this function. It is different in that it truly lists
+ * all connections, not just those relevant to the application. This
+ * function is used by special applications for diagnostics. This
+ * function is NOT part of the 'versioned', 'official' API.
+ *
+ * FIXME: we should probably make it possible to 'cancel' the
+ * operation...
+ *
+ * @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);
+
+
+/**
+ * Check if the given peer is currently connected and return information
+ * about the session if so. This function is for special cirumstances
+ * (GNUNET_TESTING uses it), normal users of the CORE API are
+ * expected to track which peers are connected based on the
+ * connect/disconnect callbacks from GNUNET_CORE_connect. This
+ * function is NOT part of the 'versioned', 'official' API.
+ *
+ * FIXME: we should probably make it possible to 'cancel' the
+ * operation...
+ *
+ * @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);
#if 0 /* keep Emacsens' auto-indent happy */