src/include/gnunet_psyc_service.h

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2012, 2013 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18      Boston, MA 02110-1301, USA.
  19 */
  20
  21 /**
  22  * @file include/gnunet_psyc_service.h
  23  * @brief PSYC service; high-level access to the PSYC protocol
  24  *        note that clients of this API are NOT expected to
  25  *        understand the PSYC message format, only the semantics!
  26  *        Parsing (and serializing) the PSYC stream format is done
  27  *        within the implementation of the libgnunetpsyc library,
  28  *        and this API deliberately exposes as little as possible
  29  *        of the actual data stream format to the application!
  30  * @author Christian Grothoff
  31  * @author Gabor X Toth
  32  *
  33  * NOTE:
  34  * - this API does not know about psyc's "root" and "places";
  35  *   there is no 'root' in GNUnet-Psyc as we're decentralized;
  36  *   'places' and 'persons' are combined within the same
  37  *   abstraction, that of a "channel".  Channels are identified
  38  *   and accessed in this API using a public/private key.
  39  *   Higher-level applications should use NAMES within GNS
  40  *   to obtain public keys, and the distinction between
  41  *   'places' and 'persons' can then be made with the help
  42  *   of the naming system (and/or conventions).
  43  *   Channels are (as in PSYC) organized into a hierarchy; each
  44  *   channel master (the one with the private key) is then
  45  *   the operator of the multicast group (its Origin in
  46  *   the terminology of the multicast API).
  47  * - The API supports passing large amounts of data using
  48  *   'streaming' for the argument passed to a method.  State
  49  *   and variables must fit into memory and cannot be streamed
  50  *   (thus, no passing of 4 GB of data in a variable;
  51  *   once we implement this, we might want to create a
  52  *   @c \#define for the maximum size of a variable).
  53  * - PSYC defines standard variables, methods, etc.  This
  54  *   library deliberately abstracts over all of these; a
  55  *   higher-level API should combine the naming system (GNS)
  56  *   and standard methods (message, join, part, warn,
  57  *   fail, error) and variables (action, color, time,
  58  *   tag, etc.).  However, this API does take over the
  59  *   routing variables, specifically 'context' (channel),
  60  *   and 'source'.  We only kind-of support 'target', as
  61  *   the target is either everyone in the group or the
  62  *   origin, and never just a single member of the group;
  63  *   for such individual messages, an application needs to
  64  *   construct an 'inbox' channel where the master (only)
  65  *   receives messages (but never forwards; private responses
  66  *   would be transmitted by joining the senders 'inbox'
  67  *   channel -- or a inbox#bob subchannel).  The
  68  *   goal for all of this is to keep the abstractions in this
  69  *   API minimal: interaction with multicast, try \& slice,
  70  *   state/variable/channel management.  Higher-level
  71  *   operations belong elsewhere (so maybe this API should
  72  *   be called 'PSYC-low', whereas a higher-level API
  73  *   implementing defaults for standard methods and
  74  *   variables might be called 'PSYC-std' or 'PSYC-high'.
  75  */
  76
  77 #ifndef GNUNET_PSYC_SERVICE_H
  78 #define GNUNET_PSYC_SERVICE_H
  79
  80 #ifdef __cplusplus
  81 extern "C"
  82 {
  83 #if 0                           /* keep Emacsens' auto-indent happy */
  84 }
  85 #endif
  86 #endif
  87
  88 #include "gnunet_util_lib.h"
  89 #include "gnunet_env_lib.h"
  90 #include "gnunet_multicast_service.h"
  91 //Mingw work around
  92 #ifdef MINGW
  93     # ifndef  UINT64_MAX
  94     # define  UINT64_MAX 0xffffffffffffffffULL
  95     # endif
  96 #endif
  97
  98 /**
  99  * Version number of GNUnet-PSYC API.
 100  */
 101 #define GNUNET_PSYC_VERSION 0x00000000
 102
 103
 104 /**
 105  * Policy flags for a channel.
 106  */
 107 enum GNUNET_PSYC_ChannelFlags
 108 {
 109   /**
 110    * Admission must be confirmed by the master.
 111    */
 112   GNUNET_PSYC_CHANNEL_ADMISSION_CONTROL = 1 << 0,
 113
 114   /**
 115    * Past messages are only available to slaves who were admitted at the time
 116    * they were sent to the channel.
 117    */
 118   GNUNET_PSYC_CHANNEL_RESTRICTED_HISTORY = 1 << 1
 119 };
 120
 121
 122 /**
 123  * PSYC channel policies.
 124  */
 125 enum GNUNET_PSYC_Policy
 126 {
 127   /**
 128    * Anyone can join the channel, without announcing his presence;
 129    * all messages are always public and can be distributed freely.
 130    * Joins may be announced, but this is not required.
 131    */
 132   GNUNET_PSYC_CHANNEL_ANONYMOUS = 0,
 133
 134   /**
 135    * The master must approve membership to the channel, messages must only be
 136    * distributed to current channel slaves.  This includes the channel
 137    * state as well as transient messages.
 138    */
 139   GNUNET_PSYC_CHANNEL_PRIVATE
 140     = GNUNET_PSYC_CHANNEL_ADMISSION_CONTROL
 141     | GNUNET_PSYC_CHANNEL_RESTRICTED_HISTORY
 142
 143 #if IDEAS_FOR_FUTURE
 144   /**
 145    * Anyone can freely join the channel (no approval required);
 146    * however, messages must only be distributed to current channel
 147    * slaves, so the master must still acknowledge that the slave
 148    * joined before transient messages are delivered.  As approval is
 149    * guaranteed, the presistent channel state can be synchronized freely
 150    * immediately, prior to master confirmation.
 151    */
 152   GNUNET_PSYC_CHANNEL_OPEN
 153     = GNUNET_PSYC_CHANNEL_RESTRICTED_HISTORY,
 154
 155   /**
 156    * The master must approve joins to the channel, but past messages can be
 157    * freely distributed to slaves.
 158    */
 159   GNUNET_PSYC_CHANNEL_CLOSED
 160     = GNUNET_PSYC_CHANNEL_ADMISSION_CONTROL,
 161 #endif
 162 };
 163
 164
 165 enum GNUNET_PSYC_MessageFlags
 166 {
 167   /**
 168    * Default / no flags.
 169    */
 170   GNUNET_PSYC_MESSAGE_DEFAULT = 0,
 171
 172   /**
 173    * Historic message, retrieved from PSYCstore.
 174    */
 175   GNUNET_PSYC_MESSAGE_HISTORIC = 1 << 0,
 176
 177   /**
 178    * Request from slave to master.
 179    */
 180   GNUNET_PSYC_MESSAGE_REQUEST = 1 << 1,
 181
 182   /**
 183    * Message can be delivered out of order.
 184    */
 185   GNUNET_PSYC_MESSAGE_ORDER_ANY = 1 << 2
 186 };
 187
 188
 189 /**
 190  * Values for the @a state_delta field of GNUNET_PSYC_MessageHeader.
 191  */
 192 enum GNUNET_PSYC_StateDeltaValues
 193 {
 194   GNUNET_PSYC_STATE_RESET = 0,
 195
 196   GNUNET_PSYC_STATE_NOT_MODIFIED = UINT64_MAX
 197 };
 198
 199
 200 GNUNET_NETWORK_STRUCT_BEGIN
 201
 202 /**
 203  * A PSYC message.
 204  *
 205  * Used for single-fragment messages e.g. in a join request or response.
 206  */
 207 struct GNUNET_PSYC_Message
 208 {
 209   /**
 210    * Message header with size and type information.
 211    */
 212   struct GNUNET_MessageHeader header;
 213
 214   /* Followed by concatenated PSYC message parts:
 215    * messages with GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_* types
 216    */
 217 };
 218
 219
 220 /**
 221  * Header of a PSYC message.
 222  *
 223  * The PSYC service adds this when delivering the message to local clients,
 224  * not present on the multicast layer.
 225  */
 226 struct GNUNET_PSYC_MessageHeader
 227 {
 228   /**
 229    * Generic message header with size and type information.
 230    */
 231   struct GNUNET_MessageHeader header;
 232
 233   /**
 234    * Flags for this message fragment.
 235    *
 236    * @see enum GNUNET_PSYC_MessageFlags
 237    */
 238   uint32_t flags GNUNET_PACKED;
 239
 240   /**
 241    * Number of the message this message part belongs to.
 242    * Monotonically increasing from 1.
 243    */
 244   uint64_t message_id GNUNET_PACKED;
 245
 246   /**
 247    * Byte offset of this @e fragment of the @e message.
 248    * FIXME: use data_offset instead
 249    */
 250   uint64_t fragment_offset GNUNET_PACKED;
 251
 252   /**
 253    * Sending slave's public key.
 254    * Not set if the message is from the master.
 255    */
 256   struct GNUNET_CRYPTO_EcdsaPublicKey slave_key;
 257
 258   /* Followed by concatenated PSYC message parts:
 259    * messages with GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_* types
 260    */
 261 };
 262
 263
 264 /**
 265  * The method of a message.
 266  */
 267 struct GNUNET_PSYC_MessageMethod
 268 {
 269   /**
 270    * Type: GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_METHOD
 271    */
 272   struct GNUNET_MessageHeader header;
 273
 274   /**
 275    * OR'ed GNUNET_PSYC_MasterTransmitFlags
 276    */
 277   uint32_t flags GNUNET_PACKED;
 278
 279   /**
 280    * Number of message IDs since the last message that contained state
 281    * operations. @see enum GNUNET_PSYC_StateDeltaValues
 282    */
 283   uint64_t state_delta GNUNET_PACKED;
 284
 285   /* Followed by NUL-terminated method name. */
 286 };
 287
 288
 289 /**
 290  * A modifier of a message.
 291  */
 292 struct GNUNET_PSYC_MessageModifier
 293 {
 294   /**
 295    * Type: GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_MODIFIER
 296    */
 297   struct GNUNET_MessageHeader header;
 298
 299   /**
 300    * Size of value.
 301    */
 302   uint32_t value_size GNUNET_PACKED;
 303
 304   /**
 305    * Size of name, including NUL terminator.
 306    */
 307   uint16_t name_size GNUNET_PACKED;
 308
 309   /**
 310    * enum GNUNET_ENV_Operator
 311    */
 312   uint8_t oper;
 313
 314   /* Followed by NUL-terminated name, then the value. */
 315 };
 316
 317
 318 struct GNUNET_PSYC_CountersResultMessage
 319 {
 320   /**
 321    * Type: GNUNET_MESSAGE_TYPE_PSYC_RESULT_COUNTERS
 322    */
 323   struct GNUNET_MessageHeader header;
 324
 325   /**
 326    * Status code for the operation.
 327    */
 328   uint32_t result_code GNUNET_PACKED;
 329
 330   /**
 331    * Last message ID sent to the channel.
 332    */
 333   uint64_t max_message_id GNUNET_PACKED;
 334 };
 335
 336
 337 /**
 338  * Join request sent to a PSYC master.
 339  */
 340 struct GNUNET_PSYC_JoinRequestMessage
 341 {
 342   /**
 343    * Type: GNUNET_MESSAGE_TYPE_PSYC_MASTER_JOIN_REQUEST
 344    */
 345   struct GNUNET_MessageHeader header;
 346   /**
 347    * Public key of the joining slave.
 348    */
 349   struct GNUNET_CRYPTO_EcdsaPublicKey slave_key;
 350
 351   /* Followed by struct GNUNET_MessageHeader join_request */
 352 };
 353
 354
 355 /**
 356  * Join decision sent in reply to a join request.
 357  */
 358 struct GNUNET_PSYC_JoinDecisionMessage
 359 {
 360   /**
 361    * Type: GNUNET_MESSAGE_TYPE_PSYC_JOIN_DECISION
 362    */
 363   struct GNUNET_MessageHeader header;
 364
 365   /**
 366    * #GNUNET_YES if the slave was admitted.
 367    */
 368   int32_t is_admitted;
 369
 370   /**
 371    * Public key of the joining slave.
 372    * Only set when the master is sending the decision,
 373    * not set when a slave is receiving it.
 374    */
 375   struct GNUNET_CRYPTO_EcdsaPublicKey slave_key;
 376
 377   /* Followed by struct GNUNET_MessageHeader join_response */
 378 };
 379
 380
 381 enum GNUNET_PSYC_HistoryReplayFlags
 382 {
 383   /**
 384    * Replay locally available messages.
 385    */
 386   GNUNET_PSYC_HISTORY_REPLAY_LOCAL  = 0,
 387
 388   /**
 389    * Replay messages from remote peers if not found locally.
 390    */
 391   GNUNET_PSYC_HISTORY_REPLAY_REMOTE = 1,
 392 };
 393
 394
 395 struct GNUNET_PSYC_HistoryRequestMessage
 396 {
 397   /**
 398    * Type: GNUNET_MESSAGE_TYPE_PSYC_CHANNEL_HISTORY_REPLAY
 399    */
 400   struct GNUNET_MessageHeader header;
 401
 402   /**
 403    * @see enum GNUNET_PSYC_HistoryReplayFlags
 404    */
 405   uint32_t flags GNUNET_PACKED;
 406
 407   /**
 408    * ID for this operation.
 409    */
 410   uint64_t op_id GNUNET_PACKED;
 411
 412   uint64_t start_message_id GNUNET_PACKED;
 413
 414   uint64_t end_message_id GNUNET_PACKED;
 415
 416   uint64_t message_limit GNUNET_PACKED;
 417
 418   /* Followed by NUL-terminated method name prefix. */
 419 };
 420
 421
 422 struct GNUNET_PSYC_StateRequestMessage
 423 {
 424   /**
 425    * Types:
 426    * - GNUNET_MESSAGE_TYPE_PSYC_CHANNEL_STATE_GET
 427    * - GNUNET_MESSAGE_TYPE_PSYC_CHANNEL_STATE_GET_PREFIX
 428    */
 429   struct GNUNET_MessageHeader header;
 430
 431   uint32_t reserved GNUNET_PACKED;
 432
 433   /**
 434    * ID for this operation.
 435    */
 436   uint64_t op_id GNUNET_PACKED;
 437
 438   /* Followed by NUL-terminated name. */
 439 };
 440
 441
 442 /**** service -> library ****/
 443
 444
 445 /**
 446  * Answer from service to client about last operation.
 447  */
 448 struct GNUNET_PSYC_OperationResultMessage
 449 {
 450   /**
 451    * Types:
 452    * - GNUNET_MESSAGE_TYPE_PSYC_RESULT_CODE
 453    * - GNUNET_MESSAGE_TYPE_PSYC_CHANNEL_STATE_RESULT
 454    */
 455   struct GNUNET_MessageHeader header;
 456
 457   uint32_t reserved GNUNET_PACKED;
 458
 459   /**
 460    * Operation ID.
 461    */
 462   uint64_t op_id GNUNET_PACKED;
 463
 464   /**
 465    * Status code for the operation.
 466    */
 467   uint64_t result_code GNUNET_PACKED;
 468
 469   /* Followed by:
 470    * - on error: NUL-terminated error message
 471    * - on success: one of the following message types
 472    *
 473    *   For a STATE_RESULT, one of:
 474    *   - GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_MODIFIER
 475    *   - GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_MOD_CONT
 476    *   - GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_END
 477    */
 478 };
 479
 480 GNUNET_NETWORK_STRUCT_END
 481
 482
 483 #define GNUNET_PSYC_MODIFIER_MAX_PAYLOAD        \
 484   GNUNET_MULTICAST_FRAGMENT_MAX_PAYLOAD         \
 485   - sizeof (struct GNUNET_PSYC_MessageModifier)
 486
 487 #define GNUNET_PSYC_MOD_CONT_MAX_PAYLOAD        \
 488   GNUNET_MULTICAST_FRAGMENT_MAX_PAYLOAD         \
 489   - sizeof (struct GNUNET_MessageHeader)
 490
 491 #define GNUNET_PSYC_DATA_MAX_PAYLOAD            \
 492   GNUNET_MULTICAST_FRAGMENT_MAX_PAYLOAD         \
 493   - sizeof (struct GNUNET_MessageHeader)
 494
 495
 496 /**
 497  * PSYC message part processing states.
 498  */
 499 enum GNUNET_PSYC_MessageState
 500 {
 501   GNUNET_PSYC_MESSAGE_STATE_START    = 0,
 502   GNUNET_PSYC_MESSAGE_STATE_HEADER   = 1,
 503   GNUNET_PSYC_MESSAGE_STATE_METHOD   = 2,
 504   GNUNET_PSYC_MESSAGE_STATE_MODIFIER = 3,
 505   GNUNET_PSYC_MESSAGE_STATE_MOD_CONT = 4,
 506   GNUNET_PSYC_MESSAGE_STATE_DATA     = 5,
 507   GNUNET_PSYC_MESSAGE_STATE_END      = 6,
 508   GNUNET_PSYC_MESSAGE_STATE_CANCEL   = 7,
 509   GNUNET_PSYC_MESSAGE_STATE_ERROR    = 8,
 510 };
 511
 512
 513 /**
 514  * Handle that identifies a join request.
 515  *
 516  * Used to match calls to #GNUNET_PSYC_JoinCallback to the
 517  * corresponding calls to GNUNET_PSYC_join_decision().
 518  */
 519 struct GNUNET_PSYC_JoinHandle;
 520
 521
 522 /**
 523  * Method called from PSYC upon receiving a message.
 524  *
 525  * @param cls  Closure.
 526  * @param message_id  Sequence number of the message.
 527  * @param flags  OR'ed GNUNET_PSYC_MessageFlags
 528  * @param msg  Message part, one of the following types:
 529  */
 530 typedef void
 531 (*GNUNET_PSYC_MessageCallback) (void *cls,
 532                                 uint64_t message_id,
 533                                 uint32_t flags,
 534                                 const struct GNUNET_PSYC_MessageHeader *msg);
 535
 536
 537 /**
 538  * Method called from PSYC upon receiving part of a message.
 539  *
 540  * @param cls  Closure.
 541  * @param message_id  Sequence number of the message.
 542  * @param data_offset  Byte offset of data, only set if @a msg has a type
 543  *                     #GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_DATA
 544  * @param flags  OR'ed GNUNET_PSYC_MessageFlags
 545  * @param msg  Message part, one of the following types:
 546  * - #GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_HEADER
 547  * - #GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_METHOD
 548  * - #GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_MODIFIER
 549  * - #GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_MOD_CONT
 550  * - #GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_DATA
 551  * or NULL if an error occurred while receiving a message.
 552  */
 553 typedef void
 554 (*GNUNET_PSYC_MessagePartCallback) (void *cls,
 555                                     uint64_t message_id,
 556                                     uint64_t data_offset,
 557                                     uint32_t flags,
 558                                     const struct GNUNET_MessageHeader *msg);
 559
 560
 561 /**
 562  * Method called from PSYC upon receiving a join request.
 563  *
 564  * @param cls  Closure.
 565  * @param slave_key  Public key of the slave requesting join.
 566  * @param join_msg  Join message sent along with the request.
 567  * @param jh  Join handle to use with GNUNET_PSYC_join_decision()
 568  */
 569 typedef void
 570 (*GNUNET_PSYC_JoinRequestCallback) (void *cls,
 571                                     const struct GNUNET_PSYC_JoinRequestMessage *req,
 572                                     const struct GNUNET_CRYPTO_EcdsaPublicKey *slave_key,
 573                                     const struct GNUNET_PSYC_Message *join_msg,
 574                                     struct GNUNET_PSYC_JoinHandle *jh);
 575
 576
 577 /**
 578  * Function to call with the decision made for a join request.
 579  *
 580  * Must be called once and only once in response to an invocation of the
 581  * #GNUNET_PSYC_JoinCallback.
 582  *
 583  * @param jh  Join request handle.
 584  * @param is_admitted
 585  *   #GNUNET_YES    if the join is approved,
 586  *   #GNUNET_NO     if it is disapproved,
 587  *   #GNUNET_SYSERR if we cannot answer the request.
 588  * @param relay_count  Number of relays given.
 589  * @param relays  Array of suggested peers that might be useful relays to use
 590  *        when joining the multicast group (essentially a list of peers that
 591  *        are already part of the multicast group and might thus be willing
 592  *        to help with routing).  If empty, only this local peer (which must
 593  *        be the multicast origin) is a good candidate for building the
 594  *        multicast tree.  Note that it is unnecessary to specify our own
 595  *        peer identity in this array.
 596  * @param join_resp  Application-dependent join response message to send along
 597  *        with the decision.
 598  *
 599  * @return #GNUNET_OK on success,
 600  *         #GNUNET_SYSERR if @a join_resp is too large.
 601  */
 602 int
 603 GNUNET_PSYC_join_decision (struct GNUNET_PSYC_JoinHandle *jh,
 604                            int is_admitted,
 605                            uint32_t relay_count,
 606                            const struct GNUNET_PeerIdentity *relays,
 607                            const struct GNUNET_PSYC_Message *join_resp);
 608
 609
 610 /**
 611  * Handle for the master of a PSYC channel.
 612  */
 613 struct GNUNET_PSYC_Master;
 614
 615
 616 /**
 617  * Function called after connected to the PSYC service
 618  * and the channel master started.
 619  *
 620  * Also called when reconnected to the service
 621  * after the connection closed unexpectedly.
 622  *
 623  * @param cls
 624  *        Closure.
 625  * @param result
 626  *        #GNUNET_YES if there were already messages sent to the channel,
 627  *        #GNUNET_NO  if the message history is empty,
 628  *        #GNUNET_SYSERR on error.
 629  * @param max_message_id
 630  *        Last message ID sent to the channel.
 631  */
 632 typedef void
 633 (*GNUNET_PSYC_MasterStartCallback) (void *cls, int result,
 634                                     uint64_t max_message_id);
 635
 636
 637 /**
 638  * Start a PSYC master channel.
 639  *
 640  * Will start a multicast group identified by the given ECC key.  Messages
 641  * received from group members will be given to the respective handler methods.
 642  * If a new member wants to join a group, the "join" method handler will be
 643  * invoked; the join handler must then generate a "join" message to approve the
 644  * joining of the new member.  The channel can also change group membership
 645  * without explicit requests.  Note that PSYC doesn't itself "understand" join
 646  * or part messages, the respective methods must call other PSYC functions to
 647  * inform PSYC about the meaning of the respective events.
 648  *
 649  * @param cfg  Configuration to use (to connect to PSYC service).
 650  * @param channel_key  ECC key that will be used to sign messages for this
 651  *        PSYC session. The public key is used to identify the PSYC channel.
 652  *        Note that end-users will usually not use the private key directly, but
 653  *        rather look it up in GNS for places managed by other users, or select
 654  *        a file with the private key(s) when setting up their own channels
 655  *        FIXME: we'll likely want to use NOT the p521 curve here, but a cheaper
 656  *        one in the future.
 657  * @param policy  Channel policy specifying join and history restrictions.
 658  *        Used to automate join decisions.
 659  * @param master_start_cb  Function to invoke after the channel master started.
 660  * @param join_request_cb  Function to invoke when a slave wants to join.
 661  * @param message_cb  Function to invoke on message parts sent to the channel
 662  *        and received from slaves
 663  * @param cls  Closure for @a method and @a join_cb.
 664  *
 665  * @return Handle for the channel master, NULL on error.
 666  */
 667 struct GNUNET_PSYC_Master *
 668 GNUNET_PSYC_master_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
 669                           const struct GNUNET_CRYPTO_EddsaPrivateKey *channel_key,
 670                           enum GNUNET_PSYC_Policy policy,
 671                           GNUNET_PSYC_MasterStartCallback master_start_cb,
 672                           GNUNET_PSYC_JoinRequestCallback join_request_cb,
 673                           GNUNET_PSYC_MessageCallback message_cb,
 674                           GNUNET_PSYC_MessagePartCallback message_part_cb,
 675                           void *cls);
 676
 677
 678 /**
 679  * Function called to provide data for a transmission via PSYC.
 680  *
 681  * Note that returning #GNUNET_YES or #GNUNET_SYSERR (but not #GNUNET_NO)
 682  * invalidates the respective transmission handle.
 683  *
 684  * @param cls Closure.
 685  * @param[in,out] data_size Initially set to the number of bytes available in
 686  *        @a data, should be set to the number of bytes written to data.
 687  * @param[out] data Where to write the body of the message to give to the
 688  *         method. The function must copy at most @a data_size bytes to @a data.
 689  * @return #GNUNET_SYSERR on error (fatal, aborts transmission)
 690  *         #GNUNET_NO on success, if more data is to be transmitted later.
 691  *         Should be used if @a data_size was not big enough to take all the
 692  *         data.  If 0 is returned in @a data_size the transmission is paused,
 693  *         and can be resumed with GNUNET_PSYC_master_transmit_resume().
 694  *         #GNUNET_YES if this completes the transmission (all data supplied)
 695  */
 696 typedef int
 697 (*GNUNET_PSYC_TransmitNotifyData) (void *cls,
 698                                    uint16_t *data_size,
 699                                    void *data);
 700
 701 /**
 702  * Function called to provide a modifier for a transmission via PSYC.
 703  *
 704  * Note that returning #GNUNET_YES or #GNUNET_SYSERR (but not #GNUNET_NO)
 705  * invalidates the respective transmission handle.
 706  *
 707  * @param cls Closure.
 708  * @param[in,out] data_size  Initially set to the number of bytes available in
 709  *         @a data, should be set to the number of bytes written to data.
 710  * @param[out] data  Where to write the modifier's name and value.
 711  *         The function must copy at most @a data_size bytes to @a data.
 712  *         When this callback is first called for a modifier, @a data should
 713  *         contain: "name\0value".  If the whole value does not fit, subsequent
 714  *         calls to this function should write continuations of the value to
 715  *         @a data.
 716  * @param[out] oper  Where to write the operator of the modifier.
 717  *         Only needed during the first call to this callback at the beginning
 718  *         of the modifier.  In case of subsequent calls asking for value
 719  *         continuations @a oper is set to #NULL.
 720  * @param[out] full_value_size  Where to write the full size of the value.
 721  *         Only needed during the first call to this callback at the beginning
 722  *         of the modifier.  In case of subsequent calls asking for value
 723  *         continuations @a value_size is set to #NULL.
 724  * @return #GNUNET_SYSERR on error (fatal, aborts transmission)
 725  *         #GNUNET_NO on success, if more data is to be transmitted later.
 726  *         Should be used if @a data_size was not big enough to take all the
 727  *         data for the modifier's value (the name must be always returned
 728  *         during the first call to this callback).
 729  *         If 0 is returned in @a data_size the transmission is paused,
 730  *         and can be resumed with GNUNET_PSYC_master_transmit_resume().
 731  *         #GNUNET_YES if this completes the modifier (the whole value is supplied).
 732  */
 733 typedef int
 734 (*GNUNET_PSYC_TransmitNotifyModifier) (void *cls,
 735                                        uint16_t *data_size,
 736                                        void *data,
 737                                        uint8_t *oper,
 738                                        uint32_t *full_value_size);
 739
 740 /**
 741  * Flags for transmitting messages to a channel by the master.
 742  */
 743 enum GNUNET_PSYC_MasterTransmitFlags
 744 {
 745   GNUNET_PSYC_MASTER_TRANSMIT_NONE = 0,
 746
 747   /**
 748    * Whether this message should reset the channel state,
 749    * i.e. remove all previously stored state variables.
 750    */
 751
 752   GNUNET_PSYC_MASTER_TRANSMIT_STATE_RESET = 1 << 0,
 753
 754   /**
 755    * Whether this message contains any state modifiers.
 756    */
 757   GNUNET_PSYC_MASTER_TRANSMIT_STATE_MODIFY = 1 << 1,
 758
 759   /**
 760    * Add PSYC header variable with the hash of the current channel state.
 761    */
 762   GNUNET_PSYC_MASTER_TRANSMIT_STATE_HASH = 1 << 2,
 763
 764   /**
 765    * Whether we need to increment the group generation counter after
 766    * transmitting this message.
 767    */
 768   GNUNET_PSYC_MASTER_TRANSMIT_INC_GROUP_GEN = 1 << 3
 769 };
 770
 771
 772 /**
 773  * Handle for a pending PSYC transmission operation.
 774  */
 775 struct GNUNET_PSYC_MasterTransmitHandle;
 776
 777
 778 /**
 779  * Send a message to call a method to all members in the PSYC channel.
 780  *
 781  * @param master Handle to the PSYC channel.
 782  * @param method_name Which method should be invoked.
 783  * @param notify_mod Function to call to obtain modifiers.
 784  * @param notify_data Function to call to obtain fragments of the data.
 785  * @param notify_cls Closure for @a notify_mod and @a notify_data.
 786  * @param flags Flags for the message being transmitted.
 787  * @return Transmission handle, NULL on error (i.e. more than one request queued).
 788  */
 789 struct GNUNET_PSYC_MasterTransmitHandle *
 790 GNUNET_PSYC_master_transmit (struct GNUNET_PSYC_Master *master,
 791                              const char *method_name,
 792                              GNUNET_PSYC_TransmitNotifyModifier notify_mod,
 793                              GNUNET_PSYC_TransmitNotifyData notify_data,
 794                              void *notify_cls,
 795                              enum GNUNET_PSYC_MasterTransmitFlags flags);
 796
 797
 798 /**
 799  * Resume transmission to the channel.
 800  *
 801  * @param th Handle of the request that is being resumed.
 802  */
 803 void
 804 GNUNET_PSYC_master_transmit_resume (struct GNUNET_PSYC_MasterTransmitHandle *th);
 805
 806
 807 /**
 808  * Abort transmission request to channel.
 809  *
 810  * @param th Handle of the request that is being aborted.
 811  */
 812 void
 813 GNUNET_PSYC_master_transmit_cancel (struct GNUNET_PSYC_MasterTransmitHandle *th);
 814
 815
 816 /**
 817  * Stop a PSYC master channel.
 818  *
 819  * @param master
 820  *        PSYC channel master to stop.
 821  * @param keep_active
 822  *        Keep place active after last application disconnected.
 823  * @param stop_cb
 824  *        Function called after the master stopped
 825  *        and disconnected from the psyc service.
 826  * @param stop_cls
 827  *        Closure for @a part_cb.
 828  */
 829 void
 830 GNUNET_PSYC_master_stop (struct GNUNET_PSYC_Master *master,
 831                          int keep_active,
 832                          GNUNET_ContinuationCallback stop_cb,
 833                          void *stop_cls);
 834
 835
 836 /**
 837  * Handle for a PSYC channel slave.
 838  */
 839 struct GNUNET_PSYC_Slave;
 840
 841
 842 /**
 843  * Function called after the slave connected to the PSYC service.
 844  *
 845  * Also called when reconnected to the service
 846  * after the connection closed unexpectedly.
 847  *
 848  * @param cls
 849  *        Closure.
 850  * @param result
 851  *        #GNUNET_YES if there were already messages sent to the channel,
 852  *        #GNUNET_NO  if the message history is empty,
 853  *        #GNUNET_SYSERR on error.
 854  * @param max_message_id
 855  *        Last message ID sent to the channel.
 856  */
 857 typedef void
 858 (*GNUNET_PSYC_SlaveConnectCallback) (void *cls, int result,
 859                                      uint64_t max_message_id);
 860
 861
 862 /**
 863  * Method called to inform about the decision in response to a join request.
 864  *
 865  * If @a is_admitted is not #GNUNET_YES, then sending messages to the channel is
 866  * not possible, but earlier history can be still queried.
 867  *
 868  * @param cls  Closure.
 869  * @param is_admitted  #GNUNET_YES or #GNUNET_NO or #GNUNET_SYSERR
 870  * @param join_msg  Application-dependent join message from the origin.
 871  */
 872 typedef void
 873 (*GNUNET_PSYC_JoinDecisionCallback) (void *cls,
 874                                      const struct GNUNET_PSYC_JoinDecisionMessage *dcsn,
 875                                      int is_admitted,
 876                                      const struct GNUNET_PSYC_Message *join_msg);
 877
 878
 879 /**
 880  * Join a PSYC channel.
 881  *
 882  * The entity joining is always the local peer.  The user must immediately use
 883  * the GNUNET_PSYC_slave_transmit() functions to transmit a @e join_msg to the
 884  * channel; if the join request succeeds, the channel state (and @e recent
 885  * method calls) will be replayed to the joining member.  There is no explicit
 886  * notification on failure (as the channel may simply take days to approve,
 887  * and disapproval is simply being ignored).
 888  *
 889  * @param cfg  Configuration to use.
 890  * @param channel_key  ECC public key that identifies the channel we wish to join.
 891  * @param slave_key  ECC private-public key pair that identifies the slave, and
 892  *        used by multicast to sign the join request and subsequent unicast
 893  *        requests sent to the master.
 894  * @param origin  Peer identity of the origin.
 895  * @param relay_count  Number of peers in the @a relays array.
 896  * @param relays  Peer identities of members of the multicast group, which serve
 897  *        as relays and used to join the group at.
 898  * @param message_cb  Function to invoke on message parts received from the
 899  *        channel, typically at least contains method handlers for @e join and
 900  *        @e part.
 901  * @param slave_connect_cb  Function invoked once we have connected to the
 902  *        PSYC service.
 903  * @param join_decision_cb  Function invoked once we have received a join
 904  *        decision.
 905  * @param cls  Closure for @a message_cb and @a slave_joined_cb.
 906  * @param method_name  Method name for the join request.
 907  * @param env  Environment containing transient variables for the request, or NULL.
 908  * @param data  Payload for the join message.
 909  * @param data_size  Number of bytes in @a data.
 910  *
 911  * @return Handle for the slave, NULL on error.
 912  */
 913 struct GNUNET_PSYC_Slave *
 914 GNUNET_PSYC_slave_join (const struct GNUNET_CONFIGURATION_Handle *cfg,
 915                         const struct GNUNET_CRYPTO_EddsaPublicKey *channel_key,
 916                         const struct GNUNET_CRYPTO_EcdsaPrivateKey *slave_key,
 917                         const struct GNUNET_PeerIdentity *origin,
 918                         uint32_t relay_count,
 919                         const struct GNUNET_PeerIdentity *relays,
 920                         GNUNET_PSYC_MessageCallback message_cb,
 921                         GNUNET_PSYC_MessagePartCallback message_part_cb,
 922                         GNUNET_PSYC_SlaveConnectCallback slave_connect_cb,
 923                         GNUNET_PSYC_JoinDecisionCallback join_decision_cb,
 924                         void *cls,
 925                         const struct GNUNET_PSYC_Message *join_msg);
 926
 927
 928 /**
 929  * Part a PSYC channel.
 930  *
 931  * Will terminate the connection to the PSYC service.  Polite clients should
 932  * first explicitly send a part request (via GNUNET_PSYC_slave_transmit()).
 933  *
 934  * @param slave
 935  *        Slave handle.
 936  * @param keep_active
 937  *        Keep place active after last application disconnected.
 938  * @param part_cb
 939  *        Function called after the slave parted the channel
 940  *        and disconnected from the psyc service.
 941  * @param part_cls
 942  *        Closure for @a part_cb.
 943  */
 944 void
 945 GNUNET_PSYC_slave_part (struct GNUNET_PSYC_Slave *slave,
 946                         int keep_active,
 947                         GNUNET_ContinuationCallback part_cb,
 948                         void *part_cls);
 949
 950
 951 /**
 952  * Flags for transmitting messages to the channel master by a slave.
 953  */
 954 enum GNUNET_PSYC_SlaveTransmitFlags
 955 {
 956   GNUNET_PSYC_SLAVE_TRANSMIT_NONE = 0
 957 };
 958
 959
 960 /**
 961  * Handle for a pending PSYC transmission operation.
 962  */
 963 struct GNUNET_PSYC_SlaveTransmitHandle;
 964
 965
 966 /**
 967  * Request a message to be sent to the channel master.
 968  *
 969  * @param slave Slave handle.
 970  * @param method_name Which (PSYC) method should be invoked (on host).
 971  * @param notify_mod Function to call to obtain modifiers.
 972  * @param notify_data Function to call to obtain fragments of the data.
 973  * @param notify_cls Closure for @a notify.
 974  * @param flags Flags for the message being transmitted.
 975  * @return Transmission handle, NULL on error (i.e. more than one request queued).
 976  */
 977 struct GNUNET_PSYC_SlaveTransmitHandle *
 978 GNUNET_PSYC_slave_transmit (struct GNUNET_PSYC_Slave *slave,
 979                             const char *method_name,
 980                             GNUNET_PSYC_TransmitNotifyModifier notify_mod,
 981                             GNUNET_PSYC_TransmitNotifyData notify_data,
 982                             void *notify_cls,
 983                             enum GNUNET_PSYC_SlaveTransmitFlags flags);
 984
 985
 986 /**
 987  * Resume transmission to the master.
 988  *
 989  * @param th Handle of the request that is being resumed.
 990  */
 991 void
 992 GNUNET_PSYC_slave_transmit_resume (struct GNUNET_PSYC_SlaveTransmitHandle *th);
 993
 994
 995 /**
 996  * Abort transmission request to master.
 997  *
 998  * @param th Handle of the request that is being aborted.
 999  */
