src/core/core.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 core/core.h
  23  * @brief common internal definitions for core service
  24  * @author Christian Grothoff
  25  */
  26 #ifndef CORE_H
  27 #define CORE_H
  28
  29 #include "gnunet_bandwidth_lib.h"
  30 #include "gnunet_transport_service.h"
  31 #include "gnunet_crypto_lib.h"
  32 #include "gnunet_time_lib.h"
  33
  34 /**
  35  * General core debugging.
  36  */
  37 #define DEBUG_CORE GNUNET_EXTRA_LOGGING
  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_STATUS_CHANGE  4
  47 #define GNUNET_CORE_OPTION_SEND_FULL_INBOUND   8
  48 #define GNUNET_CORE_OPTION_SEND_HDR_INBOUND   16
  49 #define GNUNET_CORE_OPTION_SEND_FULL_OUTBOUND 32
  50 #define GNUNET_CORE_OPTION_SEND_HDR_OUTBOUND  64
  51
  52
  53 GNUNET_NETWORK_STRUCT_BEGIN
  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_PeerIdentity my_identity;
  98
  99 };
 100
 101
 102 /**
 103  * Message sent by the service to clients to notify them
 104  * about a peer connecting.
 105  */
 106 struct ConnectNotifyMessage
 107 {
 108   /**
 109    * Header with type GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT
 110    */
 111   struct GNUNET_MessageHeader header;
 112
 113   /**
 114    * Number of ATS key-value pairs that follow this struct
 115    */
 116   uint32_t ats_count GNUNET_PACKED;
 117
 118   /**
 119    * Identity of the connecting peer.
 120    */
 121   struct GNUNET_PeerIdentity peer;
 122
 123 };
 124
 125
 126 /**
 127  * Message sent by the service to clients to notify them
 128  * about a peer changing status.
 129  */
 130 struct PeerStatusNotifyMessage
 131 {
 132   /**
 133    * Header with type GNUNET_MESSAGE_TYPE_CORE_NOTIFY_PEER_STATUS
 134    */
 135   struct GNUNET_MessageHeader header;
 136
 137   /**
 138    * Number of ATS key-value pairs that follow this struct
 139    * (excluding the 0-terminator).
 140    */
 141   uint32_t ats_count GNUNET_PACKED;
 142
 143   /**
 144    * When the peer would time out (unless we see activity)
 145    */
 146   struct GNUNET_TIME_AbsoluteNBO timeout;
 147
 148   /**
 149    * Available bandwidth from the peer.
 150    */
 151   struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in;
 152
 153   /**
 154    * Available bandwidth to the peer.
 155    */
 156   struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out;
 157
 158   /**
 159    * Identity of the peer.
 160    */
 161   struct GNUNET_PeerIdentity peer;
 162
 163   /**
 164    * First of the ATS information blocks (we must have at least
 165    * one due to the 0-termination requirement).
 166    */
 167   struct GNUNET_ATS_Information ats;
 168
 169 };
 170
 171
 172 /**
 173  * Message sent by the service to clients to notify them
 174  * about a peer disconnecting.
 175  */
 176 struct DisconnectNotifyMessage
 177 {
 178   /**
 179    * Header with type GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT.
 180    */
 181   struct GNUNET_MessageHeader header;
 182
 183   /**
 184    * Always zero.
 185    */
 186   uint32_t reserved GNUNET_PACKED;
 187
 188   /**
 189    * Identity of the connecting peer.
 190    */
 191   struct GNUNET_PeerIdentity peer;
 192
 193 };
 194
 195
 196 /**
 197  * Message sent by the service to clients to notify them about
 198  * messages being received or transmitted.  This overall message is
 199  * followed by the real message, or just the header of the real
 200  * message (depending on the client's preferences).  The receiver can
 201  * tell if he got the full message or only a partial message by
 202  * looking at the size field in the header of NotifyTrafficMessage and
 203  * checking it with the size field in the message that follows.
 204  */
 205 struct NotifyTrafficMessage
 206 {
 207   /**
 208    * Header with type GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND
 209    * or GNUNET_MESSAGE_TYPE_CORE_NOTIFY_OUTBOUND.
 210    */
 211   struct GNUNET_MessageHeader header;
 212
 213   /**
 214    * Number of ATS key-value pairs that follow this struct
 215    * (excluding the 0-terminator).
 216    */
 217   uint32_t ats_count GNUNET_PACKED;
 218
 219   /**
 220    * Identity of the receiver or sender.
 221    */
 222   struct GNUNET_PeerIdentity peer;
 223
 224   /* Followed by ATS information blocks:
 225    * struct GNUNET_ATS_Information ats[ats_count]
 226    */
 227
 228   /* Followed by payload (message or just header), variable size */
 229 };
 230
 231
 232 /**
 233  * Client notifying core about the maximum-priority
 234  * message it has in the queue for a particular target.
 235  */
 236 struct SendMessageRequest
 237 {
 238   /**
 239    * Header with type GNUNET_MESSAGE_TYPE_CORE_SEND_REQUEST
 240    */
 241   struct GNUNET_MessageHeader header;
 242
 243   /**
 244    * How important is this message?
 245    */
 246   uint32_t priority GNUNET_PACKED;
 247
 248   /**
 249    * By what time would the sender really like to see this
 250    * message transmitted?
 251    */
 252   struct GNUNET_TIME_AbsoluteNBO deadline;
 253
 254   /**
 255    * Identity of the intended target.
 256    */
 257   struct GNUNET_PeerIdentity peer;
 258
 259   /**
 260    * How large is the client's message queue for this peer?
 261    */
 262   uint32_t queue_size GNUNET_PACKED;
 263
 264   /**
 265    * How large is the message?
 266    */
 267   uint16_t size GNUNET_PACKED;
 268
 269   /**
 270    * Counter for this peer to match SMRs to replies.
 271    */
 272   uint16_t smr_id GNUNET_PACKED;
 273
 274 };
 275
 276
 277 /**
 278  * Core notifying client that it is allowed to now
 279  * transmit a message to the given target
 280  * (response to GNUNET_MESSAGE_TYPE_CORE_SEND_REQUEST).
 281  */
 282 struct SendMessageReady
 283 {
 284   /**
 285    * Header with type GNUNET_MESSAGE_TYPE_CORE_SEND_READY
 286    */
 287   struct GNUNET_MessageHeader header;
 288
 289   /**
 290    * How many bytes are allowed for transmission?
 291    * Guaranteed to be at least as big as the requested size,
 292    * or ZERO if the request is rejected (will timeout,
 293    * peer disconnected, queue full, etc.).
 294    */
 295   uint16_t size GNUNET_PACKED;
 296
 297   /**
 298    * smr_id from the request.
 299    */
 300   uint16_t smr_id GNUNET_PACKED;
 301
 302   /**
 303    * Identity of the intended target.
 304    */
 305   struct GNUNET_PeerIdentity peer;
 306
 307 };
 308
 309
 310 /**
 311  * Client asking core to transmit a particular message to a particular
 312  * target (response to GNUNET_MESSAGE_TYPE_CORE_SEND_READY).
 313  */
 314 struct SendMessage
 315 {
 316   /**
 317    * Header with type GNUNET_MESSAGE_TYPE_CORE_SEND
 318    */
 319   struct GNUNET_MessageHeader header;
 320
 321   /**
 322    * How important is this message?
 323    */
 324   uint32_t priority GNUNET_PACKED;
 325
 326   /**
 327    * By what time would the sender really like to see this
 328    * message transmitted?
 329    */
 330   struct GNUNET_TIME_AbsoluteNBO deadline;
 331
 332   /**
 333    * Identity of the intended receiver.
 334    */
 335   struct GNUNET_PeerIdentity peer;
 336
 337   /**
 338    * GNUNET_YES if corking is allowed, GNUNET_NO if not.
 339    */
 340   uint32_t cork GNUNET_PACKED;
 341
 342   /**
 343    * Always 0.
 344    */
 345   uint64_t reserved GNUNET_PACKED;
 346
 347 };
 348
 349
 350 GNUNET_NETWORK_STRUCT_END
 351 #endif
 352 /* end of core.h */