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
 541  *        Closure.
 542  * @param slave_key
 543  *        Public key of the slave sending the message.
 544  *        Only set for channel master.
 545  * @param message_id
 546  *        Sequence number of the message.
 547  * @param flags
 548  *        OR'ed GNUNET_PSYC_MessageFlags
 549  * @param data_offset
 550  *        Byte offset of data, only set if @a msg has a type
 551  *        #GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_DATA
 552  * @param msg  Message part, one of the following types:
 553  * - #GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_HEADER
 554  * - #GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_METHOD
 555  * - #GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_MODIFIER
 556  * - #GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_MOD_CONT
 557  * - #GNUNET_MESSAGE_TYPE_PSYC_MESSAGE_DATA
 558  * or NULL if an error occurred while receiving a message.
 559  */
 560 typedef void
 561 (*GNUNET_PSYC_MessagePartCallback) (void *cls,
 562                                     const struct GNUNET_CRYPTO_EcdsaPublicKey *slave_key,
 563                                     uint64_t message_id,
 564                                     uint32_t flags,
 565                                     uint64_t data_offset,
 566                                     const struct GNUNET_MessageHeader *msg);
 567
 568
 569 /**
 570  * Method called from PSYC upon receiving a join request.
 571  *
 572  * @param cls
 573  *        Closure.
 574  * @param slave_key
 575  *        Public key of the slave requesting join.
 576  * @param join_msg
 577  *        Join message sent along with the request.
 578  * @param jh
 579  *        Join handle to use with GNUNET_PSYC_join_decision()
 580  */
 581 typedef void
 582 (*GNUNET_PSYC_JoinRequestCallback) (void *cls,
 583                                     const struct GNUNET_PSYC_JoinRequestMessage *req,
 584                                     const struct GNUNET_CRYPTO_EcdsaPublicKey *slave_key,
 585                                     const struct GNUNET_PSYC_Message *join_msg,
 586                                     struct GNUNET_PSYC_JoinHandle *jh);
 587
 588
 589 /**
 590  * Function to call with the decision made for a join request.
 591  *
 592  * Must be called once and only once in response to an invocation of the
 593  * #GNUNET_PSYC_JoinCallback.
 594  *
 595  * @param jh  Join request handle.
 596  * @param is_admitted
 597  *   #GNUNET_YES    if the join is approved,
 598  *   #GNUNET_NO     if it is disapproved,
 599  *   #GNUNET_SYSERR if we cannot answer the request.
 600  * @param relay_count  Number of relays given.
 601  * @param relays  Array of suggested peers that might be useful relays to use
 602  *        when joining the multicast group (essentially a list of peers that
 603  *        are already part of the multicast group and might thus be willing
 604  *        to help with routing).  If empty, only this local peer (which must
 605  *        be the multicast origin) is a good candidate for building the
 606  *        multicast tree.  Note that it is unnecessary to specify our own
 607  *        peer identity in this array.
 608  * @param join_resp  Application-dependent join response message to send along
 609  *        with the decision.
 610  *
 611  * @return #GNUNET_OK on success,
 612  *         #GNUNET_SYSERR if @a join_resp is too large.
 613  */
 614 int
 615 GNUNET_PSYC_join_decision (struct GNUNET_PSYC_JoinHandle *jh,
 616                            int is_admitted,
 617                            uint32_t relay_count,
 618                            const struct GNUNET_PeerIdentity *relays,
 619                            const struct GNUNET_PSYC_Message *join_resp);
 620
 621
 622 /**
 623  * Handle for the master of a PSYC channel.
 624  */
 625 struct GNUNET_PSYC_Master;
 626
 627
 628 /**
 629  * Function called after connected to the PSYC service
 630  * and the channel master started.
 631  *
 632  * Also called when reconnected to the service
 633  * after the connection closed unexpectedly.
 634  *
 635  * @param cls
 636  *        Closure.
 637  * @param result
 638  *        #GNUNET_YES if there were already messages sent to the channel,
 639  *        #GNUNET_NO  if the message history is empty,
 640  *        #GNUNET_SYSERR on error.
 641  * @param max_message_id
 642  *        Last message ID sent to the channel.
 643  */
 644 typedef void
 645 (*GNUNET_PSYC_MasterStartCallback) (void *cls, int result,
 646                                     uint64_t max_message_id);
 647
 648
 649 /**
 650  * Start a PSYC master channel.
 651  *
 652  * Will start a multicast group identified by the given ECC key.  Messages
 653  * received from group members will be given to the respective handler methods.
 654  * If a new member wants to join a group, the "join" method handler will be
 655  * invoked; the join handler must then generate a "join" message to approve the
 656  * joining of the new member.  The channel can also change group membership
 657  * without explicit requests.  Note that PSYC doesn't itself "understand" join
 658  * or part messages, the respective methods must call other PSYC functions to
 659  * inform PSYC about the meaning of the respective events.
 660  *
 661  * @param cfg  Configuration to use (to connect to PSYC service).
 662  * @param channel_key  ECC key that will be used to sign messages for this
 663  *        PSYC session. The public key is used to identify the PSYC channel.
 664  *        Note that end-users will usually not use the private key directly, but
 665  *        rather look it up in GNS for places managed by other users, or select
 666  *        a file with the private key(s) when setting up their own channels
 667  *        FIXME: we'll likely want to use NOT the p521 curve here, but a cheaper
 668  *        one in the future.
 669  * @param policy  Channel policy specifying join and history restrictions.
 670  *        Used to automate join decisions.
 671  * @param master_start_cb  Function to invoke after the channel master started.
 672  * @param join_request_cb  Function to invoke when a slave wants to join.
 673  * @param message_cb  Function to invoke on message parts sent to the channel
 674  *        and received from slaves
 675  * @param cls  Closure for @a method and @a join_cb.
 676  *
 677  * @return Handle for the channel master, NULL on error.
 678  */
 679 struct GNUNET_PSYC_Master *
 680 GNUNET_PSYC_master_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
 681                           const struct GNUNET_CRYPTO_EddsaPrivateKey *channel_key,
 682                           enum GNUNET_PSYC_Policy policy,
 683                           GNUNET_PSYC_MasterStartCallback master_start_cb,
 684                           GNUNET_PSYC_JoinRequestCallback join_request_cb,
 685                           GNUNET_PSYC_MessageCallback message_cb,
 686                           GNUNET_PSYC_MessagePartCallback message_part_cb,
 687                           void *cls);
 688
 689
 690 /**
 691  * Function called to provide data for a transmission via PSYC.
 692  *
 693  * Note that returning #GNUNET_YES or #GNUNET_SYSERR (but not #GNUNET_NO)
 694  * invalidates the respective transmission handle.
 695  *
 696  * @param cls Closure.
 697  * @param[in,out] data_size Initially set to the number of bytes available in
 698  *        @a data, should be set to the number of bytes written to data.
 699  * @param[out] data Where to write the body of the message to give to the
 700  *         method. The function must copy at most @a data_size bytes to @a data.
 701  * @return #GNUNET_SYSERR on error (fatal, aborts transmission)
 702  *         #GNUNET_NO on success, if more data is to be transmitted later.
 703  *         Should be used if @a data_size was not big enough to take all the
 704  *         data.  If 0 is returned in @a data_size the transmission is paused,
 705  *         and can be resumed with GNUNET_PSYC_master_transmit_resume().
 706  *         #GNUNET_YES if this completes the transmission (all data supplied)
 707  */
 708 typedef int
 709 (*GNUNET_PSYC_TransmitNotifyData) (void *cls,
 710                                    uint16_t *data_size,
 711                                    void *data);
 712
 713 /**
 714  * Function called to provide a modifier for a transmission via PSYC.
 715  *
 716  * Note that returning #GNUNET_YES or #GNUNET_SYSERR (but not #GNUNET_NO)
 717  * invalidates the respective transmission handle.
 718  *
 719  * @param cls Closure.
 720  * @param[in,out] data_size  Initially set to the number of bytes available in
 721  *         @a data, should be set to the number of bytes written to data.
 722  * @param[out] data  Where to write the modifier's name and value.
 723  *         The function must copy at most @a data_size bytes to @a data.
 724  *         When this callback is first called for a modifier, @a data should
 725  *         contain: "name\0value".  If the whole value does not fit, subsequent
 726  *         calls to this function should write continuations of the value to
 727  *         @a data.
 728  * @param[out] oper  Where to write the operator of the modifier.
 729  *         Only needed during the first call to this callback at the beginning
 730  *         of the modifier.  In case of subsequent calls asking for value
 731  *         continuations @a oper is set to #NULL.
 732  * @param[out] full_value_size  Where to write the full size of the value.
 733  *         Only needed during the first call to this callback at the beginning
 734  *         of the modifier.  In case of subsequent calls asking for value
 735  *         continuations @a value_size is set to #NULL.
 736  * @return #GNUNET_SYSERR on error (fatal, aborts transmission)
 737  *         #GNUNET_NO on success, if more data is to be transmitted later.
 738  *         Should be used if @a data_size was not big enough to take all the
 739  *         data for the modifier's value (the name must be always returned
 740  *         during the first call to this callback).
 741  *         If 0 is returned in @a data_size the transmission is paused,
 742  *         and can be resumed with GNUNET_PSYC_master_transmit_resume().
 743  *         #GNUNET_YES if this completes the modifier (the whole value is supplied).
 744  */
 745 typedef int
 746 (*GNUNET_PSYC_TransmitNotifyModifier) (void *cls,
 747                                        uint16_t *data_size,
 748                                        void *data,
 749                                        uint8_t *oper,
 750                                        uint32_t *full_value_size);
 751
 752 /**
 753  * Flags for transmitting messages to a channel by the master.
 754  */
 755 enum GNUNET_PSYC_MasterTransmitFlags
 756 {
 757   GNUNET_PSYC_MASTER_TRANSMIT_NONE = 0,
 758
 759   /**
 760    * Whether this message should reset the channel state,
 761    * i.e. remove all previously stored state variables.
 762    */
 763
 764   GNUNET_PSYC_MASTER_TRANSMIT_STATE_RESET = 1 << 0,
 765
 766   /**
 767    * Whether this message contains any state modifiers.
 768    */
 769   GNUNET_PSYC_MASTER_TRANSMIT_STATE_MODIFY = 1 << 1,
 770
 771   /**
 772    * Add PSYC header variable with the hash of the current channel state.
 773    */
 774   GNUNET_PSYC_MASTER_TRANSMIT_STATE_HASH = 1 << 2,
 775
 776   /**
 777    * Whether we need to increment the group generation counter after
 778    * transmitting this message.
 779    */
 780   GNUNET_PSYC_MASTER_TRANSMIT_INC_GROUP_GEN = 1 << 3
 781 };
 782
 783
 784 /**
 785  * Handle for a pending PSYC transmission operation.
 786  */
 787 struct GNUNET_PSYC_MasterTransmitHandle;
 788
 789
 790 /**
 791  * Send a message to call a method to all members in the PSYC channel.
 792  *
 793  * @param master Handle to the PSYC channel.
 794  * @param method_name Which method should be invoked.
 795  * @param notify_mod Function to call to obtain modifiers.
 796  * @param notify_data Function to call to obtain fragments of the data.
 797  * @param notify_cls Closure for @a notify_mod and @a notify_data.
 798  * @param flags Flags for the message being transmitted.
 799  * @return Transmission handle, NULL on error (i.e. more than one request queued).
 800  */
 801 struct GNUNET_PSYC_MasterTransmitHandle *
 802 GNUNET_PSYC_master_transmit (struct GNUNET_PSYC_Master *master,
 803                              const char *method_name,
 804                              GNUNET_PSYC_TransmitNotifyModifier notify_mod,
 805                              GNUNET_PSYC_TransmitNotifyData notify_data,
 806                              void *notify_cls,
 807                              enum GNUNET_PSYC_MasterTransmitFlags flags);
 808
 809
 810 /**
 811  * Resume transmission to the channel.
 812  *
 813  * @param th Handle of the request that is being resumed.
 814  */
 815 void
 816 GNUNET_PSYC_master_transmit_resume (struct GNUNET_PSYC_MasterTransmitHandle *th);
 817
 818
 819 /**
 820  * Abort transmission request to channel.
 821  *
 822  * @param th Handle of the request that is being aborted.
 823  */
 824 void
 825 GNUNET_PSYC_master_transmit_cancel (struct GNUNET_PSYC_MasterTransmitHandle *th);
 826
 827
 828 /**
 829  * Stop a PSYC master channel.
 830  *
 831  * @param master
 832  *        PSYC channel master to stop.
 833  * @param keep_active
 834  *        Keep place active after last application disconnected.
 835  * @param stop_cb
 836  *        Function called after the master stopped
 837  *        and disconnected from the psyc service.
 838  * @param stop_cls
 839  *        Closure for @a part_cb.
 840  */
 841 void
 842 GNUNET_PSYC_master_stop (struct GNUNET_PSYC_Master *master,
 843                          int keep_active,
 844                          GNUNET_ContinuationCallback stop_cb,
 845                          void *stop_cls);
 846
 847
 848 /**
 849  * Handle for a PSYC channel slave.
 850  */
 851 struct GNUNET_PSYC_Slave;
 852
 853
 854 /**
 855  * Function called after the slave connected to the PSYC service.
 856  *
 857  * Also called when reconnected to the service
 858  * after the connection closed unexpectedly.
 859  *
 860  * @param cls
 861  *        Closure.
 862  * @param result
 863  *        #GNUNET_YES if there were already messages sent to the channel,
 864  *        #GNUNET_NO  if the message history is empty,
 865  *        #GNUNET_SYSERR on error.
 866  * @param max_message_id
 867  *        Last message ID sent to the channel.
 868  */
 869 typedef void
 870 (*GNUNET_PSYC_SlaveConnectCallback) (void *cls, int result,
 871                                      uint64_t max_message_id);
 872
 873
 874 /**
 875  * Method called to inform about the decision in response to a join request.
 876  *
 877  * If @a is_admitted is not #GNUNET_YES, then sending messages to the channel is
 878  * not possible, but earlier history can be still queried.
 879  *
 880  * @param cls  Closure.
 881  * @param is_admitted  #GNUNET_YES or #GNUNET_NO or #GNUNET_SYSERR
 882  * @param join_msg  Application-dependent join message from the origin.
 883  */
 884 typedef void
 885 (*GNUNET_PSYC_JoinDecisionCallback) (void *cls,
 886                                      const struct GNUNET_PSYC_JoinDecisionMessage *dcsn,
 887                                      int is_admitted,
 888                                      const struct GNUNET_PSYC_Message *join_msg);
 889
 890
 891 /**
 892  * Join a PSYC channel.
 893  *
 894  * The entity joining is always the local peer.  The user must immediately use
 895  * the GNUNET_PSYC_slave_transmit() functions to transmit a @e join_msg to the
 896  * channel; if the join request succeeds, the channel state (and @e recent
 897  * method calls) will be replayed to the joining member.  There is no explicit
 898  * notification on failure (as the channel may simply take days to approve,
 899  * and disapproval is simply being ignored).
 900  *
 901  * @param cfg  Configuration to use.
 902  * @param channel_key  ECC public key that identifies the channel we wish to join.
 903  * @param slave_key  ECC private-public key pair that identifies the slave, and
 904  *        used by multicast to sign the join request and subsequent unicast
 905  *        requests sent to the master.
 906  * @param origin  Peer identity of the origin.
 907  * @param relay_count  Number of peers in the @a relays array.
 908  * @param relays  Peer identities of members of the multicast group, which serve
 909  *        as relays and used to join the group at.
 910  * @param message_cb  Function to invoke on message parts received from the
 911  *        channel, typically at least contains method handlers for @e join and
 912  *        @e part.
 913  * @param slave_connect_cb  Function invoked once we have connected to the
 914  *        PSYC service.
 915  * @param join_decision_cb  Function invoked once we have received a join
 916  *        decision.
 917  * @param cls  Closure for @a message_cb and @a slave_joined_cb.
 918  * @param method_name  Method name for the join request.
 919  * @param env  Environment containing transient variables for the request, or NULL.
 920  * @param data  Payload for the join message.
 921  * @param data_size  Number of bytes in @a data.
 922  *
 923  * @return Handle for the slave, NULL on error.
 924  */
 925 struct GNUNET_PSYC_Slave *
 926 GNUNET_PSYC_slave_join (const struct GNUNET_CONFIGURATION_Handle *cfg,
 927                         const struct GNUNET_CRYPTO_EddsaPublicKey *channel_key,
 928                         const struct GNUNET_CRYPTO_EcdsaPrivateKey *slave_key,
 929                         const struct GNUNET_PeerIdentity *origin,
 930                         uint32_t relay_count,
 931                         const struct GNUNET_PeerIdentity *relays,
 932                         GNUNET_PSYC_MessageCallback message_cb,
 933                         GNUNET_PSYC_MessagePartCallback message_part_cb,
 934                         GNUNET_PSYC_SlaveConnectCallback slave_connect_cb,
 935                         GNUNET_PSYC_JoinDecisionCallback join_decision_cb,
 936                         void *cls,
 937                         const struct GNUNET_PSYC_Message *join_msg);
 938
 939
 940 /**
 941  * Part a PSYC channel.
 942  *
 943  * Will terminate the connection to the PSYC service.  Polite clients should
 944  * first explicitly send a part request (via GNUNET_PSYC_slave_transmit()).
 945  *
 946  * @param slave
 947  *        Slave handle.
 948  * @param keep_active
 949  *        Keep place active after last application disconnected.
 950  * @param part_cb
 951  *        Function called after the slave parted the channel
 952  *        and disconnected from the psyc service.
 953  * @param part_cls
 954  *        Closure for @a part_cb.
 955  */
 956 void
 957 GNUNET_PSYC_slave_part (struct GNUNET_PSYC_Slave *slave,
 958                         int keep_active,
 959                         GNUNET_ContinuationCallback part_cb,
 960                         void *part_cls);
 961
 962
 963 /**
 964  * Flags for transmitting messages to the channel master by a slave.
 965  */
 966 enum GNUNET_PSYC_SlaveTransmitFlags
 967 {
 968   GNUNET_PSYC_SLAVE_TRANSMIT_NONE = 0
 969 };
 970
 971
 972 /**
 973  * Handle for a pending PSYC transmission operation.
 974  */
 975 struct GNUNET_PSYC_SlaveTransmitHandle;
 976
 977
 978 /**
 979  * Request a message to be sent to the channel master.
 980  *
 981  * @param slave Slave handle.
 982  * @param method_name Which (PSYC) method should be invoked (on host).
 983  * @param notify_mod Function to call to obtain modifiers.
 984  * @param notify_data Function to call to obtain fragments of the data.
 985  * @param notify_cls Closure for @a notify.
 986  * @param flags Flags for the message being transmitted.
 987  * @return Transmission handle, NULL on error (i.e. more than one request queued).
 988  */
 989 struct GNUNET_PSYC_SlaveTransmitHandle *
 990 GNUNET_PSYC_slave_transmit (struct GNUNET_PSYC_Slave *slave,
 991                             const char *method_name,
 992                             GNUNET_PSYC_TransmitNotifyModifier notify_mod,
 993                             GNUNET_PSYC_TransmitNotifyData notify_data,
 994                             void *notify_cls,
 995                             enum GNUNET_PSYC_SlaveTransmitFlags flags);
 996
 997
 998 /**
 999  * Resume transmission to the master.
1000  *
1001  * @param th Handle of the request that is being resumed.
1002  */
1003 void
1004 GNUNET_PSYC_slave_transmit_resume (struct GNUNET_PSYC_SlaveTransmitHandle *th);
1005
1006
1007 /**
1008  * Abort transmission request to master.
1009  *
1010  * @param th Handle of the request that is being aborted.
1011  */
1012 void
1013 GNUNET_PSYC_slave_transmit_cancel (struct GNUNET_PSYC_SlaveTransmitHandle *th);
1014
1015
1016 /**
1017  * Handle to access PSYC channel operations for both the master and slaves.
1018  */
1019 struct GNUNET_PSYC_Channel;
1020
1021
1022 /**
1023  * Convert a channel @a master to a @e channel handle to access the @e channel
1024  * APIs.
1025  *
1026  * @param master Channel master handle.
1027  * @return Channel handle, valid for as long as @a master is valid.
1028  */
1029 struct GNUNET_PSYC_Channel *
1030 GNUNET_PSYC_master_get_channel (struct GNUNET_PSYC_Master *master);
1031
1032
1033 /**
1034  * Convert @a slave to a @e channel handle to access the @e channel APIs.
1035  *
1036  * @param slave Slave handle.
1037  * @return Channel handle, valid for as long as @a slave is valid.
1038  */
1039 struct GNUNET_PSYC_Channel *
1040 GNUNET_PSYC_slave_get_channel (struct GNUNET_PSYC_Slave *slave);
1041
1042
1043 /**
1044  * Add a slave to the channel's membership list.
1045  *
1046  * Note that this will NOT generate any PSYC traffic, it will merely update the
1047  * local database to modify how we react to <em>membership test</em> queries.
1048  * The channel master still needs to explicitly transmit a @e join message to
1049  * notify other channel members and they then also must still call this function
1050  * in their respective methods handling the @e join message.  This way, how @e
1051  * join and @e part operations are exactly implemented is still up to the
1052  * application; for example, there might be a @e part_all method to kick out
1053  * everyone.
1054  *
1055  * Note that channel slaves are explicitly trusted to execute such methods
1056  * correctly; not doing so correctly will result in either denying other slaves
1057  * access or offering access to channel data to non-members.
1058  *
1059  * @param channel
1060  *        Channel handle.
1061  * @param slave_key
1062  *        Identity of channel slave to add.
1063  * @param announced_at
1064  *        ID of the message that announced the membership change.
1065  * @param effective_since
1066  *        Addition of slave is in effect since this message ID.
1067  * @param result_cb
1068  *        Function to call with the result of the operation.
1069  *        The @e result_code argument is #GNUNET_OK on success, or
1070  *        #GNUNET_SYSERR on error.  In case of an error, the @e data argument
1071  *        can contain an optional error message.
1072  * @param cls
1073  *        Closure for @a result_cb.
1074  */
1075 void
1076 GNUNET_PSYC_channel_slave_add (struct GNUNET_PSYC_Channel *channel,
1077                                const struct GNUNET_CRYPTO_EcdsaPublicKey *slave_key,
1078                                uint64_t announced_at,
1079                                uint64_t effective_since,
1080                                GNUNET_ResultCallback result_cb,
1081                                void *cls);
1082
1083
1084 /**
1085  * Remove a slave from the channel's membership list.
1086  *
1087  * Note that this will NOT generate any PSYC traffic, it will merely update the
1088  * local database to modify how we react to <em>membership test</em> queries.
1089  * The channel master still needs to explicitly transmit a @e part message to
1090  * notify other channel members and they then also must still call this function
1091  * in their respective methods handling the @e part message.  This way, how
1092  * @e join and @e part operations are exactly implemented is still up to the
1093  * application; for example, there might be a @e part_all message to kick out
1094  * everyone.
1095  *
1096  * Note that channel members are explicitly trusted to perform these
1097  * operations correctly; not doing so correctly will result in either
1098  * denying members access or offering access to channel data to
1099  * non-members.
1100  *
1101  * @param channel
1102  *        Channel handle.
1103  * @param slave_key
1104  *        Identity of channel slave to remove.
1105  * @param announced_at
1106  *        ID of the message that announced the membership change.
1107  * @param result_cb
1108  *        Function to call with the result of the operation.
1109  *        The @e result_code argument is #GNUNET_OK on success, or
1110  *        #GNUNET_SYSERR on error.  In case of an error, the @e data argument
1111  *        can contain an optional error message.
1112  * @param cls
1113  *        Closure for @a result_cb.
1114  */
1115 void
1116 GNUNET_PSYC_channel_slave_remove (struct GNUNET_PSYC_Channel *channel,
1117                                   const struct GNUNET_CRYPTO_EcdsaPublicKey
1118                                   *slave_key,
1119                                   uint64_t announced_at,
1120                                   GNUNET_ResultCallback result_cb,
1121                                   void *cls);
1122
1123
1124 /**
1125  * History request handle.
1126  */
1127 struct GNUNET_PSYC_HistoryRequest;
1128
1129
1130 /**
1131  * Request to replay a part of the message history of the channel.
1132  *
1133  * Historic messages (but NOT the state at the time) will be replayed (given to
1134  * the normal method handlers) if available and if access is permitted.
1135  *
1136  * @param channel
1137  *        Which channel should be replayed?
1138  * @param start_message_id
1139  *        Earliest interesting point in history.
1140  * @param end_message_id
1141  *        Last (inclusive) interesting point in history.
1142  * @param method_prefix
1143  *        Retrieve only messages with a matching method prefix.
1144  * @param flags
1145  *        OR'ed enum GNUNET_PSYC_HistoryReplayFlags
1146  * @param result_cb
1147  *        Function to call when the requested history has been fully replayed.
1148  *        Once this function has been called, the client must not call
1149  *        GNUNET_PSYC_channel_history_replay_cancel() anymore.
1150  * @param cls
1151  *        Closure for the callbacks.
1152  *
1153  * @return Handle to cancel history replay operation.
1154  */
1155 struct GNUNET_PSYC_HistoryRequest *
1156 GNUNET_PSYC_channel_history_replay (struct GNUNET_PSYC_Channel *channel,
1157                                     uint64_t start_message_id,
1158                                     uint64_t end_message_id,
1159                                     const char *method_prefix,
1160                                     uint32_t flags,
1161                                     GNUNET_PSYC_MessageCallback message_cb,
1162                                     GNUNET_PSYC_MessagePartCallback message_part_cb,
1163                                     GNUNET_ResultCallback result_cb,
1164                                     void *cls);
1165
1166
1167 /**
1168  * Request to replay the latest messages from the message history of the channel.
1169  *
1170  * Historic messages (but NOT the state at the time) will be replayed (given to
1171  * the normal method handlers) if available and if access is permitted.
1172  *
1173  * @param channel
1174  *        Which channel should be replayed?
1175  * @param message_limit
1176  *        Maximum number of messages to replay.
1177  * @param flags
1178  *        OR'ed enum GNUNET_PSYC_HistoryReplayFlags
1179  * @param finish_cb
1180  *        Function to call when the requested history has been fully replayed
1181  *        (counting message IDs might not suffice, as some messages might be
1182  *        secret and thus the listener would not know the story is finished
1183  *        without being told explicitly)o once this function has been called, the
1184  *        client must not call GNUNET_PSYC_channel_history_replay_cancel() anymore.
1185  * @param cls
1186  *        Closure for the callbacks.
1187  *
1188  * @return Handle to cancel history replay operation.
1189  */
1190 struct GNUNET_PSYC_HistoryRequest *
1191 GNUNET_PSYC_channel_history_replay_latest (struct GNUNET_PSYC_Channel *channel,
1192                                            uint64_t message_limit,
1193                                            const char *method_prefix,
1194                                            uint32_t flags,
1195                                            GNUNET_PSYC_MessageCallback message_cb,
1196                                            GNUNET_PSYC_MessagePartCallback message_part_cb,
1197                                            GNUNET_ResultCallback result_cb,
1198                                            void *cls);
1199
1200
1201 void
1202 GNUNET_PSYC_channel_history_replay_cancel (struct GNUNET_PSYC_Channel *channel,
1203                                            struct GNUNET_PSYC_HistoryRequest *hr);
1204
1205
1206 /**
1207  * Function called to inform a member about stored state values for a channel.
1208  *
1209  * If @a full_value_size > value_size then this function is called multiple
1210  * times until the whole value arrived.
1211  *
1212  * @param cls
1213  *        Closure.
1214  * @param name
1215  *        Name of the state variable.
1216  *        NULL if there are no more state variables to be returned.
1217  * @param value
1218  *        Value of the state variable.
1219  * @param value_size
1220  *        Number of bytes in @a value.
1221  * @param full_value_size
1222  *        Number of bytes in the full value, including continuations.
1223  *        Only set for the first part of a variable,
1224  *        in case of a continuation it is 0.
1225  */
1226 typedef void
1227 (*GNUNET_PSYC_StateVarCallback) (void *cls,
1228                                  const struct GNUNET_MessageHeader *mod,
1229                                  const char *name,
1230                                  const void *value,
1231                                  uint32_t value_size,
1232                                  uint32_t full_value_size);
1233
1234
1235 /**
1236  * State request handle.
1237  */
1238 struct GNUNET_PSYC_StateRequest;
1239
1240
1241 /**
1242  * Retrieve the best matching channel state variable.
1243  *
1244  * If the requested variable name is not present in the state, the nearest
1245  * less-specific name is matched; for example, requesting "_a_b" will match "_a"
1246  * if "_a_b" does not exist.
1247  *
1248  * @param channel
1249  *        Channel handle.
1250  * @param full_name
1251  *        Full name of the requested variable.
1252  *        The actual variable returned might have a shorter name.
1253  * @param var_cb
1254  *        Function called once when a matching state variable is found.
1255  *        Not called if there's no matching state variable.
1256  * @param result_cb
1257  *        Function called after the operation finished.
1258  *        (i.e. all state variables have been returned via @a state_cb)
1259  * @param cls
1260  *        Closure for the callbacks.
1261  */
1262 struct GNUNET_PSYC_StateRequest *
1263 GNUNET_PSYC_channel_state_get (struct GNUNET_PSYC_Channel *channel,
1264                                const char *full_name,
1265                                GNUNET_PSYC_StateVarCallback var_cb,
1266                                GNUNET_ResultCallback result_cb,
1267                                void *cls);
1268
1269
1270 /**
1271  * Return all channel state variables whose name matches a given prefix.
1272  *
1273  * A name matches if it starts with the given @a name_prefix, thus requesting
1274  * the empty prefix ("") will match all values; requesting "_a_b" will also
1275  * return values stored under "_a_b_c".
1276  *
1277  * The @a state_cb is invoked on all matching state variables asynchronously, as
1278  * the state is stored in and retrieved from the PSYCstore,
1279  *
1280  * @param channel
1281  *        Channel handle.
1282  * @param name_prefix
1283  *        Prefix of the state variable name to match.
1284  * @param var_cb
1285  *        Function called once when a matching state variable is found.
1286  *        Not called if there's no matching state variable.
1287  * @param result_cb
1288  *        Function called after the operation finished.
1289  *        (i.e. all state variables have been returned via @a state_cb)
1290  * @param cls
1291  *        Closure for the callbacks.
1292  */
1293 struct GNUNET_PSYC_StateRequest *
1294 GNUNET_PSYC_channel_state_get_prefix (struct GNUNET_PSYC_Channel *channel,
1295                                       const char *name_prefix,
1296                                       GNUNET_PSYC_StateVarCallback var_cb,
1297                                       GNUNET_ResultCallback result_cb,
1298                                       void *cls);
1299
1300 /**
1301  * Cancel a state request operation.
1302  *
1303  * @param sr
1304  *        Handle for the operation to cancel.
1305  */
1306 void
1307 GNUNET_PSYC_channel_state_get_cancel (struct GNUNET_PSYC_StateRequest *sr);
1308
1309
1310
1311 #if 0                           /* keep Emacsens' auto-indent happy */
1312 {
1313 #endif
1314 #ifdef __cplusplus
1315 }
1316 #endif
1317
1318 /* ifndef GNUNET_PSYC_SERVICE_H */
1319 #endif
1320 /* end of gnunet_psyc_service.h */