src/cadet/gnunet-service-cadet.h

   1
   2 /*
   3      This file is part of GNUnet.
   4      Copyright (C) 2001-2017 GNUnet e.V.
   5
   6      GNUnet is free software; you can redistribute it and/or modify
   7      it under the terms of the GNU General Public License as published
   8      by the Free Software Foundation; either version 3, or (at your
   9      option) any later version.
  10
  11      GNUnet is distributed in the hope that it will be useful, but
  12      WITHOUT ANY WARRANTY; without even the implied warranty of
  13      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14      General Public License for more details.
  15
  16      You should have received a copy of the GNU General Public License
  17      along with GNUnet; see the file COPYING.  If not, write to the
  18      Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19      Boston, MA 02110-1301, USA.
  20 */
  21
  22 /**
  23  * @file cadet/gnunet-service-cadet.h
  24  * @brief Information we track per peer.
  25  * @author Bartlomiej Polot
  26  * @author Christian Grothoff
  27  */
  28 #ifndef GNUNET_SERVICE_CADET_H
  29 #define GNUNET_SERVICE_CADET_H
  30
  31 #include "gnunet_util_lib.h"
  32 #include "cadet_protocol.h"
  33
  34 /**
  35  * A client to the CADET service.  Each client gets a unique handle.
  36  */
  37 struct CadetClient;
  38
  39 /**
  40  * A peer in the GNUnet network.  Each peer we care about must have one globally
  41  * unique such handle within this process.
  42  */
  43 struct CadetPeer;
  44
  45 /**
  46  * Tunnel from us to another peer.  There can only be at most one
  47  * tunnel per peer.
  48  */
  49 struct CadetTunnel;
  50
  51 /**
  52  * Entry in the message queue of a `struct CadetTunnel`.
  53  */
  54 struct CadetTunnelQueueEntry;
  55
  56 /**
  57  * A path of peer in the GNUnet network.  There must only be at most
  58  * once such path.  Paths may share disjoint prefixes, but must all
  59  * end at a unique suffix.  Paths must also not be proper subsets of
  60  * other existing paths.
  61  */
  62 struct CadetPeerPath;
  63
  64 /**
  65  * Entry in a peer path.
  66  */
  67 struct CadetPeerPathEntry
  68 {
  69   /**
  70    * DLL of paths where the same @e peer is at the same offset.
  71    */
  72   struct CadetPeerPathEntry *next;
  73
  74   /**
  75    * DLL of paths where the same @e peer is at the same offset.
  76    */
  77   struct CadetPeerPathEntry *prev;
  78
  79   /**
  80    * The peer at this offset of the path.
  81    */
  82   struct CadetPeer *peer;
  83
  84   /**
  85    * Path this entry belongs to.
  86    */
  87   struct CadetPeerPath *path;
  88
  89   /**
  90    * Connection using this path, or NULL for none.
  91    */
  92   struct CadetConnection *cc;
  93
  94   /**
  95    * Path's historic score up to this point.  Basically, how often did
  96    * we succeed or fail to use the path up to this entry in a
  97    * connection.  Positive values indicate good experiences, negative
  98    * values bad experiences.  Code updating the score must guard
  99    * against overflows.
 100    */
 101   int score;
 102
 103 };
 104
 105 /**
 106  * Entry in list of connections used by tunnel, with metadata.
 107  */
 108 struct CadetTConnection
 109 {
 110   /**
 111    * Next in DLL.
 112    */
 113   struct CadetTConnection *next;
 114
 115   /**
 116    * Prev in DLL.
 117    */
 118   struct CadetTConnection *prev;
 119
 120   /**
 121    * Connection handle.
 122    */
 123   struct CadetConnection *cc;
 124
 125   /**
 126    * Tunnel this connection belongs to.
 127    */
 128   struct CadetTunnel *t;
 129
 130   /**
 131    * Creation time, to keep oldest connection alive.
 132    */
 133   struct GNUNET_TIME_Absolute created;
 134
 135   /**
 136    * Connection throughput, to keep fastest connection alive.
 137    */
 138   uint32_t throughput;
 139
 140   /**
 141    * Is the connection currently ready for transmission?
 142    */
 143   int is_ready;
 144 };
 145
 146
 147 /**
 148  * Port opened by a client.
 149  */
 150 struct OpenPort
 151 {
 152
 153   /**
 154    * Client that opened the port.
 155    */
 156   struct CadetClient *c;
 157
 158   /**
 159    * Port number.
 160    */
 161   struct GNUNET_HashCode port;
 162
 163   /**
 164    * Port hashed with our PID (matches incoming OPEN messages).
 165    */
 166   struct GNUNET_HashCode h_port;
 167
 168 };
 169
 170
 171 /**
 172  * Active path through the network (used by a tunnel).  There may
 173  * be at most one connection per path.
 174  */
 175 struct CadetConnection;
 176
 177 /**
 178  * Description of a segment of a `struct CadetConnection` at the
 179  * intermediate peers.  Routes are basically entries in a peer's
 180  * routing table for forwarding traffic.  At both endpoints, the
 181  * routes are terminated by a `struct CadetConnection`, which knows
 182  * the complete `struct CadetPath` that is formed by the individual
 183  * routes.
 184  */
 185 struct CadetRoute;
 186
 187 /**
 188  * Logical end-to-end conenction between clients.  There can be
 189  * any number of channels between clients.
 190  */
 191 struct CadetChannel;
 192
 193 /**
 194  * Handle to our configuration.
 195  */
 196 extern const struct GNUNET_CONFIGURATION_Handle *cfg;
 197
 198 /**
 199  * Handle to the statistics service.
 200  */
 201 extern struct GNUNET_STATISTICS_Handle *stats;
 202
 203 /**
 204  * Handle to communicate with ATS.
 205  */
 206 extern struct GNUNET_ATS_ConnectivityHandle *ats_ch;
 207
 208 /**
 209  * Local peer own ID.
 210  */
 211 extern struct GNUNET_PeerIdentity my_full_id;
 212
 213 /**
 214  * Own private key.
 215  */
 216 extern struct GNUNET_CRYPTO_EddsaPrivateKey *my_private_key;
 217
 218 /**
 219  * All ports clients of this peer have opened.  Maps from
 220  * a hashed port to a `struct OpenPort`.
 221  */
 222 extern struct GNUNET_CONTAINER_MultiHashMap *open_ports;
 223
 224 /**
 225  * Map from `struct GNUNET_CADET_ConnectionTunnelIdentifier`
 226  * hash codes to `struct CadetConnection` objects.
 227  */
 228 extern struct GNUNET_CONTAINER_MultiShortmap *connections;
 229
 230 /**
 231  * Map from ports to channels where the ports were closed at the
 232  * time we got the inbound connection.
 233  * Indexed by h_port, contains `struct CadetChannel`.
 234  */
 235 extern struct GNUNET_CONTAINER_MultiHashMap *loose_channels;
 236
 237 /**
 238  * Map from PIDs to `struct CadetPeer` entries.
 239  */
 240 extern struct GNUNET_CONTAINER_MultiPeerMap *peers;
 241
 242 /**
 243  * How many messages are needed to trigger an AXOLOTL ratchet advance.
 244  */
 245 extern unsigned long long ratchet_messages;
 246
 247 /**
 248  * How long until we trigger a ratched advance due to time.
 249  */
 250 extern struct GNUNET_TIME_Relative ratchet_time;
 251
 252 /**
 253  * How frequently do we send KEEPALIVE messages on idle connections?
 254  */
 255 extern struct GNUNET_TIME_Relative keepalive_period;
 256
 257 /**
 258  * Signal that shutdown is happening: prevent recovery measures.
 259  */
 260 extern int shutting_down;
 261
 262 /**
 263  * Set to non-zero values to create random drops to test retransmissions.
 264  */
 265 extern unsigned long long drop_percent;
 266
 267
 268 /**
 269  * Send a message to a client.
 270  *
 271  * @param c client to get the message
 272  * @param env envelope with the message
 273  */
 274 void
 275 GSC_send_to_client (struct CadetClient *c,
 276                     struct GNUNET_MQ_Envelope *env);
 277
 278
 279 /**
 280  * A channel was destroyed by the other peer. Tell our client.
 281  *
 282  * @param c client that lost a channel
 283  * @param ccn channel identification number for the client
 284  * @param ch the channel object
 285  */
 286 void
 287 GSC_handle_remote_channel_destroy (struct CadetClient *c,
 288                                    struct GNUNET_CADET_ClientChannelNumber ccn,
 289                                    struct CadetChannel *ch);
 290
 291 /**
 292  * A client that created a loose channel that was not bound to a port
 293  * disconnected, drop it from the #loose_channels list.
 294  *
 295  * @param h_port the hashed port the channel was trying to bind to
 296  * @param ch the channel that was lost
 297  */
 298 void
 299 GSC_drop_loose_channel (const struct GNUNET_HashCode *h_port,
 300                         struct CadetChannel *ch);
 301
 302
 303 /**
 304  * Bind incoming channel to this client, and notify client
 305  * about incoming connection.
 306  *
 307  * @param c client to bind to
 308  * @param ch channel to be bound
 309  * @param dest peer that establishes the connection
 310  * @param port port number
 311  * @param options options
 312  * @return local channel number assigned to the new client
 313  */
 314 struct GNUNET_CADET_ClientChannelNumber
 315 GSC_bind (struct CadetClient *c,
 316           struct CadetChannel *ch,
 317           struct CadetPeer *dest,
 318           const struct GNUNET_HashCode *port,
 319           uint32_t options);
 320
 321
 322 /**
 323  * Return identifier for a client as a string.
 324  *
 325  * @param c client to identify
 326  * @return string for debugging
 327  */
 328 const char *
 329 GSC_2s (struct CadetClient *c);
 330
 331
 332 #endif