src/cadet/cadet_protocol.h

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2001 - 2011 GNUnet e.V.
   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., 51 Franklin Street, Fifth Floor,
  18      Boston, MA 02110-1301, USA.
  19 */
  20
  21 /**
  22  * @author Bartlomiej Polot
  23  * @file cadet/cadet_protocol.h
  24  */
  25
  26 #ifndef CADET_PROTOCOL_H_
  27 #define CADET_PROTOCOL_H_
  28
  29 #include "platform.h"
  30 #include "gnunet_util_lib.h"
  31 #include "cadet.h"
  32
  33 #ifdef __cplusplus
  34
  35 struct GNUNET_CADET_TunnelMessage;
  36 extern "C"
  37 {
  38 #if 0
  39   /* keep Emacsens' auto-indent happy */
  40 }
  41 #endif
  42 #endif
  43
  44 /******************************************************************************/
  45 /********************      CADET NETWORK MESSAGES     **************************/
  46 /******************************************************************************/
  47
  48 GNUNET_NETWORK_STRUCT_BEGIN
  49
  50
  51 /******************************************************************************/
  52 /*****************************   CONNECTION  **********************************/
  53 /******************************************************************************/
  54
  55
  56 /**
  57  * Message for cadet connection creation.
  58  */
  59 struct GNUNET_CADET_ConnectionCreateMessage
  60 {
  61   /**
  62    * Type: #GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE
  63    *
  64    * Size: sizeof (struct GNUNET_CADET_ConnectionCreateMessage) +
  65    *       path_length * sizeof (struct GNUNET_PeerIdentity)
  66    */
  67   struct GNUNET_MessageHeader header;
  68
  69   /**
  70    * For alignment.
  71    */
  72   uint32_t reserved GNUNET_PACKED;
  73
  74   /**
  75    * ID of the connection
  76    */
  77   struct GNUNET_CADET_ConnectionTunnelIdentifier cid;
  78
  79   /**
  80    * path_length structs defining the *whole* path from the origin [0] to the
  81    * final destination [path_length-1].
  82    */
  83   /* struct GNUNET_PeerIdentity peers[path_length]; */
  84 };
  85
  86
  87 /**
  88  * Message for ack'ing a connection
  89  */
  90 struct GNUNET_CADET_ConnectionCreateMessageAckMessage
  91 {
  92   /**
  93    * Type: #GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE_ACK
  94    */
  95   struct GNUNET_MessageHeader header;
  96
  97   /**
  98    * For alignment.
  99    */
 100   uint32_t reserved GNUNET_PACKED;
 101
 102   /**
 103    * ID of the connection.
 104    */
 105   struct GNUNET_CADET_ConnectionTunnelIdentifier cid;
 106
 107 };
 108
 109
 110 /**
 111  * Message for notifying a disconnection in a path
 112  */
 113 struct GNUNET_CADET_ConnectionBrokenMessage
 114 {
 115   /**
 116    * Type: #GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN
 117    */
 118   struct GNUNET_MessageHeader header;
 119
 120   /**
 121    * For alignment.
 122    */
 123   uint32_t reserved GNUNET_PACKED;
 124
 125   /**
 126    * ID of the connection.
 127    */
 128   struct GNUNET_CADET_ConnectionTunnelIdentifier cid;
 129
 130   /**
 131    * ID of the endpoint
 132    */
 133   struct GNUNET_PeerIdentity peer1;
 134
 135   /**
 136    * ID of the endpoint
 137    */
 138   struct GNUNET_PeerIdentity peer2;
 139 };
 140
 141
 142 /**
 143  * Message to destroy a connection.
 144  */
 145 struct GNUNET_CADET_ConnectionDestroyMessage
 146 {
 147   /**
 148    * Type: #GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY
 149    */
 150   struct GNUNET_MessageHeader header;
 151
 152   /**
 153    * For alignment.
 154    */
 155   uint32_t reserved GNUNET_PACKED;
 156
 157   /**
 158    * ID of the connection.
 159    */
 160   struct GNUNET_CADET_ConnectionTunnelIdentifier cid;
 161 };
 162
 163
 164 /**
 165  * Unique identifier (counter) for an encrypted message in a channel.
 166  * Used to match #GNUNET_MESSAGE_TYPE_CADET_ENCRYPTED_HOP_BY_HOP_ACK
 167  * and  #GNUNET_MESSAGE_TYPE_CADET_CONNECTION_HOP_BY_HOP_POLL messages
 168  * against the respective  #GNUNET_MESSAGE_TYPE_CONNECTION_ENCRYPTED
 169  * messages.
 170  */
 171 struct CadetEncryptedMessageIdentifier
 172 {
 173   /**
 174    * This number is incremented by one per message. It may wrap around.
 175    * In network byte order.
 176    */
 177   uint32_t pid GNUNET_PACKED;
 178 };
 179
 180
 181 /**
 182  * Message to acknowledge cadet encrypted traffic.
 183  */
 184 struct GNUNET_CADET_ConnectionEncryptedAckMessage
 185 {
 186   /**
 187    * Type: #GNUNET_MESSAGE_TYPE_CADET_ENCRYPTED_HOP_BY_HOP_ACK
 188    */
 189   struct GNUNET_MessageHeader header;
 190
 191   /**
 192    * Maximum packet ID authorized.
 193    */
 194   struct CadetEncryptedMessageIdentifier cemi;
 195
 196   /**
 197    * ID of the connection.
 198    */
 199   struct GNUNET_CADET_ConnectionTunnelIdentifier cid;
 200 };
 201
 202
 203 /**
 204  * Message to query a peer about its Flow Control status regarding a tunnel.
 205  */
 206 struct GNUNET_CADET_ConnectionHopByHopPollMessage
 207 {
 208   /**
 209    * Type: #GNUNET_MESSAGE_TYPE_CADET_CONNECTION_HOP_BY_HOP_POLL
 210    */
 211   struct GNUNET_MessageHeader header;
 212
 213   /**
 214    * Last packet sent.
 215    */
 216   struct CadetEncryptedMessageIdentifier cemi;
 217
 218   /**
 219    * ID of the connection.
 220    */
 221   struct GNUNET_CADET_ConnectionTunnelIdentifier cid;
 222
 223 };
 224
 225
 226
 227 /******************************************************************************/
 228 /*******************************   TUNNEL   ***********************************/
 229 /******************************************************************************/
 230
 231 /**
 232  * Flags to be used in GNUNET_CADET_KX.
 233  */
 234 enum GNUNET_CADET_KX_Flags {
 235
 236   /**
 237    * Should the peer reply with its KX details?
 238    */
 239   GNUNET_CADET_KX_FLAG_NONE = 0,
 240
 241   /**
 242    * The peer should reply with its KX details?
 243    */
 244   GNUNET_CADET_KX_FLAG_FORCE_REPLY = 1
 245 };
 246
 247
 248 /**
 249  * Message for a Key eXchange for a tunnel.
 250  */
 251 struct GNUNET_CADET_TunnelKeyExchangeMessage
 252 {
 253   /**
 254    * Type: #GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX.
 255    */
 256   struct GNUNET_MessageHeader header;
 257
 258   /**
 259    * Flags for the key exchange in NBO, based on
 260    * `enum GNUNET_CADET_KX_Flags`.
 261    */
 262   uint32_t flags GNUNET_PACKED;
 263
 264   /**
 265    * ID of the connection.
 266    */
 267   struct GNUNET_CADET_ConnectionTunnelIdentifier cid;
 268
 269   /**
 270    * Sender's ephemeral public ECC key encoded in a
 271    * format suitable for network transmission, as created
 272    * using 'gcry_sexp_sprint'.
 273    */
 274   struct GNUNET_CRYPTO_EcdhePublicKey ephemeral_key;
 275
 276   /**
 277    * Sender's next ephemeral public ECC key encoded in a
 278    * format suitable for network transmission, as created
 279    * using 'gcry_sexp_sprint'.
 280    */
 281   struct GNUNET_CRYPTO_EcdhePublicKey ratchet_key;
 282 };
 283
 284
 285 /**
 286  * Axolotl tunnel message.
 287  */
 288 struct GNUNET_CADET_ConnectionEncryptedMessage
 289 {
 290   /**
 291    * Type: #GNUNET_MESSAGE_TYPE_CONNECTION_ENCRYPTED
 292    */
 293   struct GNUNET_MessageHeader header;
 294
 295   /**
 296    * ID of the packet (hop by hop).
 297    */
 298   struct CadetEncryptedMessageIdentifier cemi;
 299
 300   /**
 301    * ID of the connection.
 302    */
 303   struct GNUNET_CADET_ConnectionTunnelIdentifier cid;
 304
 305   /**
 306    * MAC of the encrypted message, used to verify message integrity.
 307    * Everything after this value  will be encrypted with the header key
 308    * and authenticated.
 309    */
 310   struct GNUNET_ShortHashCode hmac;
 311
 312   /**************** AX_HEADER start ****************/
 313
 314   /**
 315    * Number of messages sent with the current ratchet key.
 316    */
 317   uint32_t Ns GNUNET_PACKED;
 318
 319   /**
 320    * Number of messages sent with the previous ratchet key.
 321    */
 322   uint32_t PNs GNUNET_PACKED;
 323
 324   /**
 325    * Current ratchet key.
 326    */
 327   struct GNUNET_CRYPTO_EcdhePublicKey DHRs;
 328
 329   /**************** AX_HEADER  end  ****************/
 330
 331   /**
 332    * Encrypted content follows.
 333    */
 334 };
 335
 336
 337
 338 /******************************************************************************/
 339 /*******************************   CHANNEL  ***********************************/
 340 /******************************************************************************/
 341
 342 #ifndef NEW_CADET
 343
 344 /**
 345  * Message to create a Channel.
 346  */
 347 struct GNUNET_CADET_ChannelCreateMessage
 348 {
 349   /**
 350    * Type: #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_CREATE
 351    */
 352   struct GNUNET_MessageHeader header;
 353
 354   /**
 355    * Channel options.
 356    */
 357   uint32_t opt GNUNET_PACKED;
 358
 359   /**
 360    * Destination port.
 361    */
 362   struct GNUNET_HashCode port;
 363
 364   /**
 365    * ID of the channel
 366    */
 367   struct GNUNET_CADET_ChannelNumber chid;
 368 };
 369
 370 #endif
 371
 372 /**
 373  * Message to manage a Channel (ACK, NACK, Destroy).
 374  */
 375 struct GNUNET_CADET_ChannelManageMessage
 376 {
 377   /**
 378    * Type: #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_{ACK|NACK|DESTROY}
 379    */
 380   struct GNUNET_MessageHeader header;
 381
 382   /**
 383    * ID of the channel
 384    */
 385   struct GNUNET_CADET_ChannelNumber chid;
 386 };
 387
 388
 389 #ifndef NEW_CADET
 390
 391 /**
 392  * Message for cadet data traffic.
 393  */
 394 struct GNUNET_CADET_ChannelDataMessage
 395 {
 396   /**
 397    * Type: #GNUNET_MESSAGE_TYPE_CADET_UNICAST,
 398    *       #GNUNET_MESSAGE_TYPE_CADET_TO_ORIGIN
 399    */
 400   struct GNUNET_MessageHeader header;
 401
 402   /**
 403    * Unique ID of the payload message
 404    */
 405   /* NEW: struct ChannelMessageIdentifier */
 406   uint32_t mid GNUNET_PACKED;
 407
 408   /**
 409    * ID of the channel
 410    */
 411   struct GNUNET_CADET_ChannelNumber chid;
 412
 413   /**
 414    * Payload follows
 415    */
 416 };
 417
 418
 419 /**
 420  * Message to acknowledge end-to-end data.
 421  */
 422 struct GNUNET_CADET_ChannelDataAckMessage
 423 {
 424   /**
 425    * Type: #GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DATA_ACK
 426    */
 427   struct GNUNET_MessageHeader header;
 428
 429   /**
 430    * ID of the channel
 431    */
 432   struct GNUNET_CADET_ChannelNumber chid;
 433
 434   /**
 435    * Bitfield of already-received newer messages
 436    * pid +  1 @ LSB
 437    * pid + 64 @ MSB
 438    */
 439   uint64_t futures GNUNET_PACKED;
 440
 441   /**
 442    * Last message ID received.
 443    */
 444   /* NEW: struct ChannelMessageIdentifier */
 445   uint32_t mid GNUNET_PACKED;
 446 };
 447
 448 #endif
 449
 450 GNUNET_NETWORK_STRUCT_END
 451
 452 #if 0                           /* keep Emacsens' auto-indent happy */
 453 {
 454 #endif
 455 #ifdef __cplusplus
 456 }
 457 #endif
 458
 459 /* ifndef CADET_PROTOCOL_H */
 460 #endif
 461 /* end of cadet_protocol.h */