psyc service skeleton

1 files changed, 452 insertions, 0 deletions

diff --git a/src/psyc/psyc_api.c b/src/psyc/psyc_api.c
new file mode 100644
index 000000000..8d07f5f79
--- /dev/null
+++ b/src/psyc/psyc_api.c
@@ -0,0 +1,452 @@
+/*
+ * This file is part of GNUnet
+ * (C) 2013 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 3, or (at your
+ * option) any later version.
+ *
+ * GNUnet is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * 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.
+ */
+
+/** 
+ * @file psyc/psyc_api.c
+ * @brief PSYC service; high-level access to the PSYC protocol
+ *        note that clients of this API are NOT expected to
+ *        understand the PSYC message format, only the semantics!
+ *        Parsing (and serializing) the PSYC stream format is done
+ *        within the implementation of the libgnunetpsyc library,
+ *        and this API deliberately exposes as little as possible
+ *        of the actual data stream format to the application!
+ * @author Gabor X Toth
+ */
+
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_env_lib.h"
+#include "gnunet_psyc_service.h"
+#include "psyc.h"
+
+/** 
+ * Handle that identifies a join request.
+ *
+ * Used to match calls to #GNUNET_PSYC_JoinCallback to the
+ * corresponding calls to GNUNET_PSYC_join_decision().
+ */
+struct GNUNET_PSYC_JoinHandle;
+
+
+/** 
+ * Handle for the master of a PSYC channel.
+ */
+struct GNUNET_PSYC_Master;
+
+
+/** 
+ * Handle for a pending PSYC transmission operation.
+ */
+struct GNUNET_PSYC_MasterTransmitHandle;
+
+
+/** 
+ * Handle for a PSYC channel slave.
+ */
+struct GNUNET_PSYC_Slave;
+
+
+/** 
+ * Handle for a pending PSYC transmission operation.
+ */
+struct GNUNET_PSYC_SlaveTransmitHandle;
+
+
+/** 
+ * Handle to access PSYC channel operations for both the master and slaves.
+ */
+struct GNUNET_PSYC_Channel;
+
+
+/** 
+ * Handle to a story telling operation.
+ */
+struct GNUNET_PSYC_Story;
+
+
+struct GNUNET_PSYC_StateQuery;
+
+
+/** 
+ * Function to call with the decision made for a join request.
+ *
+ * Must be called once and only once in response to an invocation of the
+ * #GNUNET_PSYC_JoinCallback.
+ *
+ * @param jh Join request handle.
+ * @param is_admitted #GNUNET_YES if joining is approved,
+ *        #GNUNET_NO if it is disapproved.
+ * @param relay_count Number of relays given.
+ * @param relays Array of suggested peers that might be useful relays to use
+ *        when joining the multicast group (essentially a list of peers that
+ *        are already part of the multicast group and might thus be willing
+ *        to help with routing).  If empty, only this local peer (which must
+ *        be the multicast origin) is a good candidate for building the
+ *        multicast tree.  Note that it is unnecessary to specify our own
+ *        peer identity in this array.
+ * @param method_name Method name for the message transmitted with the response.
+ * @param env Environment containing transient variables for the message, or NULL.
+ * @param data Data of the message.
+ * @param data_size Size of @a data.
+ */
+void
+GNUNET_PSYC_join_decision (struct GNUNET_PSYC_JoinHandle *jh,
+                           int is_admitted,
+                           unsigned int relay_count,
+                           const struct GNUNET_PeerIdentity *relays,
+                           const char *method_name,
+                           const struct GNUNET_ENV_Environment *env,
+                           const void *data,
+                           size_t data_size);
+
+
+/** 
+ * Start a PSYC master channel.
+ *
+ * Will start a multicast group identified by the given ECC key.  Messages
+ * received from group members will be given to the respective handler methods.
+ * If a new member wants to join a group, the "join" method handler will be
+ * invoked; the join handler must then generate a "join" message to approve the
+ * joining of the new member.  The channel can also change group membership
+ * without explicit requests.  Note that PSYC doesn't itself "understand" join
+ * or part messages, the respective methods must call other PSYC functions to
+ * inform PSYC about the meaning of the respective events.
+ *
+ * @param cfg Configuration to use (to connect to PSYC service).
+ * @param channel_key ECC key that will be used to sign messages for this
+ *        PSYC session. The public key is used to identify the PSYC channel.
+ *        Note that end-users will usually not use the private key directly, but
+ *        rather look it up in GADS for places managed by other users, or select
+ *        a file with the private key(s) when setting up their own channels
+ *        FIXME: we'll likely want to use NOT the p521 curve here, but a cheaper
+ *        one in the future.
+ * @param policy Channel policy specifying join and history restrictions.
+ *        Used to automate join decisions.
+ * @param method Function to invoke on messages received from slaves.
+ * @param join_cb Function to invoke when a peer wants to join.
+ * @param cls Closure for @a method and @a join_cb.
+ * @return Handle for the channel master, NULL on error.
+ */
+struct GNUNET_PSYC_Master *
+GNUNET_PSYC_master_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                          const struct GNUNET_CRYPTO_EccPrivateKey *channel_key,
+                          enum GNUNET_PSYC_Policy policy,
+                          GNUNET_PSYC_Method method,
+                          GNUNET_PSYC_JoinCallback join_cb,
+                          void *cls);
+
+
+/** 
+ * Send a message to call a method to all members in the PSYC channel.
+ *
+ * @param master Handle to the PSYC channel.
+ * @param method_name Which method should be invoked.
+ * @param env Environment containing state operations and transient variables
+ *            for the message, or NULL.
+ * @param notify Function to call to obtain the arguments.
+ * @param notify_cls Closure for @a notify.
+ * @param flags Flags for the message being transmitted.
+ * @return Transmission handle, NULL on error (i.e. more than one request queued).
+ */
+struct GNUNET_PSYC_MasterTransmitHandle *
+GNUNET_PSYC_master_transmit (struct GNUNET_PSYC_Master *master,
+                             const char *method_name,
+                             const struct GNUNET_ENV_Environment *env,
+                             GNUNET_PSYC_MasterTransmitNotify notify,
+                             void *notify_cls,
+                             enum GNUNET_PSYC_MasterTransmitFlags flags);
+
+
+/** 
+ * Abort transmission request to channel.
+ *
+ * @param th Handle of the request that is being aborted.
+ */
+void
+GNUNET_PSYC_master_transmit_cancel (struct GNUNET_PSYC_MasterTransmitHandle *th);
+
+
+/** 
+ * Stop a PSYC master channel.
+ *
+ * @param master PSYC channel master to stop.
+ */
+void
+GNUNET_PSYC_master_stop (struct GNUNET_PSYC_Master *master);
+
+
+/** 
+ * Join a PSYC channel.
+ *
+ * The entity joining is always the local peer.  The user must immediately use
+ * the GNUNET_PSYC_slave_to_master() functions to transmit a @e join_msg to the
+ * channel; if the join request succeeds, the channel state (and @e recent
+ * method calls) will be replayed to the joining member.  There is no explicit
+ * notification on failure (as the channel may simply take days to approve,
+ * and disapproval is simply being ignored).
+ *
+ * @param cfg Configuration to use.
+ * @param channel_key ECC public key that identifies the channel we wish to join.
+ * @param slave_key ECC private-public key pair that identifies the slave, and
+ *        used by multicast to sign the join request and subsequent unicast
+ *        requests sent to the master.
+ * @param origin Peer identity of the origin.
+ * @param relay_count Number of peers in the @a relays array.
+ * @param relays Peer identities of members of the multicast group, which serve
+ *        as relays and used to join the group at.
+ * @param method Function to invoke on messages received from the channel,
+ *        typically at least contains functions for @e join and @e part.
+ * @param join_cb Function to invoke when a peer wants to join.
+ * @param cls Closure for @a method_cb and @a join_cb.
+ * @param method_name Method name for the join request.
+ * @param env Environment containing transient variables for the request, or NULL.
+ * @param data Payload for the join message.
+ * @param data_size Number of bytes in @a data.
+ * @return Handle for the slave, NULL on error.
+ */
+struct GNUNET_PSYC_Slave *
+GNUNET_PSYC_slave_join (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                        const struct GNUNET_CRYPTO_EccPublicSignKey *channel_key,
+                        const struct GNUNET_CRYPTO_EccPrivateKey *slave_key,
+                        const struct GNUNET_PeerIdentity *origin,
+                        size_t relay_count,
+                        const struct GNUNET_PeerIdentity *relays,
+                        GNUNET_PSYC_Method method,
+                        GNUNET_PSYC_JoinCallback join_cb,
+                        void *cls,
+                        const char *method_name,
+                        const struct GNUNET_ENV_Environment *env,
+                        const void *data,
+                        size_t data_size);
+
+
+/** 
+ * Part a PSYC channel.
+ *
+ * Will terminate the connection to the PSYC service.  Polite clients should
+ * first explicitly send a @e part request (via GNUNET_PSYC_slave_to_master()).
+ *
+ * @param slave Slave handle.
+ */
+void
+GNUNET_PSYC_slave_part (struct GNUNET_PSYC_Slave *slave);
+
+
+/** 
+ * Request a message to be sent to the channel master.
+ *
+ * @param slave Slave handle.
+ * @param method_name Which (PSYC) method should be invoked (on host).
+ * @param env Environment containing transient variables for the message, or NULL.
+ * @param notify Function to call when we are allowed to transmit (to get data).
+ * @param notify_cls Closure for @a notify.
+ * @param flags Flags for the message being transmitted.
+ * @return Transmission handle, NULL on error (i.e. more than one request queued).
+ */
+struct GNUNET_PSYC_SlaveTransmitHandle *
+GNUNET_PSYC_slave_transmit (struct GNUNET_PSYC_Slave *slave,
+                            const char *method_name,
+                            const struct GNUNET_ENV_Environment *env,
+                            GNUNET_PSYC_SlaveTransmitNotify notify,
+                            void *notify_cls,
+                            enum GNUNET_PSYC_SlaveTransmitFlags flags);
+
+
+/** 
+ * Abort transmission request to master.
+ *
+ * @param th Handle of the request that is being aborted.
+ */
+void
+GNUNET_PSYC_slave_transmit_cancel (struct GNUNET_PSYC_SlaveTransmitHandle *th);
+
+
+/** 
+ * Convert a channel @a master to a @e channel handle to access the @e channel APIs.
+ *
+ * @param master Channel master handle.
+ * @return Channel handle, valid for as long as @a master is valid.
+ */
+struct GNUNET_PSYC_Channel *
+GNUNET_PSYC_master_get_channel (struct GNUNET_PSYC_Master *master);
+
+
+/** 
+ * Convert @a slave to a @e channel handle to access the @e channel APIs.
+ *
+ * @param slave Slave handle.
+ * @return Channel handle, valid for as long as @a slave is valid.
+ */
+struct GNUNET_PSYC_Channel *
+GNUNET_PSYC_slave_get_channel (struct GNUNET_PSYC_Slave *slave);
+
+
+/** 
+ * Add a slave to the channel's membership list.
+ *
+ * Note that this will NOT generate any PSYC traffic, it will merely update the
+ * local database to modify how we react to <em>membership test</em> queries.
+ * The channel master still needs to explicitly transmit a @e join message to
+ * notify other channel members and they then also must still call this function
+ * in their respective methods handling the @e join message.  This way, how @e
+ * join and @e part operations are exactly implemented is still up to the
+ * application; for example, there might be a @e part_all method to kick out
+ * everyone.
+ *
+ * Note that channel slaves are explicitly trusted to execute such methods
+ * correctly; not doing so correctly will result in either denying other slaves
+ * access or offering access to channel data to non-members.
+ *
+ * @param channel Channel handle.
+ * @param slave_key Identity of channel slave to add.
+ * @param announced_at ID of the message that announced the membership change.
+ * @param effective_since Addition of slave is in effect since this message ID.
+ */
+void
+GNUNET_PSYC_channel_slave_add (struct GNUNET_PSYC_Channel *channel,
+                               const struct GNUNET_CRYPTO_EccPublicSignKey *slave_key,
+                               uint64_t announced_at,
+                               uint64_t effective_since);
+
+
+/** 
+ * Remove a slave from the channel's membership list.
+ *
+ * Note that this will NOT generate any PSYC traffic, it will merely update the
+ * local database to modify how we react to <em>membership test</em> queries.
+ * The channel master still needs to explicitly transmit a @e part message to
+ * notify other channel members and they then also must still call this function
+ * in their respective methods handling the @e part message.  This way, how
+ * @e join and @e part operations are exactly implemented is still up to the
+ * application; for example, there might be a @e part_all message to kick out
+ * everyone.
+ *
+ * Note that channel members are explicitly trusted to perform these
+ * operations correctly; not doing so correctly will result in either
+ * denying members access or offering access to channel data to
+ * non-members.
+ *
+ * @param channel Channel handle.
+ * @param slave_key Identity of channel slave to remove.
+ * @param announced_at ID of the message that announced the membership change.
+ */
+void
+GNUNET_PSYC_channel_slave_remove (struct GNUNET_PSYC_Channel *channel,
+                                  const struct GNUNET_CRYPTO_EccPublicSignKey *slave_key,
+                                  uint64_t announced_at);
+
+
+/** 
+ * Request to be told the message history of the channel.
+ *
+ * Historic messages (but NOT the state at the time) will be replayed (given to
+ * the normal method handlers) if available and if access is permitted.
+ *
+ * To get the latest message, use 0 for both the start and end message ID.
+ *
+ * @param channel Which channel should be replayed?
+ * @param start_message_id Earliest interesting point in history.
+ * @param end_message_id Last (exclusive) interesting point in history.
+ * @param method Function to invoke on messages received from the story.
+ * @param finish_cb Function to call when the requested story has been fully
+ *        told (counting message IDs might not suffice, as some messages
+ *        might be secret and thus the listener would not know the story is
+ *        finished without being told explicitly); once this function
+ *        has been called, the client must not call
+ *        GNUNET_PSYC_channel_story_tell_cancel() anymore.
+ * @param cls Closure for the callbacks.
+ * @return Handle to cancel story telling operation.
+ */
+struct GNUNET_PSYC_Story *
+GNUNET_PSYC_channel_story_tell (struct GNUNET_PSYC_Channel *channel,
+                                uint64_t start_message_id,
+                                uint64_t end_message_id,
+                                GNUNET_PSYC_Method method,
+                                GNUNET_PSYC_FinishCallback *finish_cb,
+                                void *cls);
+
+
+/** 
+ * Abort story telling.
+ *
+ * This function must not be called from within method handlers (as given to
+ * GNUNET_PSYC_slave_join()) of the slave.
+ *
+ * @param story Story telling operation to stop.
+ */
+void
+GNUNET_PSYC_channel_story_tell_cancel (struct GNUNET_PSYC_Story *story);
+
+
+/** 
+ * Retrieve the best matching channel state variable.
+ *
+ * If the requested variable name is not present in the state, the nearest
+ * less-specific name is matched; for example, requesting "_a_b" will match "_a"
+ * if "_a_b" does not exist.
+ *
+ * @param channel Channel handle.
+ * @param full_name Full name of the requested variable, the actual variable
+ *        returned might have a shorter name..
+ * @param cb Function called once when a matching state variable is found.
+ *        Not called if there's no matching state variable.
+ * @param cb_cls Closure for the callbacks.
+ * @return Handle that can be used to cancel the query operation.
+ */
+struct GNUNET_PSYC_StateQuery *
+GNUNET_PSYC_channel_state_get (struct GNUNET_PSYC_Channel *channel,
+                               const char *full_name,
+                               GNUNET_PSYC_StateCallback cb,
+                               void *cb_cls);
+
+
+/** 
+ * Return all channel state variables whose name matches a given prefix.
+ *
+ * A name matches if it starts with the given @a name_prefix, thus requesting the
+ * empty prefix ("") will match all values; requesting "_a_b" will also return
+ * values stored under "_a_b_c".
+ *
+ * The @a state_cb is invoked on all matching state variables asynchronously, as
+ * the state is stored in and retrieved from the PSYCstore,
+ *
+ * @param channel Channel handle.
+ * @param name_prefix Prefix of the state variable name to match.
+ * @param cb Function to call with the matching state variables.
+ * @param cb_cls Closure for the callbacks.
+ * @return Handle that can be used to cancel the query operation.
+ */
+struct GNUNET_PSYC_StateQuery *
+GNUNET_PSYC_channel_state_get_prefix (struct GNUNET_PSYC_Channel *channel,
+                                      const char *name_prefix,
+                                      GNUNET_PSYC_StateCallback cb,
+                                      void *cb_cls);
+
+
+/** 
+ * Cancel a state query operation.
+ *
+ * @param query Handle for the operation to cancel.
+ */
+void
+GNUNET_PSYC_channel_state_get_cancel (struct GNUNET_PSYC_StateQuery *query);
+
+
+/* end of psyc_api.c */