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