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 2, 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 either connects or
  55  * disconnects (or list of connections was requested).
  56  *
  57  * @param cls closure
  58  * @param peer peer identity this notification is about
  59  */
  60 typedef void (*GNUNET_CORE_ClientEventHandler) (void *cls,
  61                                                 const struct
  62                                                 GNUNET_PeerIdentity * peer);
  63
  64
  65 /**
  66  * Functions with this signature are called whenever a message is
  67  * received or transmitted.
  68  *
  69  * @param cls closure
  70  * @param peer the other peer involved (sender or receiver, NULL
  71  *        for loopback messages where we are both sender and receiver)
  72  * @param message the actual message
  73  * @return GNUNET_OK to keep the connection open,
  74  *         GNUNET_SYSERR to close it (signal serious error)
  75  */
  76 typedef int
  77   (*GNUNET_CORE_MessageCallback) (void *cls,
  78                                   const struct GNUNET_PeerIdentity * other,
  79                                   const struct GNUNET_MessageHeader *
  80                                   message);
  81
  82
  83 /**
  84  * Message handler.  Each struct specifies how to handle on particular
  85  * type of message received.
  86  */
  87 struct GNUNET_CORE_MessageHandler
  88 {
  89   /**
  90    * Function to call for messages of "type".
  91    */
  92   GNUNET_CORE_MessageCallback callback;
  93
  94   /**
  95    * Type of the message this handler covers.
  96    */
  97   uint16_t type;
  98
  99   /**
 100    * Expected size of messages of this type.  Use 0 for variable-size.
 101    * If non-zero, messages of the given type will be discarded if they
 102    * do not have the right size.
 103    */
 104   uint16_t expected_size;
 105
 106 };
 107
 108
 109 /**
 110  * Function called after GNUNET_CORE_connect has succeeded
 111  * (or failed for good).  Note that the private key of the
 112  * peer is intentionally not exposed here; if you need it,
 113  * your process should try to read the private key file
 114  * directly (which should work if you are authorized...).
 115  *
 116  * @param cls closure
 117  * @param server handle to the server, NULL if we failed
 118  * @param my_identity ID of this peer, NULL if we failed
 119  * @param publicKey public key of this peer, NULL if we failed
 120  */
 121 typedef void
 122   (*GNUNET_CORE_StartupCallback) (void *cls,
 123                                   struct GNUNET_CORE_Handle * server,
 124                                   const struct GNUNET_PeerIdentity *
 125                                   my_identity,
 126                                   const struct
 127                                   GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *
 128                                   publicKey);
 129
 130
 131 /**
 132  * Connect to the core service.  Note that the connection may
 133  * complete (or fail) asynchronously.
 134  *
 135  * @param sched scheduler to use
 136  * @param cfg configuration to use
 137  * @param timeout after how long should we give up trying to connect to the core service?
 138  * @param cls closure for the various callbacks that follow (including handlers in the handlers array)
 139  * @param init callback to call on timeout or once we have successfully
 140  *        connected to the core service; note that timeout is only meaningful if init is not NULL
 141  * @param connects function to call on peer connect, can be NULL
 142  * @param disconnects function to call on peer disconnect / timeout, can be NULL
 143  * @param inbound_notify function to call for all inbound messages, can be NULL
 144  * @param inbound_hdr_only set to GNUNET_YES if inbound_notify will only read the
 145  *                GNUNET_MessageHeader and hence we do not need to give it the full message;
 146  *                can be used to improve efficiency, ignored if inbound_notify is NULLL
 147  * @param outbound_notify function to call for all outbound messages, can be NULL
 148  * @param outbound_hdr_only set to GNUNET_YES if outbound_notify will only read the
 149  *                GNUNET_MessageHeader and hence we do not need to give it the full message
 150  *                can be used to improve efficiency, ignored if outbound_notify is NULLL
 151  * @param handlers callbacks for messages we care about, NULL-terminated
 152  * @return handle to the core service (only useful for disconnect until 'init' is called),
 153  *           NULL on error (in this case, init is never called)
 154  */
 155 struct GNUNET_CORE_Handle *
 156 GNUNET_CORE_connect (struct GNUNET_SCHEDULER_Handle *sched,
 157                      const struct GNUNET_CONFIGURATION_Handle *cfg,
 158                      struct GNUNET_TIME_Relative timeout,
 159                      void *cls,
 160                      GNUNET_CORE_StartupCallback init,
 161                      GNUNET_CORE_ClientEventHandler connects,
 162                      GNUNET_CORE_ClientEventHandler disconnects,
 163                      GNUNET_CORE_MessageCallback inbound_notify,
 164                      int inbound_hdr_only,
 165                      GNUNET_CORE_MessageCallback outbound_notify,
 166                      int outbound_hdr_only,
 167                      const struct GNUNET_CORE_MessageHandler *handlers);
 168
 169
 170 /**
 171  * Disconnect from the core service.
 172  *
 173  * @param handle connection to core to disconnect
 174  */
 175 void GNUNET_CORE_disconnect (struct GNUNET_CORE_Handle *handle);
 176
 177
 178 struct GNUNET_CORE_PeerRequestHandle;
 179
 180 struct GNUNET_CORE_PeerRequestHandle *
 181 struct GNUNET_CORE_peer_request_connect (struct GNUNET_SCHEDULER_Handle *sched,
 182                                          const struct GNUNET_CONFIGURATION_Handle *cfg,
 183                                          const struct GNUNET_PeerIdentity * peer,
 184                                          GNUNET_SCHEDULER_Task cont,
 185                                          void *cont_cls);
 186
 187
 188 struct GNUNET_CORE_PeerRequestHandle *
 189 struct GNUNET_CORE_peer_request_disconnect (struct GNUNET_SCHEDULER_Handle *sched,
 190                                             const struct GNUNET_CONFIGURATION_Handle *cfg,
 191                                             const struct GNUNET_PeerIdentity * peer,
 192                                             GNUNET_SCHEDULER_Task cont,
 193                                             void *cont_cls);
 194
 195 void
 196 GNUNET_CORE_peer_request_cancel (struct GNUNET_CORE_PeerRequestHandle *req);
 197
 198
 199 /**
 200  * Function called with statistics about the given peer.
 201  *
 202  * @param cls closure
 203  * @param peer identifies the peer
 204  * @param bpm_in set to the current bandwidth limit (receiving) for this peer
 205  * @param bpm_out set to the current bandwidth limit (sending) for this peer
 206  * @param latency current latency estimate, "FOREVER" if we have been
 207  *                disconnected
 208  * @param amount set to the amount that was actually reserved or unreserved
 209  * @param preference current traffic preference for the given peer
 210  */
 211 typedef void
 212   (*GNUNET_CORE_PeerConfigurationInfoCallback) (void *cls,
 213                                                 const struct
 214                                                 GNUNET_PeerIdentity * peer,
 215                                                 unsigned int bpm_in,
 216                                                 unsigned int bpm_out,
 217                                                 struct GNUNET_TIME_Relative
 218                                                 latency, int amount,
 219                                                 unsigned long long preference);
 220
 221
 222
 223 /**
 224  * Context that can be used to cancel a peer information request.
 225  */
 226 struct GNUNET_CORE_InformationRequestContext;
 227
 228 /**
 229  * Obtain statistics and/or change preferences for the given peer.
 230  *
 231  * @param sched scheduler to use
 232  * @param cfg configuration to use
 233  * @param peer identifies the peer
 234  * @param timeout after how long should we give up (and call "info" with NULL
 235  *                for "peer" to signal an error)?
 236  * @param bpm_out set to the current bandwidth limit (sending) for this peer,
 237  *                caller should set "bpm_out" to "-1" to avoid changing
 238  *                the current value; otherwise "bpm_out" will be lowered to
 239  *                the specified value; passing a pointer to "0" can be used to force
 240  *                us to disconnect from the peer; "bpm_out" might not increase
 241  *                as specified since the upper bound is generally
 242  *                determined by the other peer!
 243  * @param amount reserve N bytes for receiving, negative
 244  *                amounts can be used to undo a (recent) reservation;
 245  * @param preference increase incoming traffic share preference by this amount;
 246  *                in the absence of "amount" reservations, we use this
 247  *                preference value to assign proportional bandwidth shares
 248  *                to all connected peers
 249  * @param info function to call with the resulting configuration information
 250  * @param info_cls closure for info
 251  * @return NULL on error
 252  */
 253 struct GNUNET_CORE_InformationRequestContext *
 254 GNUNET_CORE_peer_get_info (struct GNUNET_SCHEDULER_Handle *sched,
 255                            const struct GNUNET_CONFIGURATION_Handle *cfg,
 256                            const struct GNUNET_PeerIdentity *peer,
 257                            struct GNUNET_TIME_Relative timeout,
 258                            uint32_t bpm_out,
 259                            int32_t amount,
 260                            uint64_t preference,
 261                            GNUNET_CORE_PeerConfigurationInfoCallback info,
 262                            void *info_cls);
 263
 264
 265 /**
 266  * Cancel request for getting information about a peer.
 267  *
 268  * @param irc context returned by the original GNUNET_CORE_peer_get_info call
 269  */
 270 void
 271 GNUNET_CORE_peer_get_info_cancel (struct GNUNET_CORE_InformationRequestContext *irc);
 272
 273
 274 /**
 275  * Handle for a transmission request.
 276  */
 277 struct GNUNET_CORE_TransmitHandle;
 278
 279
 280 /**
 281  * Ask the core to call "notify" once it is ready to transmit the
 282  * given number of bytes to the specified "target".  If we are not yet
 283  * connected to the specified peer, a call to this function will cause
 284  * us to try to establish a connection.
 285  *
 286  * @param handle connection to core service
 287  * @param priority how important is the message?
 288  * @param maxdelay how long can the message wait?
 289  * @param target who should receive the message,
 290  *        use NULL for this peer (loopback)
 291  * @param notify_size how many bytes of buffer space does notify want?
 292  * @param notify function to call when buffer space is available
 293  * @param notify_cls closure for notify
 294  * @return non-NULL if the notify callback was queued,
 295  *         NULL if we can not even queue the request (insufficient
 296  *         memory); if NULL is returned, "notify" will NOT be called.
 297  */
 298 struct GNUNET_CORE_TransmitHandle *
 299 GNUNET_CORE_notify_transmit_ready (struct
 300                                    GNUNET_CORE_Handle
 301                                    *handle,
 302                                    unsigned
 303                                    int
 304                                    priority,
 305                                    struct
 306                                    GNUNET_TIME_Relative
 307                                    maxdelay,
 308                                    const
 309                                    struct
 310                                    GNUNET_PeerIdentity
 311                                    *target,
 312                                    size_t
 313                                    notify_size,
 314                                    GNUNET_CONNECTION_TransmitReadyNotify
 315                                    notify,
 316                                    void
 317                                    *notify_cls);
 318
 319
 320 /**
 321  * Cancel the specified transmission-ready notification.
 322  *
 323  * @param h handle that was returned by "notify_transmit_ready".
 324  */
 325 void
 326 GNUNET_CORE_notify_transmit_ready_cancel (struct GNUNET_CORE_TransmitHandle
 327                                           *h);
 328
 329
 330 #if 0                           /* keep Emacsens' auto-indent happy */
 331 {
 332 #endif
 333 #ifdef __cplusplus
 334 }
 335 #endif
 336
 337 /* ifndef GNUNET_CORE_SERVICE_H */
 338 #endif
 339 /* end of gnunet_core_service.h */