src/mesh/mesh2.h

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2001 - 2011 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  * @author Bartlomiej Polot
  23  * @file mesh/mesh.h
  24  */
  25
  26 #ifndef MESH_H_
  27 #define MESH_H_
  28
  29 #ifdef __cplusplus
  30 extern "C"
  31 {
  32 #if 0                           /* keep Emacsens' auto-indent happy */
  33 }
  34 #endif
  35 #endif
  36
  37 #include <stdint.h>
  38
  39 #define MESH_DEBUG              GNUNET_YES
  40
  41 #define INITIAL_WINDOW_SIZE     8
  42 #define ACK_THRESHOLD           INITIAL_WINDOW_SIZE / 2
  43
  44 #include "platform.h"
  45 #include "gnunet_common.h"
  46 #include "gnunet_util_lib.h"
  47 #include "gnunet_peer_lib.h"
  48 #include "gnunet_core_service.h"
  49 #include "gnunet_protocols.h"
  50 #include <gnunet_mesh_service.h>
  51
  52 /******************************************************************************/
  53 /********************        MESH LOCAL MESSAGES      *************************/
  54 /******************************************************************************/
  55 /*  Any API call should be documented in the folowing table under API CALL.
  56  *  Also, any message type should be documented in the following table, with the
  57  * associated event.
  58  *
  59  * API CALL (GNUNET_MESH_*)             MESSAGE USED
  60  * ------------------------             ------------
  61  * connect                              GNUNET_MESH_ClientConnect
  62  * disconnect                           None (network level disconnect)
  63  *
  64  * tunnel_create                        GNUNET_MESH_TunnelMessage
  65  * tunnel_destroy                       GNUNET_MESH_TunnelMessage
  66  * tunnel_buffer                        GNUNET_MESH_TunnelMessage
  67  *
  68  * notify_transmit_ready                None (queue / GNUNET_CLIENT_ntf_tmt_rdy)
  69  * notify_transmit_ready_cancel         None (clear of internal data structures)
  70  *
  71  *
  72  * EVENT                                MESSAGE USED
  73  * -----                                ------------
  74  * data                                 GNUNET_MESH_Unicast OR
  75  *                                      GNUNET_MESH_Multicast OR
  76  *                                      GNUNET_MESH_ToOrigin
  77  * data ack                             GNUNET_MESH_LocalAck
  78  *
  79  * new incoming tunnel                  GNUNET_MESH_PeerControl
  80  * peer connects to a tunnel            FIXME
  81  * peer disconnects from a tunnel       FIXME
  82  */
  83
  84 /******************************************************************************/
  85 /**************************       CONSTANTS      ******************************/
  86 /******************************************************************************/
  87
  88 #define GNUNET_MESH_LOCAL_TUNNEL_ID_CLI         0x80000000
  89 #define GNUNET_MESH_LOCAL_TUNNEL_ID_SERV        0xB0000000
  90
  91 #define HIGH_PID                                0xFFFF0000
  92 #define LOW_PID                                 0x0000FFFF
  93
  94 #define PID_OVERFLOW(pid, max) (pid > HIGH_PID && max < LOW_PID)
  95
  96 /******************************************************************************/
  97 /**************************        MESSAGES      ******************************/
  98 /******************************************************************************/
  99
 100 GNUNET_NETWORK_STRUCT_BEGIN
 101
 102 /**
 103  * Message for a client to register to the service
 104  */
 105 struct GNUNET_MESH_ClientConnect
 106 {
 107     /**
 108      * Type: GNUNET_MESSAGE_TYPE_MESH_LOCAL_CONNECT
 109      *
 110      * Size: sizeof(struct GNUNET_MESH_ClientConnect) +
 111      *       sizeof(MESH_ApplicationType) * applications +
 112      *       sizeof(uint16_t) * types
 113      */
 114   struct GNUNET_MessageHeader header;
 115   /* uint32_t                 list_ports[]           */
 116 };
 117
 118
 119 /**
 120  * Type for tunnel numbering.
 121  * - Local tunnel numbers given by the service (incoming) are >= 0xB0000000
 122  * - Local tunnel numbers given by the client (created) are >= 0x80000000
 123  * - Global tunnel numbers are < 0x80000000
 124  */
 125 typedef uint32_t MESH_TunnelNumber;
 126
 127
 128 /**
 129  * Message for a client to create and destroy tunnels.
 130  */
 131 struct GNUNET_MESH_TunnelMessage
 132 {
 133     /**
 134      * Type: GNUNET_MESSAGE_TYPE_MESH_LOCAL_TUNNEL_[CREATE|DESTROY]
 135      *
 136      * Size: sizeof(struct GNUNET_MESH_TunnelMessage)
 137      */
 138   struct GNUNET_MessageHeader header;
 139
 140     /**
 141      * ID of a tunnel controlled by this client.
 142      */
 143   MESH_TunnelNumber tunnel_id GNUNET_PACKED;
 144
 145     /**
 146      * Tunnel's peer
 147      */
 148   struct GNUNET_PeerIdentity peer;
 149
 150     /**
 151      * Port of the tunnel.
 152      */
 153   uint32_t port GNUNET_PACKED;
 154 };
 155
 156
 157 /**
 158  * Message for the service to let a client know about created tunnels.
 159  */
 160 struct GNUNET_MESH_TunnelNotification
 161 {
 162     /**
 163      * Type: GNUNET_MESSAGE_TYPE_MESH_LOCAL_TUNNEL_CREATE
 164      *
 165      * Size: sizeof(struct GNUNET_MESH_TunnelMessage)
 166      */
 167   struct GNUNET_MessageHeader header;
 168
 169     /**
 170      * ID of a tunnel controlled by this client.
 171      */
 172   MESH_TunnelNumber tunnel_id GNUNET_PACKED;
 173
 174     /**
 175      * Peer at the other end.
 176      */
 177   struct GNUNET_PeerIdentity peer;
 178
 179     /**
 180      * Port for this tunnel
 181      */
 182   uint32_t port GNUNET_PACKED;
 183
 184     /**
 185      * Tunnel options (speed, buffering)
 186      */
 187   uint32_t opt GNUNET_PACKED;
 188 };
 189
 190
 191 /**
 192  * Message to allow the client send more data to the service
 193  * (always service -> client).
 194  */
 195 struct GNUNET_MESH_LocalAck
 196 {
 197     /**
 198      * Type: GNUNET_MESSAGE_TYPE_MESH_LOCAL_ACK
 199      */
 200   struct GNUNET_MessageHeader header;
 201
 202     /**
 203      * ID of the tunnel allowed to send more data.
 204      */
 205   MESH_TunnelNumber tunnel_id GNUNET_PACKED;
 206
 207     /**
 208      * ID of the last packet allowed.
 209      */
 210   uint32_t max_pid GNUNET_PACKED;
 211 };
 212
 213
 214 /**
 215  * Message to inform the client about tunnels in the service.
 216  */
 217 struct GNUNET_MESH_LocalMonitor
 218 {
 219   /**
 220      * Type: GNUNET_MESSAGE_TYPE_MESH_LOCAL_MONITOR[_TUNNEL]
 221    */
 222   struct GNUNET_MessageHeader header;
 223
 224   /**
 225    * ID of the tunnel allowed to send more data.
 226    */
 227   MESH_TunnelNumber tunnel_id GNUNET_PACKED;
 228
 229   /**
 230    * Alignment.
 231    */
 232   uint32_t reserved GNUNET_PACKED;
 233
 234   /**
 235    * ID of the owner of the tunnel (can be local peer).
 236    */
 237   struct GNUNET_PeerIdentity owner;
 238
 239   /**
 240    * ID of the destination of the tunnel (can be local peer).
 241    */
 242   struct GNUNET_PeerIdentity destination;
 243 };
 244
 245
 246 GNUNET_NETWORK_STRUCT_END
 247
 248 /******************************************************************************/
 249 /************************        ENUMERATIONS      ****************************/
 250 /******************************************************************************/
 251
 252 /**
 253  * All the states a tunnel can be in.
 254  */
 255 enum MeshTunnelState
 256 {
 257     /**
 258      * Uninitialized status, should never appear in operation.
 259      */
 260   MESH_TUNNEL_NEW,
 261
 262     /**
 263      * Path to the peer not known yet
 264      */
 265   MESH_TUNNEL_SEARCHING,
 266
 267     /**
 268      * Request sent, not yet answered.
 269      */
 270   MESH_TUNNEL_WAITING,
 271
 272     /**
 273      * Peer connected and ready to accept data
 274      */
 275   MESH_TUNNEL_READY,
 276
 277     /**
 278      * Peer connected previosly but not responding
 279      */
 280   MESH_TUNNEL_RECONNECTING
 281 };
 282
 283
 284 /**
 285  * Check if one pid is bigger than other, accounting for overflow.
 286  *
 287  * @param bigger Argument that should be bigger.
 288  * @param smaller Argument that should be smaller.
 289  *
 290  * @return True if bigger (arg1) has a higher value than smaller (arg 2).
 291  */
 292 int
 293 GMC_is_pid_bigger (uint32_t bigger, uint32_t smaller);
 294
 295
 296 /**
 297  * Get the higher ACK value out of two values, taking in account overflow.
 298  *
 299  * @param a First ACK value.
 300  * @param b Second ACK value.
 301  *
 302  * @return Highest ACK value from the two.
 303  */
 304 uint32_t
 305 GMC_max_pid (uint32_t a, uint32_t b);
 306
 307
 308 /**
 309  * Get the lower ACK value out of two values, taking in account overflow.
 310  *
 311  * @param a First ACK value.
 312  * @param b Second ACK value.
 313  *
 314  * @return Lowest ACK value from the two.
 315  */
 316 uint32_t
 317 GMC_min_pid (uint32_t a, uint32_t b);
 318
 319
 320 /**
 321  * Expand a 32 bit value (message type) into a hash for a MultiHashMap (fast).
 322  * WARNING: do not use for anything other than MultiHashMap!
 323  *          does not alter anything other than bits used by idx_of !
 324  *
 325  * @param i 32 bit integer value.
 326  * @param h Hash code to fill.
 327  */
 328 void
 329 GMC_hash32 (uint32_t i, struct GNUNET_HashCode *h);
 330
 331
 332 /**
 333  * Convert a message type into a string to help debug
 334  * Generated with:
 335  * FIND:        "#define ([^ ]+)[ ]*([0-9]+)"
 336  * REPLACE:     "    case \2: return "\1"; break;"
 337  *
 338  * @param m Message type.
 339  *
 340  * @return Human readable string description.
 341  */
 342 const char *
 343 GNUNET_MESH_DEBUG_M2S (uint16_t m);
 344
 345 #if 0                           /* keep Emacsens' auto-indent happy */
 346 {
 347 #endif
 348 #ifdef __cplusplus
 349 }
 350 #endif
 351
 352 #endif