1000 void
1001 GNUNET_PSYC_slave_transmit_cancel (struct GNUNET_PSYC_SlaveTransmitHandle *th);
1002
1003
1004 /**
1005  * Handle to access PSYC channel operations for both the master and slaves.
1006  */
1007 struct GNUNET_PSYC_Channel;
1008
1009
1010 /**
1011  * Convert a channel @a master to a @e channel handle to access the @e channel
1012  * APIs.
1013  *
1014  * @param master Channel master handle.
1015  * @return Channel handle, valid for as long as @a master is valid.
1016  */
1017 struct GNUNET_PSYC_Channel *
1018 GNUNET_PSYC_master_get_channel (struct GNUNET_PSYC_Master *master);
1019
1020
1021 /**
1022  * Convert @a slave to a @e channel handle to access the @e channel APIs.
1023  *
1024  * @param slave Slave handle.
1025  * @return Channel handle, valid for as long as @a slave is valid.
1026  */
1027 struct GNUNET_PSYC_Channel *
1028 GNUNET_PSYC_slave_get_channel (struct GNUNET_PSYC_Slave *slave);
1029
1030
1031 /**
1032  * Add a slave to the channel's membership list.
1033  *
1034  * Note that this will NOT generate any PSYC traffic, it will merely update the
1035  * local database to modify how we react to <em>membership test</em> queries.
1036  * The channel master still needs to explicitly transmit a @e join message to
1037  * notify other channel members and they then also must still call this function
1038  * in their respective methods handling the @e join message.  This way, how @e
1039  * join and @e part operations are exactly implemented is still up to the
1040  * application; for example, there might be a @e part_all method to kick out
1041  * everyone.
1042  *
1043  * Note that channel slaves are explicitly trusted to execute such methods
1044  * correctly; not doing so correctly will result in either denying other slaves
1045  * access or offering access to channel data to non-members.
1046  *
1047  * @param channel
1048  *        Channel handle.
1049  * @param slave_key
1050  *        Identity of channel slave to add.
1051  * @param announced_at
1052  *        ID of the message that announced the membership change.
1053  * @param effective_since
1054  *        Addition of slave is in effect since this message ID.
1055  * @param result_cb
1056  *        Function to call with the result of the operation.
1057  *        The @e result_code argument is #GNUNET_OK on success, or
1058  *        #GNUNET_SYSERR on error.  In case of an error, the @e data argument
1059  *        can contain an optional error message.
1060  * @param cls
1061  *        Closure for @a result_cb.
1062  */
1063 void
1064 GNUNET_PSYC_channel_slave_add (struct GNUNET_PSYC_Channel *channel,
1065                                const struct GNUNET_CRYPTO_EcdsaPublicKey *slave_key,
1066                                uint64_t announced_at,
1067                                uint64_t effective_since,
1068                                GNUNET_ResultCallback result_cb,
1069                                void *cls);
1070
1071
1072 /**
1073  * Remove a slave from the channel's membership list.
1074  *
1075  * Note that this will NOT generate any PSYC traffic, it will merely update the
1076  * local database to modify how we react to <em>membership test</em> queries.
1077  * The channel master still needs to explicitly transmit a @e part message to
1078  * notify other channel members and they then also must still call this function
1079  * in their respective methods handling the @e part message.  This way, how
1080  * @e join and @e part operations are exactly implemented is still up to the
1081  * application; for example, there might be a @e part_all message to kick out
1082  * everyone.
1083  *
1084  * Note that channel members are explicitly trusted to perform these
1085  * operations correctly; not doing so correctly will result in either
1086  * denying members access or offering access to channel data to
1087  * non-members.
1088  *
1089  * @param channel
1090  *        Channel handle.
1091  * @param slave_key
1092  *        Identity of channel slave to remove.
1093  * @param announced_at
1094  *        ID of the message that announced the membership change.
1095  * @param result_cb
1096  *        Function to call with the result of the operation.
1097  *        The @e result_code argument is #GNUNET_OK on success, or
1098  *        #GNUNET_SYSERR on error.  In case of an error, the @e data argument
1099  *        can contain an optional error message.
1100  * @param cls
1101  *        Closure for @a result_cb.
1102  */
1103 void
1104 GNUNET_PSYC_channel_slave_remove (struct GNUNET_PSYC_Channel *channel,
1105                                   const struct GNUNET_CRYPTO_EcdsaPublicKey
1106                                   *slave_key,
1107                                   uint64_t announced_at,
1108                                   GNUNET_ResultCallback result_cb,
1109                                   void *cls);
1110
1111
1112 /**
1113  * History request handle.
1114  */
1115 struct GNUNET_PSYC_HistoryRequest;
1116
1117
1118 /**
1119  * Request to replay a part of the message history of the channel.
1120  *
1121  * Historic messages (but NOT the state at the time) will be replayed (given to
1122  * the normal method handlers) if available and if access is permitted.
1123  *
1124  * @param channel
1125  *        Which channel should be replayed?
1126  * @param start_message_id
1127  *        Earliest interesting point in history.
1128  * @param end_message_id
1129  *        Last (inclusive) interesting point in history.
1130  * @param method_prefix
1131  *        Retrieve only messages with a matching method prefix.
1132  * @param flags
1133  *        OR'ed enum GNUNET_PSYC_HistoryReplayFlags
1134  * @param result_cb
1135  *        Function to call when the requested history has been fully replayed.
1136  *        Once this function has been called, the client must not call
1137  *        GNUNET_PSYC_channel_history_replay_cancel() anymore.
1138  * @param cls
1139  *        Closure for the callbacks.
1140  *
1141  * @return Handle to cancel history replay operation.
1142  */
1143 struct GNUNET_PSYC_HistoryRequest *
1144 GNUNET_PSYC_channel_history_replay (struct GNUNET_PSYC_Channel *channel,
1145                                     uint64_t start_message_id,
1146                                     uint64_t end_message_id,
1147                                     const char *method_prefix,
1148                                     uint32_t flags,
1149                                     GNUNET_PSYC_MessageCallback message_cb,
1150                                     GNUNET_PSYC_MessagePartCallback message_part_cb,
1151                                     GNUNET_ResultCallback result_cb,
1152                                     void *cls);
1153
1154
1155 /**
1156  * Request to replay the latest messages from the message history of the channel.
1157  *
1158  * Historic messages (but NOT the state at the time) will be replayed (given to
1159  * the normal method handlers) if available and if access is permitted.
1160  *
1161  * @param channel
1162  *        Which channel should be replayed?
1163  * @param message_limit
1164  *        Maximum number of messages to replay.
1165  * @param flags
1166  *        OR'ed enum GNUNET_PSYC_HistoryReplayFlags
1167  * @param finish_cb
1168  *        Function to call when the requested history has been fully replayed
1169  *        (counting message IDs might not suffice, as some messages might be
1170  *        secret and thus the listener would not know the story is finished
1171  *        without being told explicitly)o once this function has been called, the
1172  *        client must not call GNUNET_PSYC_channel_history_replay_cancel() anymore.
1173  * @param cls
1174  *        Closure for the callbacks.
1175  *
1176  * @return Handle to cancel history replay operation.
1177  */
1178 struct GNUNET_PSYC_HistoryRequest *
1179 GNUNET_PSYC_channel_history_replay_latest (struct GNUNET_PSYC_Channel *channel,
1180                                            uint64_t message_limit,
1181                                            const char *method_prefix,
1182                                            uint32_t flags,
1183                                            GNUNET_PSYC_MessageCallback message_cb,
1184                                            GNUNET_PSYC_MessagePartCallback message_part_cb,
1185                                            GNUNET_ResultCallback result_cb,
1186                                            void *cls);
1187
1188
1189 void
1190 GNUNET_PSYC_channel_history_replay_cancel (struct GNUNET_PSYC_Channel *channel,
1191                                            struct GNUNET_PSYC_HistoryRequest *hr);
1192
1193
1194 /**
1195  * Function called to inform a member about stored state values for a channel.
1196  *
1197  * If @a full_value_size > value_size then this function is called multiple
1198  * times until the whole value arrived.
1199  *
1200  * @param cls
1201  *        Closure.
1202  * @param name
1203  *        Name of the state variable.
1204  *        NULL if there are no more state variables to be returned.
1205  * @param value
1206  *        Value of the state variable.
1207  * @param value_size
1208  *        Number of bytes in @a value.
1209  * @param full_value_size
1210  *        Number of bytes in the full value, including continuations.
1211  *        Only set for the first part of a variable,
1212  *        in case of a continuation it is 0.
1213  */
1214 typedef void
1215 (*GNUNET_PSYC_StateVarCallback) (void *cls,
1216                                  const struct GNUNET_MessageHeader *mod,
1217                                  const char *name,
1218                                  const void *value,
1219                                  uint32_t value_size,
1220                                  uint32_t full_value_size);
1221
1222
1223 /**
1224  * State request handle.
1225  */
1226 struct GNUNET_PSYC_StateRequest;
1227
1228
1229 /**
1230  * Retrieve the best matching channel state variable.
1231  *
1232  * If the requested variable name is not present in the state, the nearest
1233  * less-specific name is matched; for example, requesting "_a_b" will match "_a"
1234  * if "_a_b" does not exist.
1235  *
1236  * @param channel
1237  *        Channel handle.
1238  * @param full_name
1239  *        Full name of the requested variable.
1240  *        The actual variable returned might have a shorter name.
1241  * @param var_cb
1242  *        Function called once when a matching state variable is found.
1243  *        Not called if there's no matching state variable.
1244  * @param result_cb
1245  *        Function called after the operation finished.
1246  *        (i.e. all state variables have been returned via @a state_cb)
1247  * @param cls
1248  *        Closure for the callbacks.
1249  */
1250 struct GNUNET_PSYC_StateRequest *
1251 GNUNET_PSYC_channel_state_get (struct GNUNET_PSYC_Channel *channel,
1252                                const char *full_name,
1253                                GNUNET_PSYC_StateVarCallback var_cb,
1254                                GNUNET_ResultCallback result_cb,
1255                                void *cls);
1256
1257
1258 /**
1259  * Return all channel state variables whose name matches a given prefix.
1260  *
1261  * A name matches if it starts with the given @a name_prefix, thus requesting
1262  * the empty prefix ("") will match all values; requesting "_a_b" will also
1263  * return values stored under "_a_b_c".
1264  *
1265  * The @a state_cb is invoked on all matching state variables asynchronously, as
1266  * the state is stored in and retrieved from the PSYCstore,
1267  *
1268  * @param channel
1269  *        Channel handle.
1270  * @param name_prefix
1271  *        Prefix of the state variable name to match.
1272  * @param var_cb
1273  *        Function called once when a matching state variable is found.
1274  *        Not called if there's no matching state variable.
1275  * @param result_cb
1276  *        Function called after the operation finished.
1277  *        (i.e. all state variables have been returned via @a state_cb)
1278  * @param cls
1279  *        Closure for the callbacks.
1280  */
1281 struct GNUNET_PSYC_StateRequest *
1282 GNUNET_PSYC_channel_state_get_prefix (struct GNUNET_PSYC_Channel *channel,
1283                                       const char *name_prefix,
1284                                       GNUNET_PSYC_StateVarCallback var_cb,
1285                                       GNUNET_ResultCallback result_cb,
1286                                       void *cls);
1287
1288 /**
1289  * Cancel a state request operation.
1290  *
1291  * @param sr
1292  *        Handle for the operation to cancel.
1293  */
1294 void
1295 GNUNET_PSYC_channel_state_get_cancel (struct GNUNET_PSYC_StateRequest *sr);
1296
1297
1298
1299 #if 0                           /* keep Emacsens' auto-indent happy */
1300 {
1301 #endif
1302 #ifdef __cplusplus
1303 }
1304 #endif
1305
1306 /* ifndef GNUNET_PSYC_SERVICE_H */
1307 #endif
1308 /* end of gnunet_psyc_service.h */