src/core/core.h

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2009 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 core/core.h
  23  * @brief common internal definitions for core service
  24  * @author Christian Grothoff
  25  */
  26 #include "gnunet_crypto_lib.h"
  27 #include "gnunet_time_lib.h"
  28
  29 /**
  30  * General core debugging.
  31  */
  32 #define DEBUG_CORE GNUNET_YES
  33
  34 /**
  35  * Debugging interaction core-clients.
  36  */
  37 #define DEBUG_CORE_CLIENT GNUNET_YES
  38
  39 /**
  40  * Definition of bits in the InitMessage's options field that specify
  41  * which events this client cares about.  Note that inbound messages
  42  * for handlers that were specifically registered are always
  43  * transmitted to the client.
  44  */
  45 #define GNUNET_CORE_OPTION_NOTHING             0
  46 #define GNUNET_CORE_OPTION_SEND_PRE_CONNECT    1
  47 #define GNUNET_CORE_OPTION_SEND_CONNECT        2
  48 #define GNUNET_CORE_OPTION_SEND_DISCONNECT     4
  49 #define GNUNET_CORE_OPTION_SEND_FULL_INBOUND   8
  50 #define GNUNET_CORE_OPTION_SEND_HDR_INBOUND   16
  51 #define GNUNET_CORE_OPTION_SEND_FULL_OUTBOUND 32
  52 #define GNUNET_CORE_OPTION_SEND_HDR_OUTBOUND  64
  53
  54
  55 /**
  56  * Message transmitted core clients to gnunet-service-core
  57  * to start the interaction.  This header is followed by
  58  * uint16_t type values specifying which messages this
  59  * client is interested in.
  60  */
  61 struct InitMessage
  62 {
  63
  64   /**
  65    * Header with type GNUNET_MESSAGE_TYPE_CORE_INIT.
  66    */
  67   struct GNUNET_MessageHeader header;
  68
  69   /**
  70    * Options, see GNUNET_CORE_OPTION_ values.
  71    */
  72   uint32_t options GNUNET_PACKED;
  73
  74 };
  75
  76
  77 /**
  78  * Message transmitted by the gnunet-service-core process
  79  * to its clients in response to an INIT message.
  80  */
  81 struct InitReplyMessage
  82 {
  83
  84   /**
  85    * Header with type GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY
  86    */
  87   struct GNUNET_MessageHeader header;
  88
  89   /**
  90    * Always zero.
  91    */
  92   uint32_t reserved GNUNET_PACKED;
  93
  94   /**
  95    * Public key of the local peer.
  96    */
  97   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded publicKey;
  98
  99 };
 100
 101
 102 /**
 103  * Message sent by the service to clients to notify them
 104  * about a peer connecting or disconnecting.
 105  */
 106 struct ConnectNotifyMessage
 107 {
 108   /**
 109    * Header with type GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT
 110    * or GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT.
 111    */
 112   struct GNUNET_MessageHeader header;
 113
 114   /**
 115    * Distance to the peer.
 116    */
 117   uint32_t distance GNUNET_PACKED;
 118
 119   /**
 120    * Currently observed latency.
 121    */
 122   struct GNUNET_TIME_RelativeNBO latency;
 123
 124   /**
 125    * Identity of the connecting peer.
 126    */
 127   struct GNUNET_PeerIdentity peer;
 128
 129 };
 130
 131
 132
 133 /**
 134  * Message sent by the service to clients to notify them
 135  * about a peer disconnecting.
 136  */
 137 struct DisconnectNotifyMessage
 138 {
 139   /**
 140    * Header with type GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT.
 141    */
 142   struct GNUNET_MessageHeader header;
 143
 144   /**
 145    * Always zero.
 146    */
 147   uint32_t reserved GNUNET_PACKED;
 148
 149   /**
 150    * Identity of the connecting peer.
 151    */
 152   struct GNUNET_PeerIdentity peer;
 153
 154 };
 155
 156
 157
 158 /**
 159  * Message sent by the service to clients to notify them about
 160  * messages being received or transmitted.  This overall message is
 161  * followed by the real message, or just the header of the real
 162  * message (depending on the client's preferences).  The receiver can
 163  * tell if he got the full message or only a partial message by
 164  * looking at the size field in the header of NotifyTrafficMessage and
 165  * checking it with the size field in the message that follows.
 166  */
 167 struct NotifyTrafficMessage
 168 {
 169   /**
 170    * Header with type GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND
 171    * or GNUNET_MESSAGE_TYPE_CORE_NOTIFY_OUTBOUND.
 172    */
 173   struct GNUNET_MessageHeader header;
 174
 175   /**
 176    * Distance to the peer.
 177    */
 178   uint32_t distance GNUNET_PACKED;
 179
 180   /**
 181    * Currently observed latency.
 182    */
 183   struct GNUNET_TIME_RelativeNBO latency;
 184
 185   /**
 186    * Identity of the receiver or sender.
 187    */
 188   struct GNUNET_PeerIdentity peer;
 189
 190 };
 191
 192
 193 /**
 194  * Message sent to the core asking for configuration
 195  * information and possibly preference changes.
 196  */
 197 struct RequestInfoMessage
 198 {
 199   /**
 200    * Header with type GNUNET_MESSAGE_TYPE_CORE_REQUEST_CONFIGURE
 201    */
 202   struct GNUNET_MessageHeader header;
 203
 204   /**
 205    * Always zero.
 206    */
 207   uint32_t reserved GNUNET_PACKED;
 208
 209   /**
 210    * Limit the number of bytes of outbound traffic to this
 211    * peer to at most the specified amount (naturally, the
 212    * amount is also limited by the receiving peer).
 213    */
 214   uint32_t limit_outbound_bpm GNUNET_PACKED;
 215
 216   /**
 217    * Number of bytes of inbound traffic to reserve, can
 218    * be negative (to unreserve).  NBO.
 219    */
 220   int32_t reserve_inbound GNUNET_PACKED;
 221
 222   /**
 223    * Increment the current traffic preference for the given peer by
 224    * the specified amont.  The traffic preference is used to determine
 225    * the share of bandwidth this peer will typcially be assigned.
 226    */
 227   uint64_t preference_change GNUNET_PACKED;
 228
 229   /**
 230    * Identity of the peer being configured.
 231    */
 232   struct GNUNET_PeerIdentity peer;
 233
 234 };
 235
 236
 237 /**
 238  * Response from the core to a "RequestInfoMessage"
 239  * providing traffic status information for a peer.
 240  */
 241 struct ConfigurationInfoMessage
 242 {
 243   /**
 244    * Header with type GNUNET_MESSAGE_TYPE_CORE_CONFIGURATION_INFO
 245    */
 246   struct GNUNET_MessageHeader header;
 247
 248   /**
 249    * Amount of traffic (inbound number of bytes) that was reserved in
 250    * response to the configuration change request.  Negative for
 251    * "unreserved" bytes.
 252    */
 253   int32_t reserved_amount GNUNET_PACKED;
 254
 255   /**
 256    * Available bandwidth in (in bytes per minute) for this peer.
 257    * 0 if we have been disconnected.
 258    */
 259   uint32_t bpm_in GNUNET_PACKED;
 260
 261   /**
 262    * Available bandwidth out (in bytes per minute) for this peer,
 263    * 0 if we have been disconnected.
 264    */
 265   uint32_t bpm_out GNUNET_PACKED;
 266
 267   /**
 268    * Current traffic preference for the peer.
 269    * 0 if we have been disconnected.
 270    */
 271   uint64_t preference;
 272
 273   /**
 274    * Identity of the receiver or sender.
 275    */
 276   struct GNUNET_PeerIdentity peer;
 277
 278 };
 279
 280
 281 /**
 282  * Client asking core to transmit a particular message to
 283  * a particular target.
 284  */
 285 struct SendMessage
 286 {
 287   /**
 288    * Header with type GNUNET_MESSAGE_TYPE_CORE_SEND
 289    */
 290   struct GNUNET_MessageHeader header;
 291
 292   /**
 293    * How important is this message?
 294    */
 295   uint32_t priority GNUNET_PACKED;
 296
 297   /**
 298    * By what time would the sender really like to see this
 299    * message transmitted?
 300    */
 301   struct GNUNET_TIME_AbsoluteNBO deadline;
 302
 303   /**
 304    * Identity of the receiver or sender.
 305    */
 306   struct GNUNET_PeerIdentity peer;
 307
 308 };
 309
 310
 311 /**
 312  * Client asking core to connect to a particular target.  There is no
 313  * response from the core to this type of request (however, if an
 314  * actual connection is created or destroyed, be it because of this
 315  * type request or not, the core generally needs to notify the
 316  * clients).
 317  */
 318 struct ConnectMessage
 319 {
 320   /**
 321    * Header with type GNUNET_MESSAGE_TYPE_REQUEST_CONNECT or
 322    * GNUNET_MESSAGE_TYPE_REQUEST_DISCONNECT.
 323    */
 324   struct GNUNET_MessageHeader header;
 325
 326   /**
 327    * For alignment.
 328    */
 329   uint32_t reserved GNUNET_PACKED;
 330
 331   /**
 332    * Identity of the other peer.
 333    */
 334   struct GNUNET_PeerIdentity peer;
 335
 336 };
 337
 338 /* end of core.h */