src/include/gnunet_core_service.h

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2009, 2010 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., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file include/gnunet_core_service.h
  23  * @brief core service; this is the main API for encrypted P2P
  24  *        communications
  25  * @author Christian Grothoff
  26  */
  27
  28 #ifndef GNUNET_CORE_SERVICE_H
  29 #define GNUNET_CORE_SERVICE_H
  30
  31 #ifdef __cplusplus
  32 extern "C"
  33 {
  34 #if 0                           /* keep Emacsens' auto-indent happy */
  35 }
  36 #endif
  37 #endif
  38
  39 #include "gnunet_util_lib.h"
  40
  41 /**
  42  * Version number of GNUnet-core API.
  43  */
  44 #define GNUNET_CORE_VERSION 0x00000000
  45
  46
  47 /**
  48  * Opaque handle to the service.
  49  */
  50 struct GNUNET_CORE_Handle;
  51
  52
  53 /**
  54  * Method called whenever a given peer connects.
  55  *
  56  * @param cls closure
  57  * @param peer peer identity this notification is about
  58  * @param latency reported latency of the connection with 'other'
  59  * @param distance reported distance (DV) to 'other'
  60  */
  61 typedef void (*GNUNET_CORE_ConnectEventHandler) (void *cls,
  62                                                  const struct
  63                                                  GNUNET_PeerIdentity * peer,
  64                                                  struct GNUNET_TIME_Relative latency,
  65                                                  uint32_t distance);
  66
  67 /**
  68  * Method called whenever a given peer has a status change.
  69  *
  70  * @param cls closure
  71  * @param peer peer identity this notification is about
  72  * @param latency reported latency of the connection with 'other'
  73  * @param distance reported distance (DV) to 'other'
  74  * @param bandwidth_in available amount of inbound bandwidth
  75  * @param bandwidth_out available amount of outbound bandwidth
  76  * @param timeout absolute time when this peer will time out
  77  *        unless we see some further activity from it
  78  */
  79 typedef void (*GNUNET_CORE_PeerStatusEventHandler) (void *cls,
  80                                                     const struct
  81                                                     GNUNET_PeerIdentity * peer,
  82                                                     struct GNUNET_TIME_Relative latency,
  83                                                     uint32_t distance,
  84                                                     struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
  85                                                     struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
  86                                                     struct GNUNET_TIME_Absolute timeout);
  87
  88
  89 /**
  90  * Method called whenever a given peer either disconnects.
  91  *
  92  * @param cls closure
  93  * @param peer peer identity this notification is about
  94  */
  95 typedef void (*GNUNET_CORE_DisconnectEventHandler) (void *cls,
  96                                                     const struct
  97                                                     GNUNET_PeerIdentity * peer);
  98
  99
 100 /**
 101  * Functions with this signature are called whenever a message is
 102  * received or transmitted.
 103  *
 104  * @param cls closure
 105  * @param peer the other peer involved (sender or receiver, NULL
 106  *        for loopback messages where we are both sender and receiver)
 107  * @param message the actual message
 108  * @param latency reported latency of the connection with 'other'
 109  * @param distance reported distance (DV) to 'other'
 110  * @return GNUNET_OK to keep the connection open,
 111  *         GNUNET_SYSERR to close it (signal serious error)
 112  */
 113 typedef int
 114   (*GNUNET_CORE_MessageCallback) (void *cls,
 115                                   const struct GNUNET_PeerIdentity * other,
 116                                   const struct GNUNET_MessageHeader *
 117                                   message,
 118                                   struct GNUNET_TIME_Relative latency,
 119                                   uint32_t distance);
 120
 121
 122 /**
 123  * Message handler.  Each struct specifies how to handle on particular
 124  * type of message received.
 125  */
 126 struct GNUNET_CORE_MessageHandler
 127 {
 128   /**
 129    * Function to call for messages of "type".
 130    */
 131   GNUNET_CORE_MessageCallback callback;
 132
 133   /**
 134    * Type of the message this handler covers.
 135    */
 136   uint16_t type;
 137
 138   /**
 139    * Expected size of messages of this type.  Use 0 for variable-size.
 140    * If non-zero, messages of the given type will be discarded if they
 141    * do not have the right size.
 142    */
 143   uint16_t expected_size;
 144
 145 };
 146
 147
 148 /**
 149  * Function called after GNUNET_CORE_connect has succeeded
 150  * (or failed for good).  Note that the private key of the
 151  * peer is intentionally not exposed here; if you need it,
 152  * your process should try to read the private key file
 153  * directly (which should work if you are authorized...).
 154  *
 155  * @param cls closure
 156  * @param server handle to the server, NULL if we failed
 157  * @param my_identity ID of this peer, NULL if we failed
 158  * @param publicKey public key of this peer, NULL if we failed
 159  */
 160 typedef void
 161   (*GNUNET_CORE_StartupCallback) (void *cls,
 162                                   struct GNUNET_CORE_Handle * server,
 163                                   const struct GNUNET_PeerIdentity *
 164                                   my_identity,
 165                                   const struct
 166                                   GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *
 167                                   publicKey);
 168
 169
 170 /**
 171  * Connect to the core service.  Note that the connection may complete
 172  * (or fail) asynchronously.  This function primarily causes the given
 173  * callback notification functions to be invoked whenever the
 174  * specified event happens.  The maximum number of queued
 175  * notifications (queue length) is per client but the queue is shared
 176  * across all types of notifications.  So a slow client that registers
 177  * for 'outbound_notify' also risks missing 'inbound_notify' messages.
 178  * Certain events (such as connect/disconnect notifications) are not
 179  * subject to queue size limitations.
 180  *
 181  * @param sched scheduler to use
 182  * @param cfg configuration to use
 183  * @param timeout after how long should we give up trying to connect to the core service?
 184  * @param cls closure for the various callbacks that follow (including handlers in the handlers array)
 185  * @param init callback to call on timeout or once we have successfully
 186  *        connected to the core service; note that timeout is only meaningful if init is not NULL
 187  * @param connects function to call on peer connect, can be NULL
 188  * @param disconnects function to call on peer disconnect / timeout, can be NULL
 189  * @param status_events function to call on peer status changes, can be NULL
 190  * @param inbound_notify function to call for all inbound messages, can be NULL
 191  *                note that the core is allowed to drop notifications about inbound
 192  *                messages if the client does not process them fast enough (for this
 193  *                notification type, a bounded queue is used)
 194  * @param inbound_hdr_only set to GNUNET_YES if inbound_notify will only read the
 195  *                GNUNET_MessageHeader and hence we do not need to give it the full message;
 196  *                can be used to improve efficiency, ignored if inbound_notify is NULL
 197  *                note that the core is allowed to drop notifications about inbound
 198  *                messages if the client does not process them fast enough (for this
 199  *                notification type, a bounded queue is used)
 200  * @param outbound_notify function to call for all outbound messages, can be NULL;
 201  *                note that the core is allowed to drop notifications about outbound
 202  *                messages if the client does not process them fast enough (for this
 203  *                notification type, a bounded queue is used)
 204  * @param outbound_hdr_only set to GNUNET_YES if outbound_notify will only read the
 205  *                GNUNET_MessageHeader and hence we do not need to give it the full message
 206  *                can be used to improve efficiency, ignored if outbound_notify is NULL
 207  *                note that the core is allowed to drop notifications about outbound
 208  *                messages if the client does not process them fast enough (for this
 209  *                notification type, a bounded queue is used)
 210  * @param handlers callbacks for messages we care about, NULL-terminated
 211  *                note that the core is allowed to drop notifications about inbound
 212  *                messages if the client does not process them fast enough (for this
 213  *                notification type, a bounded queue is used)
 214  * @return handle to the core service (only useful for disconnect until 'init' is called),
 215  *           NULL on error (in this case, init is never called)
 216  */
 217 struct GNUNET_CORE_Handle *
 218 GNUNET_CORE_connect (struct GNUNET_SCHEDULER_Handle *sched,
 219                      const struct GNUNET_CONFIGURATION_Handle *cfg,
 220                      struct GNUNET_TIME_Relative timeout,
 221                      void *cls,
 222                      GNUNET_CORE_StartupCallback init,
 223                      GNUNET_CORE_ConnectEventHandler connects,
 224                      GNUNET_CORE_DisconnectEventHandler disconnects,
 225                      GNUNET_CORE_PeerStatusEventHandler status_events,
 226                      GNUNET_CORE_MessageCallback inbound_notify,
 227                      int inbound_hdr_only,
 228                      GNUNET_CORE_MessageCallback outbound_notify,
 229                      int outbound_hdr_only,
 230                      const struct GNUNET_CORE_MessageHandler *handlers);
 231
 232
 233 /**
 234  * Disconnect from the core service.
 235  *
 236  * @param handle connection to core to disconnect
 237  */
 238 void GNUNET_CORE_disconnect (struct GNUNET_CORE_Handle *handle);
 239
 240
 241 /**
 242  * Handle for a request to the core to connect or disconnect
 243  * from a particular peer.  Can be used to cancel the request
 244  * (before the 'cont'inuation is called).
 245  */
 246 struct GNUNET_CORE_PeerRequestHandle;
 247
 248
 249 /**
 250  * Request that the core should try to connect to a particular peer.
 251  * Once the request has been transmitted to the core, the continuation
 252  * function will be called.  Note that this does NOT mean that a
 253  * connection was successfully established -- it only means that the
 254  * core will now try.  Successful establishment of the connection
 255  * will be signalled to the 'connects' callback argument of
 256  * 'GNUNET_CORE_connect' only.  If the core service does not respond
 257  * to our connection attempt within the given time frame, 'cont' will
 258  * be called with the TIMEOUT reason code.
 259  *
 260  * @param sched scheduler to use
 261  * @param cfg configuration to use
 262  * @param timeout how long to try to talk to core
 263  * @param peer who should we connect to
 264  * @param cont function to call once the request has been completed (or timed out)
 265  * @param cont_cls closure for cont
 266  * @return NULL on error (cont will not be called), otherwise handle for cancellation
 267  */
 268 struct GNUNET_CORE_PeerRequestHandle *
 269 GNUNET_CORE_peer_request_connect (struct GNUNET_SCHEDULER_Handle *sched,
 270                                   const struct GNUNET_CONFIGURATION_Handle *cfg,
 271                                   struct GNUNET_TIME_Relative timeout,
 272                                   const struct GNUNET_PeerIdentity * peer,
 273                                   GNUNET_SCHEDULER_Task cont,
 274                                   void *cont_cls);
 275
 276
 277 /**
 278  * Cancel a pending request to connect to a particular peer.  Must not
 279  * be called after the 'cont' function was invoked.
 280  *
 281  * @param req request handle that was returned for the original request
 282  */
 283 void
 284 GNUNET_CORE_peer_request_connect_cancel (struct GNUNET_CORE_PeerRequestHandle *req);
 285
 286
 287 /**
 288  * Function called with statistics about the given peer.
 289  *
 290  * @param cls closure
 291  * @param peer identifies the peer
 292  * @param bpm_in set to the current bandwidth limit (receiving) for this peer
 293  * @param bpm_out set to the current bandwidth limit (sending) for this peer
 294  * @param latency current latency estimate, "FOREVER" if we have been
 295  *                disconnected
 296  * @param amount set to the amount that was actually reserved or unreserved;
 297  *               either the full requested amount or zero (no partial reservations)
 298  * @param preference current traffic preference for the given peer
 299  */
 300 typedef void
 301   (*GNUNET_CORE_PeerConfigurationInfoCallback) (void *cls,
 302                                                 const struct
 303                                                 GNUNET_PeerIdentity * peer,
 304                                                 struct GNUNET_BANDWIDTH_Value32NBO bpm_in,
 305                                                 struct GNUNET_BANDWIDTH_Value32NBO bpm_out,
 306                                                 int amount,
 307                                                 uint64_t preference);
 308
 309
 310
 311 /**
 312  * Context that can be used to cancel a peer information request.
 313  */
 314 struct GNUNET_CORE_InformationRequestContext;
 315
 316
 317 /**
 318  * Obtain statistics and/or change preferences for the given peer.
 319  *
 320  * @param sched scheduler to use
 321  * @param cfg configuration to use
 322  * @param peer identifies the peer
 323  * @param timeout after how long should we give up (and call "info" with NULL
 324  *                for "peer" to signal an error)?
 325  * @param bw_out set to the current bandwidth limit (sending) for this peer,
 326  *                caller should set "bpm_out" to "-1" to avoid changing
 327  *                the current value; otherwise "bw_out" will be lowered to
 328  *                the specified value; passing a pointer to "0" can be used to force
 329  *                us to disconnect from the peer; "bw_out" might not increase
 330  *                as specified since the upper bound is generally
 331  *                determined by the other peer!
 332  * @param amount reserve N bytes for receiving, negative
 333  *                amounts can be used to undo a (recent) reservation;
 334  * @param preference increase incoming traffic share preference by this amount;
 335  *                in the absence of "amount" reservations, we use this
 336  *                preference value to assign proportional bandwidth shares
 337  *                to all connected peers
 338  * @param info function to call with the resulting configuration information
 339  * @param info_cls closure for info
 340  * @return NULL on error
 341  */
 342 struct GNUNET_CORE_InformationRequestContext *
 343 GNUNET_CORE_peer_change_preference (struct GNUNET_SCHEDULER_Handle *sched,
 344                                     const struct GNUNET_CONFIGURATION_Handle *cfg,
 345                                     const struct GNUNET_PeerIdentity *peer,
 346                                     struct GNUNET_TIME_Relative timeout,
 347                                     struct GNUNET_BANDWIDTH_Value32NBO bw_out,
 348                                     int32_t amount,
 349                                     uint64_t preference,
 350                                     GNUNET_CORE_PeerConfigurationInfoCallback info,
 351                                     void *info_cls);
 352
 353
 354 /**
 355  * Cancel request for getting information about a peer.
 356  *
 357  * @param irc context returned by the original GNUNET_CORE_peer_get_info call
 358  */
 359 void
 360 GNUNET_CORE_peer_change_preference_cancel (struct GNUNET_CORE_InformationRequestContext *irc);
 361
 362
 363 /**
 364  * Handle for a transmission request.
 365  */
 366 struct GNUNET_CORE_TransmitHandle;
 367
 368
 369 /**
 370  * Ask the core to call "notify" once it is ready to transmit the
 371  * given number of bytes to the specified "target".  If we are not yet
 372  * connected to the specified peer, a call to this function will cause
 373  * us to try to establish a connection.
 374  *
 375  * @param handle connection to core service
 376  * @param priority how important is the message?
 377  * @param maxdelay how long can the message wait?
 378  * @param target who should receive the message,
 379  *        use NULL for this peer (loopback)
 380  * @param notify_size how many bytes of buffer space does notify want?
 381  * @param notify function to call when buffer space is available
 382  * @param notify_cls closure for notify
 383  * @return non-NULL if the notify callback was queued,
 384  *         NULL if we can not even queue the request (insufficient
 385  *         memory); if NULL is returned, "notify" will NOT be called.
 386  */
 387 struct GNUNET_CORE_TransmitHandle *
 388 GNUNET_CORE_notify_transmit_ready (struct
 389                                    GNUNET_CORE_Handle
 390                                    *handle,
 391                                    uint32_t priority,
 392                                    struct
 393                                    GNUNET_TIME_Relative
 394                                    maxdelay,
 395                                    const
 396                                    struct
 397                                    GNUNET_PeerIdentity
 398                                    *target,
 399                                    size_t
 400                                    notify_size,
 401                                    GNUNET_CONNECTION_TransmitReadyNotify
 402                                    notify,
 403                                    void
 404                                    *notify_cls);
 405
 406
 407 /**
 408  * Cancel the specified transmission-ready notification.
 409  *
 410  * @param th handle that was returned by "notify_transmit_ready".
 411  */
 412 void
 413 GNUNET_CORE_notify_transmit_ready_cancel (struct GNUNET_CORE_TransmitHandle
 414                                           *th);
 415
 416
 417 #if 0                           /* keep Emacsens' auto-indent happy */
 418 {
 419 #endif
 420 #ifdef __cplusplus
 421 }
 422 #endif
 423
 424 /* ifndef GNUNET_CORE_SERVICE_H */
 425 #endif
 426 /* end of gnunet_core_service.h */