/*
This file is part of GNUnet.
- (C) 2009, 2010 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2009-2014 GNUnet e.V.
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
You should have received a copy of the GNU General Public License
along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
+ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
*/
-
/**
- * @file include/gnunet_core_service.h
- * @brief core service; this is the main API for encrypted P2P
- * communications
* @author Christian Grothoff
+ *
+ * @file include/gnunet_core_service.h
+ * Core service; the main API for encrypted P2P communications
+ *
+ * @defgroup core Core service
+ * Encrypted direct communication between peers
+ *
+ * @see [Documentation](https://gnunet.org/gnunet-core-subsystem)
+ *
+ * @{
*/
-
#ifndef GNUNET_CORE_SERVICE_H
#define GNUNET_CORE_SERVICE_H
/**
* Version number of GNUnet-core API.
*/
-#define GNUNET_CORE_VERSION 0x00000000
+#define GNUNET_CORE_VERSION 0x00000001
+
+/**
+ * Traffic priorities.
+ */
+enum GNUNET_CORE_Priority
+{
+
+ /**
+ * Lowest priority, i.e. background traffic (i.e. fs)
+ */
+ GNUNET_CORE_PRIO_BACKGROUND = 0,
+
+ /**
+ * Normal traffic (i.e. cadet/dv relay, DHT)
+ */
+ GNUNET_CORE_PRIO_BEST_EFFORT = 1,
+
+ /**
+ * Urgent traffic (local peer, i.e. conversation).
+ */
+ GNUNET_CORE_PRIO_URGENT = 2,
+
+ /**
+ * Highest priority, control traffic (i.e. NSE, Core/Cadet KX).
+ */
+ GNUNET_CORE_PRIO_CRITICAL_CONTROL = 3
+
+
+};
/**
*
* @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_ConnectEventHandler) (void *cls,
- const struct
- GNUNET_PeerIdentity * peer,
- const struct
- GNUNET_ATS_Information * atsi,
- unsigned int atsi_count);
+typedef void
+(*GNUNET_CORE_ConnectEventHandler) (void *cls,
+ const struct GNUNET_PeerIdentity *peer);
/**
* @param cls closure
* @param peer peer identity this notification is about
*/
-typedef void (*GNUNET_CORE_DisconnectEventHandler) (void *cls,
- const struct
- GNUNET_PeerIdentity * peer);
+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 (set from GNUNET_CORE_connect)
+ * @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)
+ * @return #GNUNET_OK to keep the connection open,
+ * #GNUNET_SYSERR to close connection to the peer (signal serious error)
*/
-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);
+typedef int
+(*GNUNET_CORE_MessageCallback) (void *cls,
+ const struct GNUNET_PeerIdentity *other,
+ const struct GNUNET_MessageHeader *message);
/**
struct GNUNET_CORE_MessageHandler
{
/**
- * Function to call for messages of "type".
+ * Function to call for messages of @e type.
*/
GNUNET_CORE_MessageCallback callback;
/**
- * Function called after GNUNET_CORE_connect has succeeded (or failed
+ * 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...).
+ * authorized...). Implementations of this function must not call
+ * #GNUNET_CORE_disconnect (other than by scheduling a new task to
+ * do this later).
*
* @param cls closure
- * @param server handle to the server, NULL if we failed
* @param my_identity ID 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);
+typedef void
+(*GNUNET_CORE_StartupCallback) (void *cls,
+ const struct GNUNET_PeerIdentity *my_identity);
/**
* (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
+ * notifications (queue length) is per client; the queue is shared
* across all types of notifications. So a slow client that registers
- * for 'outbound_notify' also risks missing 'inbound_notify' messages.
+ * for @a outbound_notify also risks missing @a inbound_notify messages.
* Certain events (such as connect/disconnect notifications) are not
* subject to queue size limitations.
*
* @param cfg configuration to use
- * @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 once we have successfully
* connected to the core service
* 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;
+ * @param inbound_hdr_only set to #GNUNET_YES if @a inbound_notify will only read the
+ * `struct 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 NULL
* note that the core is allowed to drop notifications about inbound
* messages if the client does not process them fast enough (for this
* 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
+ * @param outbound_hdr_only set to #GNUNET_YES if @a outbound_notify will only read the
+ * `struct 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 NULL
* note that the core is allowed to drop notifications about outbound
* messages if the client does not process them fast enough (for this
* 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),
+ * @return handle to the core service (only useful for disconnect until @a init is called),
* NULL on error (in this case, init is never called)
*/
struct GNUNET_CORE_Handle *
GNUNET_CORE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
- unsigned int queue_size, void *cls,
+ void *cls,
GNUNET_CORE_StartupCallback init,
GNUNET_CORE_ConnectEventHandler connects,
GNUNET_CORE_DisconnectEventHandler disconnects,
/**
* Disconnect from the core service. This function can only
- * be called *after* all pending 'GNUNET_CORE_notify_transmit_ready'
+ * be called *after* all pending #GNUNET_CORE_notify_transmit_ready
* requests have been explicitly cancelled.
*
* @param handle connection to core to disconnect
/**
- * Ask the core to call "notify" once it is ready to transmit the
- * given number of bytes to the specified "target". Must only be
+ * Ask the core to call @a notify once it is ready to transmit the
+ * given number of bytes to the specified @a target. Must only be
* called after a connection to the respective peer has been
- * established (and the client has been informed about this).
- *
+ * established (and the client has been informed about this). You may
+ * have one request of this type pending for each connected peer at
+ * any time. If a peer disconnects, the application MUST call
+ * #GNUNET_CORE_notify_transmit_ready_cancel() on the respective
+ * transmission request, if one such request is pending.
*
* @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 maxdelay how long can the message wait? Only effective if @a cork is #GNUNET_YES
* @param target who should receive the message, never NULL (can be this peer's identity for loopback)
- * @param notify_size how many bytes of buffer space does notify want?
+ * @param notify_size how many bytes of buffer space does @a 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; will also be called
- * with 'NULL' buf if the peer disconnects; since the disconnect
- * signal will be emmitted even later, clients MUST cancel
+ * will be called with NULL on timeout; 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
+ * handler
+ * @param notify_cls closure for @a 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.
+ * NULL if we can not even queue the request (request already pending);
+ * if NULL is returned, @a notify will NOT be called.
*/
struct GNUNET_CORE_TransmitHandle *
-GNUNET_CORE_notify_transmit_ready (struct GNUNET_CORE_Handle *handle, int cork,
- uint32_t priority,
+GNUNET_CORE_notify_transmit_ready (struct GNUNET_CORE_Handle *handle,
+ int cork,
+ enum GNUNET_CORE_Priority priority,
struct GNUNET_TIME_Relative maxdelay,
const struct GNUNET_PeerIdentity *target,
size_t notify_size,
/**
* Cancel the specified transmission-ready notification.
*
- * @param th handle that was returned by "notify_transmit_ready".
+ * @param th handle that was returned by #GNUNET_CORE_notify_transmit_ready().
*/
void
-GNUNET_CORE_notify_transmit_ready_cancel (struct GNUNET_CORE_TransmitHandle
- *th);
+GNUNET_CORE_notify_transmit_ready_cancel (struct GNUNET_CORE_TransmitHandle *th);
+/**
+ * Handle to a CORE monitoring operation.
+ */
+struct GNUNET_CORE_MonitorHandle;
+/**
+ * State machine for our P2P encryption handshake. Everyone starts in
+ * #GNUNET_CORE_KX_STATE_DOWN, if we receive the other peer's key
+ * (other peer initiated) we start in state
+ * #GNUNET_CORE_KX_STATE_KEY_RECEIVED (since we will immediately send
+ * our own); otherwise we start in #GNUNET_CORE_KX_STATE_KEY_SENT. If
+ * we get back a PONG from within either state, we move up to
+ * #GNUNET_CORE_KX_STATE_UP (the PONG will always be sent back
+ * encrypted with the key we sent to the other peer). Eventually,
+ * we will try to rekey, for this we will enter
+ * #GNUNET_CORE_KX_STATE_REKEY_SENT until the rekey operation is
+ * confirmed by a PONG from the other peer.
+ */
+enum GNUNET_CORE_KxState
+{
+ /**
+ * No handshake yet.
+ */
+ GNUNET_CORE_KX_STATE_DOWN,
+
+ /**
+ * We've sent our session key.
+ */
+ GNUNET_CORE_KX_STATE_KEY_SENT,
+
+ /**
+ * We've received the other peers session key.
+ */
+ GNUNET_CORE_KX_STATE_KEY_RECEIVED,
+
+ /**
+ * The other peer has confirmed our session key + PING with a PONG
+ * message encrypted with his session key (which we got). Key
+ * exchange is done.
+ */
+ GNUNET_CORE_KX_STATE_UP,
+
+ /**
+ * We're rekeying (or had a timeout), so we have sent the other peer
+ * our new ephemeral key, but we did not get a matching PONG yet.
+ * This is equivalent to being #GNUNET_CORE_KX_STATE_KEY_RECEIVED,
+ * except that the session is marked as 'up' with sessions (as we
+ * don't want to drop and re-establish P2P connections simply due to
+ * rekeying).
+ */
+ GNUNET_CORE_KX_STATE_REKEY_SENT,
+
+ /**
+ * Last state of a KX (when it is being terminated). Set
+ * just before CORE frees the internal state for this peer.
+ */
+ GNUNET_CORE_KX_PEER_DISCONNECT,
+
+ /**
+ * This is not a state in a peer's state machine, but a special
+ * value used with the #GNUNET_CORE_MonitorCallback to indicate
+ * that we finished the initial iteration over the peers.
+ */
+ GNUNET_CORE_KX_ITERATION_FINISHED,
+
+ /**
+ * This is not a state in a peer's state machine, but a special
+ * value used with the #GNUNET_CORE_MonitorCallback to indicate
+ * that we lost the connection to the CORE service (and will try
+ * to reconnect). If this happens, most likely the CORE service
+ * crashed and thus all connection state should be assumed lost.
+ */
+ GNUNET_CORE_KX_CORE_DISCONNECT
+
+};
+
/**
- * 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.
+ * Function called by the monitor callback whenever
+ * a peer's connection status changes.
*
- * FIXME: we should probably make it possible to 'cancel' the
- * operation...
+ * @param cls closure
+ * @param pid identity of the peer this update is about
+ * @param state current key exchange state of the peer
+ * @param timeout when does the current state expire
+ */
+typedef void
+(*GNUNET_CORE_MonitorCallback)(void *cls,
+ const struct GNUNET_PeerIdentity *pid,
+ enum GNUNET_CORE_KxState state,
+ struct GNUNET_TIME_Absolute timeout);
+
+
+/**
+ * Monitor connectivity and KX status of all peers known to CORE.
+ * Calls @a peer_cb with the current status for each connected peer,
+ * and then once with NULL to indicate that all peers that are
+ * currently active have been handled. After that, the iteration
+ * continues until it is cancelled. Normal users of the CORE API are
+ * not expected to use this function. It is different in that it
+ * truly lists all connections (including those where the KX is in
+ * progress), not just those relevant to the application. This
+ * function is used by special applications for diagnostics.
*
* @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
+ * @param peer_cb_cls closure for @a peer_cb
+ * @return NULL on error
*/
-int
-GNUNET_CORE_iterate_peers (const struct GNUNET_CONFIGURATION_Handle *cfg,
- GNUNET_CORE_ConnectEventHandler peer_cb,
- void *cb_cls);
+struct GNUNET_CORE_MonitorHandle *
+GNUNET_CORE_monitor_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
+ GNUNET_CORE_MonitorCallback peer_cb,
+ void *peer_cb_cls);
/**
- * Handle to cancel 'is_peer_connected' test.
+ * Stop monitoring CORE activity.
+ *
+ * @param mh monitor to stop
*/
-struct GNUNET_CORE_ConnectTestHandle;
+void
+GNUNET_CORE_monitor_stop (struct GNUNET_CORE_MonitorHandle *mh);
/**
- * 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.
+ * Check if the given peer is currently connected. This function is for special
+ * cirumstances (GNUNET_TESTBED 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. This function returns
+ * synchronously after looking in the CORE API cache.
*
- * @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 handle to cancel the operation
+ * @param h the core handle
+ * @param pid the identity of the peer to check if it has been connected to us
+ * @return #GNUNET_YES if the peer is connected to us; #GNUNET_NO if not
*/
-struct GNUNET_CORE_ConnectTestHandle *
-GNUNET_CORE_is_peer_connected (const struct GNUNET_CONFIGURATION_Handle *cfg,
- const struct GNUNET_PeerIdentity *peer,
- GNUNET_CORE_ConnectEventHandler peer_cb,
- void *cb_cls);
+int
+GNUNET_CORE_is_peer_connected_sync (const struct GNUNET_CORE_Handle *h,
+ const struct GNUNET_PeerIdentity *pid);
/**
- * Abort 'is_connected' test operation.
+ * Create a message queue for sending messages to a peer with CORE.
+ * Messages may only be queued with #GNUNET_MQ_send once the init callback has
+ * been called for the given handle.
+ * There must only be one queue per peer for each core handle.
+ * The message queue can only be used to transmit messages,
+ * not to receive them.
*
- * @param cth handle for operation to cancel
+ * @param h the core handle
+ * @param target the target peer for this queue, may not be NULL
+ * @return a message queue for sending messages over the core handle
+ * to the target peer
*/
-void
-GNUNET_CORE_is_peer_connected_cancel (struct GNUNET_CORE_ConnectTestHandle *cth);
+struct GNUNET_MQ_Handle *
+GNUNET_CORE_mq_create (struct GNUNET_CORE_Handle *h,
+ const struct GNUNET_PeerIdentity *target);
#if 0 /* keep Emacsens' auto-indent happy */
/* ifndef GNUNET_CORE_SERVICE_H */
#endif
+
+/** @} */ /* end of group core */
+
/* end of gnunet_core_service.h */