X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Finclude%2Fgnunet_core_service.h;h=1f6c0f329c64d169e44c006d2a5c2a38bc16af15;hb=83b19539f4d322b43683f5838b72e9ec2c8e6073;hp=a772813365f113ab50852d9f013ac830e761c98e;hpb=7bc466bbdb8b64cac68c5ee59eb7ab6b9d85c420;p=oweals%2Fgnunet.git diff --git a/src/include/gnunet_core_service.h b/src/include/gnunet_core_service.h index a77281336..1f6c0f329 100644 --- a/src/include/gnunet_core_service.h +++ b/src/include/gnunet_core_service.h @@ -1,10 +1,10 @@ /* This file is part of GNUnet. - (C) 2009 Christian Grothoff (and other contributing authors) + (C) 2009, 2010 Christian Grothoff (and other contributing authors) 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 @@ -37,6 +37,7 @@ extern "C" #endif #include "gnunet_util_lib.h" +#include "gnunet_transport_service.h" /** * Version number of GNUnet-core API. @@ -51,51 +52,52 @@ struct GNUNET_CORE_Handle; /** - * 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 atsi performance data for the connection + * @param atsi_count number of records in 'atsi' */ -typedef void (*GNUNET_CORE_ClientEventHandler) (void *cls, - const struct - GNUNET_PeerIdentity * peer); +typedef void (*GNUNET_CORE_ConnectEventHandler) (void *cls, + const struct + GNUNET_PeerIdentity * peer, + const struct + GNUNET_ATS_Information * atsi, + unsigned int atsi_count); /** - * Type of a send callback to fill up buffers. + * Method called whenever a peer disconnects. * - * @param receiver the receiver of the message - * @param position is the reference to the - * first unused position in the buffer where GNUnet is building - * the message - * @param padding is the number of bytes left in that buffer. - * @return the number of bytes written to - * that buffer (must be a positive number). + * @param cls closure + * @param peer peer identity this notification is about */ -typedef unsigned int - (*GNUNET_CORE_BufferFillCallback) (void *cls, - const struct GNUNET_PeerIdentity * - receiver, - void *position, unsigned int padding); +typedef void (*GNUNET_CORE_DisconnectEventHandler) (void *cls, + 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 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); +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); /** @@ -125,59 +127,73 @@ struct GNUNET_CORE_MessageHandler /** - * 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 + * 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 bfc function to call to fill up spare bandwidth, 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) */ -void -GNUNET_CORE_connect (struct GNUNET_SCHEDULER_Handle *sched, - const struct GNUNET_CONFIGURATION_Handle *cfg, - struct GNUNET_TIME_Relative timeout, - void *cls, +struct GNUNET_CORE_Handle * +GNUNET_CORE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, + unsigned int queue_size, void *cls, GNUNET_CORE_StartupCallback init, - GNUNET_CORE_ClientEventHandler connects, - GNUNET_CORE_ClientEventHandler disconnects, - GNUNET_CORE_BufferFillCallback bfc, + GNUNET_CORE_ConnectEventHandler connects, + GNUNET_CORE_DisconnectEventHandler disconnects, GNUNET_CORE_MessageCallback inbound_notify, int inbound_hdr_only, GNUNET_CORE_MessageCallback outbound_notify, @@ -186,67 +202,14 @@ GNUNET_CORE_connect (struct GNUNET_SCHEDULER_Handle *sched, /** - * 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); - - -/** - * Function called with statistics about the given peer. - * - * @param peer identifies the peer - * @param latency current latency estimate, "FOREVER" if we have been - * disconnected - * @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 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, - struct GNUNET_TIME_Relative - latency, int amount, - unsigned long long preference); - - -/** - * Obtain statistics and/or change preferences for the given peer. - * - * @param handle connection to core 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 - */ void -GNUNET_CORE_peer_configure (struct GNUNET_CORE_Handle *handle, - const struct GNUNET_PeerIdentity *peer, - struct GNUNET_TIME_Relative timeout, - unsigned int bpm_out, - int amount, - unsigned long long preference, - GNUNET_CORE_PeerConfigurationInfoCallback info, - void *info_cls); +GNUNET_CORE_disconnect (struct GNUNET_CORE_Handle *handle); /** @@ -257,51 +220,100 @@ struct GNUNET_CORE_TransmitHandle; /** * 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, - unsigned - int - priority, - struct - GNUNET_TIME_Relative - maxdelay, - const - struct - GNUNET_PeerIdentity - *target, - size_t - notify_size, - GNUNET_NETWORK_TransmitReadyNotify - notify, - void - *notify_cls); +struct GNUNET_CORE_TransmitHandle * +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 */