src/transport/transport.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 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 transport/transport.h
  23  * @brief common internal definitions for transport service
  24  * @author Christian Grothoff
  25  */
  26 #ifndef TRANSPORT_H
  27 #define TRANSPORT_H
  28
  29 #include "gnunet_crypto_lib.h"
  30 #include "gnunet_time_lib.h"
  31 #include "gnunet_transport_service.h"
  32
  33 /* Minimum time between to calculations*/
  34 #define ATS_MIN_INTERVAL  GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 1)
  35 #define ATS_EXEC_INTERVAL GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5)
  36 #define ATS_MAX_EXEC_DURATION GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 500)
  37 #define ATS_MAX_ITERATIONS INT_MAX
  38
  39 struct ATS_info
  40 {
  41         struct GNUNET_CONTAINER_MultiHashMap * peers;
  42         /**
  43          * Time of last execution
  44          */
  45         struct GNUNET_TIME_Absolute last;
  46         /**
  47          * Minimum intervall between two executions
  48          */
  49         struct GNUNET_TIME_Relative min_delta;
  50         /**
  51          * Regular intervall when execution is triggered
  52          */
  53         struct GNUNET_TIME_Relative exec_intervall;
  54         /**
  55          * Maximum execution time per calculation
  56          */
  57         struct GNUNET_TIME_Relative max_exec_duration;
  58         /**
  59          * Maximum number of LP iterations per calculation
  60          */
  61         int max_iterations;
  62
  63         GNUNET_SCHEDULER_TaskIdentifier ats_task;
  64 };
  65
  66 #define DEBUG_TRANSPORT GNUNET_NO
  67 #define DEBUG_TRANSPORT_TIMEOUT GNUNET_NO
  68 #define DEBUG_TRANSPORT_DISCONNECT GNUNET_NO
  69
  70 /**
  71  * For how long do we allow unused bandwidth
  72  * from the past to carry over into the future? (in seconds)
  73  */
  74 #define MAX_BANDWIDTH_CARRY_S 5
  75
  76 /**
  77  * How often do we (at most) do a full quota
  78  * recalculation? (in ms)
  79  */
  80 #define MIN_QUOTA_REFRESH_TIME 2000
  81
  82 /**
  83  * Message from the transport service to the library
  84  * asking to check if both processes agree about this
  85  * peers identity.
  86  */
  87 struct StartMessage
  88 {
  89
  90   /**
  91    * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_START
  92    */
  93   struct GNUNET_MessageHeader header;
  94
  95   /**
  96    * Should the 'self' field be checked?
  97    */
  98   uint32_t do_check;
  99
 100   /**
 101    * Identity we think we have.  If it does not match, the
 102    * receiver should print out an error message and disconnect.
 103    */
 104   struct GNUNET_PeerIdentity self;
 105
 106 };
 107
 108
 109 /**
 110  * Message from the transport service to the library
 111  * informing about neighbors.
 112  */
 113 struct ConnectInfoMessage
 114 {
 115
 116   /**
 117    * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT
 118    */
 119   struct GNUNET_MessageHeader header;
 120
 121   /**
 122    * Number of ATS key-value pairs that follow this struct
 123    * (excluding the 0-terminator).
 124    */
 125   uint32_t ats_count GNUNET_PACKED;
 126
 127   /**
 128    * Identity of the new neighbour.
 129    */
 130   struct GNUNET_PeerIdentity id;
 131
 132   /**
 133    * First of the ATS information blocks (we must have at least
 134    * one due to the 0-termination requirement).
 135    */
 136   struct GNUNET_TRANSPORT_ATS_Information ats;
 137 };
 138
 139
 140 /**
 141  * Message from the transport service to the library
 142  * informing about disconnects.
 143  */
 144 struct DisconnectInfoMessage
 145 {
 146
 147   /**
 148    * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT
 149    */
 150   struct GNUNET_MessageHeader header;
 151
 152   /**
 153    * Reserved, always zero.
 154    */
 155   uint32_t reserved GNUNET_PACKED;
 156
 157   /**
 158    * Who got disconnected?
 159    */
 160   struct GNUNET_PeerIdentity peer;
 161
 162 };
 163
 164 /**
 165  * Message type for sending a request connect message
 166  * to the transport service.  Must be done before transport
 167  * api will allow messages to be queued/sent to transport
 168  * service for transmission to a peer.
 169  */
 170 struct TransportRequestConnectMessage
 171 {
 172   /**
 173    *  Message header
 174    */
 175   struct GNUNET_MessageHeader header;
 176
 177   /**
 178    * Identity of the peer we would like to connect to.
 179    */
 180   struct GNUNET_PeerIdentity peer;
 181 };
 182
 183 /**
 184  * Message used to set a particular bandwidth quota.  Send TO the
 185  * service to set an incoming quota, send FROM the service to update
 186  * an outgoing quota.
 187  */
 188 struct QuotaSetMessage
 189 {
 190
 191   /**
 192    * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_NEIGHBOUR_INFO
 193    */
 194   struct GNUNET_MessageHeader header;
 195
 196   /**
 197    * Quota.
 198    */
 199   struct GNUNET_BANDWIDTH_Value32NBO quota;
 200
 201   /**
 202    * About which peer are we talking here?
 203    */
 204   struct GNUNET_PeerIdentity peer;
 205
 206 };
 207
 208
 209 /**
 210  * Message used to notify the transport API about a message
 211  * received from the network.  The actual message follows.
 212  */
 213 struct InboundMessage
 214 {
 215
 216   /**
 217    * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_RECV
 218    */
 219   struct GNUNET_MessageHeader header;
 220
 221   /**
 222    * Always zero.
 223    */
 224   uint32_t reserved GNUNET_PACKED;
 225
 226   /**
 227    * Number of ATS key-value pairs that follow this struct
 228    * (excluding the 0-terminator).
 229    */
 230   uint32_t ats_count GNUNET_PACKED;
 231
 232   /**
 233    * Which peer sent the message?
 234    */
 235   struct GNUNET_PeerIdentity peer;
 236
 237   /**
 238    * First of the ATS information blocks (we must have at least
 239    * one due to the 0-termination requirement).
 240    */
 241   struct GNUNET_TRANSPORT_ATS_Information ats;
 242 };
 243
 244
 245 /**
 246  * Message used to notify the transport API that it can
 247  * send another message to the transport service.
 248  */
 249 struct SendOkMessage
 250 {
 251
 252   /**
 253    * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK
 254    */
 255   struct GNUNET_MessageHeader header;
 256
 257   /**
 258    * GNUNET_OK if the transmission succeeded,
 259    * GNUNET_SYSERR if it failed (i.e. network disconnect);
 260    * in either case, it is now OK for this client to
 261    * send us another message for the given peer.
 262    */
 263   uint32_t success GNUNET_PACKED;
 264
 265   /**
 266    * Latency estimate.
 267    */
 268   struct GNUNET_TIME_RelativeNBO latency;
 269
 270   /**
 271    * Which peer can send more now?
 272    */
 273   struct GNUNET_PeerIdentity peer;
 274
 275 };
 276
 277
 278 /**
 279  * Message used to notify the transport service about a message
 280  * to be transmitted to another peer.  The actual message follows.
 281  */
 282 struct OutboundMessage
 283 {
 284
 285   /**
 286    * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_SEND
 287    */
 288   struct GNUNET_MessageHeader header;
 289
 290   /**
 291    * Message priority.
 292    */
 293   uint32_t priority GNUNET_PACKED;
 294
 295   /**
 296    * Allowed delay.
 297    */
 298   struct GNUNET_TIME_RelativeNBO timeout;
 299
 300   /**
 301    * Which peer should receive the message?
 302    */
 303   struct GNUNET_PeerIdentity peer;
 304
 305 };
 306
 307
 308 /**
 309  * Message from the library to the transport service
 310  * asking for converting a transport address to a
 311  * human-readable UTF-8 string.
 312  */
 313 struct AddressLookupMessage
 314 {
 315
 316   /**
 317    * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_LOOKUP
 318    */
 319   struct GNUNET_MessageHeader header;
 320
 321   /**
 322    * Should the conversion use numeric IP addresses (otherwise
 323    * a reverse DNS lookup is OK -- if applicable).
 324    */
 325   int32_t numeric_only GNUNET_PACKED;
 326
 327   /**
 328    * timeout to give up.
 329    */
 330   struct GNUNET_TIME_AbsoluteNBO timeout;
 331
 332   /**
 333    * Length of the (binary) address in bytes, in big-endian.
 334    */
 335   uint32_t addrlen GNUNET_PACKED;
 336
 337   /* followed by 'addrlen' bytes of the actual address, then
 338      followed by the 0-terminated name of the transport */
 339 };
 340
 341
 342
 343 /**
 344  * Change in blacklisting (either request or notification,
 345  * depending on which direction it is going).
 346  */
 347 struct BlacklistMessage
 348 {
 349
 350   /**
 351    * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_QUERY or
 352    * GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_REPLY.
 353    */
 354   struct GNUNET_MessageHeader header;
 355
 356   /**
 357    * 0 for the query, GNUNET_OK (allowed) or GNUNET_SYSERR (disallowed)
 358    * for the response.
 359    */
 360   uint32_t is_allowed GNUNET_PACKED;
 361
 362   /**
 363    * Which peer is being blacklisted or queried?
 364    */
 365   struct GNUNET_PeerIdentity peer;
 366
 367 };
 368
 369
 370 /* end of transport.h */
 371 #endif