src/mesh/gnunet-service-mesh.c

   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  * @file mesh/gnunet-service-mesh.c
  23  * @brief GNUnet MESH service
  24  * @author Bartlomiej Polot
  25  *
  26  * STRUCTURE:
  27  * - MESH NETWORK MESSAGES
  28  * - DATA STRUCTURES
  29  * - GLOBAL VARIABLES
  30  * - MESH NETWORK HANDLES
  31  * - MESH LOCAL HANDLES
  32  * - MAIN FUNCTIONS (main & run)
  33  *
  34  * TODO:
  35  * - soft stateing (keep-alive (CHANGE?) / timeout / disconnect) -- not a message issue
  36  * - error reporting (CREATE/CHANGE/ADD/DEL?) -- new message!
  37  * - partial disconnect reporting -- same as error reporting?
  38  * - add vs create? change vs. keep-alive? same msg or different ones? -- thinking...
  39  * - speed requirement specification (change?) in mesh API -- API call
  40  */
  41
  42 #include "platform.h"
  43 #include "gnunet_common.h"
  44 #include "gnunet_util_lib.h"
  45 #include "gnunet_peer_lib.h"
  46 #include "gnunet_core_service.h"
  47 #include "gnunet_protocols.h"
  48 #include "mesh.h"
  49
  50
  51 /******************************************************************************/
  52 /********************      MESH NETWORK MESSAGES     **************************/
  53 /******************************************************************************/
  54
  55 /**
  56  * Message for mesh path management
  57  */
  58 struct GNUNET_MESH_ManipulatePath
  59 {
  60     /**
  61      * Type: GNUNET_MESSAGE_TYPE_MESH_PATH_[CREATE|CHANGE|ADD|DEL]
  62      *
  63      * Size: sizeof(struct GNUNET_MESH_ManipulatePath) +
  64      *       path_length * sizeof (struct GNUNET_PeerIdentity)
  65      */
  66     struct GNUNET_MessageHeader header;
  67
  68     /**
  69      * Global id of the tunnel this path belongs to,
  70      * unique in conjunction with the origin.
  71      */
  72     uint32_t tid GNUNET_PACKED;
  73
  74     /**
  75      * Information about speed requirements.  If the tunnel cannot sustain the
  76      * minimum bandwidth, packets are to be dropped.
  77      */
  78     uint32_t speed_min GNUNET_PACKED;
  79
  80     /**
  81      * 64-bit alignment.
  82      */
  83     uint32_t reserved GNUNET_PACKED;
  84
  85     /**
  86      * path_length structs defining the *whole* path from the origin [0] to the
  87      * final destination [path_length-1].
  88      */
  89     /* struct GNUNET_PeerIdentity peers[path_length]; */
  90 };
  91
  92 /**
  93  * Message for mesh data traffic to all tunnel targets.
  94  */
  95 struct GNUNET_MESH_OriginMulticast
  96 {
  97     /**
  98      * Type: GNUNET_MESSAGE_TYPE_DATA_MULTICAST
  99      */
 100     struct GNUNET_MessageHeader header;
 101
 102     /**
 103      * TID of the tunnel
 104      */
 105     uint32_t tid GNUNET_PACKED;
 106
 107     /**
 108      * OID of the tunnel
 109      */
 110     struct GNUNET_PeerIdentity oid;
 111
 112     /**
 113      * Payload follows
 114      */
 115 };
 116
 117
 118 /**
 119  * Message for mesh data traffic to a particular destination from origin.
 120  */
 121 struct GNUNET_MESH_DataMessageFromOrigin
 122 {
 123     /**
 124      * Type: GNUNET_MESSAGE_TYPE_DATA_MESSAGE_FROM_ORIGIN
 125      */
 126     struct GNUNET_MessageHeader header;
 127
 128     /**
 129      * TID of the tunnel
 130      */
 131     uint32_t tid GNUNET_PACKED;
 132
 133     /**
 134      * OID of the tunnel
 135      */
 136     struct GNUNET_PeerIdentity oid;
 137
 138     /**
 139      * Destination.
 140      */
 141     struct GNUNET_PeerIdentity destination;
 142
 143     /**
 144      * Payload follows
 145      */
 146 };
 147
 148
 149 /**
 150  * Message for mesh data traffic from a tunnel participant to origin.
 151  */
 152 struct GNUNET_MESH_DataMessageToOrigin
 153 {
 154     /**
 155      * Type: GNUNET_MESSAGE_TYPE_DATA_MESSAGE_TO_ORIGIN
 156      */
 157     struct GNUNET_MessageHeader header;
 158
 159     /**
 160      * TID of the tunnel
 161      */
 162     uint32_t tid GNUNET_PACKED;
 163
 164     /**
 165      * OID of the tunnel
 166      */
 167     struct GNUNET_PeerIdentity oid;
 168
 169     /**
 170      * Sender of the message.
 171      */
 172     struct GNUNET_PeerIdentity sender;
 173
 174     /**
 175      * Payload follows
 176      */
 177 };
 178
 179 /**
 180  * Message for mesh flow control
 181  */
 182 struct GNUNET_MESH_SpeedNotify
 183 {
 184     /**
 185      * Type: GNUNET_MESSAGE_TYPE_DATA_SPEED_NOTIFY
 186      */
 187     struct GNUNET_MessageHeader header;
 188
 189     /**
 190      * TID of the tunnel
 191      */
 192     uint32_t tid GNUNET_PACKED;
 193
 194     /**
 195      * OID of the tunnel
 196      */
 197     struct GNUNET_PeerIdentity oid;
 198
 199     /**
 200      * Slowest link down the path (above minimum speed requirement).
 201      */
 202     uint32_t speed_min;
 203
 204 };
 205
 206 /******************************************************************************/
 207 /************************      DATA STRUCTURES     ****************************/
 208 /******************************************************************************/
 209
 210 /**
 211  * All the states a peer participating in a tunnel can be in.
 212  */
 213 enum PeerState
 214 {
 215     /**
 216      * Request sent, not yet answered.
 217      */
 218     MESH_PEER_WAITING,
 219
 220     /**
 221      * Peer connected and ready to accept data
 222      */
 223     MESH_PEER_READY,
 224
 225     /**
 226      * Peer connected previosly but not responding
 227      */
 228     MESH_PEER_RECONNECTING,
 229
 230 };
 231
 232 /**
 233  * Struct containing all information regarding a given peer
 234  */
 235 struct PeerInfo
 236 {
 237     /**
 238      * ID of the peer
 239      */
 240     GNUNET_PEER_Id              id;
 241
 242     /**
 243      * Is the peer reachable? Is the peer even connected?
 244      */
 245     enum PeerState state;
 246
 247     /**
 248      * Who to send the data to --- what about multiple (alternate) paths?
 249      */
 250     GNUNET_PEER_Id              first_hop;
 251
 252     /**
 253      * Max data rate to this peer
 254      */
 255     uint32_t                    max_speed;
 256 };
 257
 258
 259 typedef uint32_t MESH_PathID;
 260 /**
 261  * Information regarding a path
 262  */
 263 struct Path
 264 {
 265     /**
 266      * Id of the path, in case it's needed
 267      */
 268     MESH_PathID                 id;
 269
 270     /**
 271      * Whether the path is serving traffic in a tunnel or is a backup
 272      */
 273     int                         in_use;
 274
 275     /**
 276      * List of all the peers that form the path from origin to target
 277      */
 278     GNUNET_PEER_Id              *peers;
 279 };
 280
 281
 282 /**
 283  * Struct containing all information regarding a tunnel
 284  * For an intermediate node the improtant info used will be:
 285  * - OID        \ To identify
 286  * - TID        / the tunnel
 287  * - paths[0]   | To know where to send it next
 288  * - metainfo: ready, speeds, accounting
 289  * For an end node more fields will be needed (client-handling)
 290  */
 291 struct MESH_tunnel
 292 {
 293
 294     /**
 295      * Double linked list
 296      */
 297     struct MESH_tunnel          *next;
 298     struct MESH_tunnel          *prev;
 299
 300     /**
 301      * Origin ID: Node that created the tunnel
 302      */
 303     GNUNET_PEER_Id              oid;
 304
 305     /**
 306      * Tunnel number (unique for a given oid)
 307      */
 308     MESH_TunnelID               tid;
 309
 310     /**
 311      * Whether the tunnel is in a state to transmit data
 312      */
 313     int                         ready;
 314
 315     /**
 316      * Minimal speed for this tunnel in kb/s
 317      */
 318     uint32_t                    speed_min;
 319
 320     /**
 321      * Maximal speed for this tunnel in kb/s
 322      */
 323     uint32_t                    speed_max;
 324
 325     /**
 326      * Last time the tunnel was used
 327      */
 328     struct GNUNET_TIME_Absolute timestamp;
 329
 330     /**
 331      * Peers in the tunnel, for future optimizations
 332      */
 333     struct PeerInfo             *peers;
 334
 335     /**
 336      * Paths (used and backup)
 337      */
 338     struct Path                 *paths;
 339
 340     /**
 341      * Messages ready to transmit??? -- FIXME real queues needed
 342      */
 343     struct GNUNET_MessageHeader *msg_out;
 344
 345     /**
 346      * Messages received and not processed??? -- FIXME real queues needed
 347      */
 348     struct GNUNET_MessageHeader *msg_in;
 349
 350     /**
 351      * If this tunnel was created by a local client, what's its handle?
 352      */
 353     struct GNUNET_SERVER_Client *initiator;
 354 };
 355
 356 /**
 357  * So, I'm an endpoint. Why am I receiveing traffic?
 358  * Who is interested in this? How to communicate with them?
 359  */
 360 struct Client
 361 {
 362     /**
 363      * Double linked list
 364      */
 365     struct Client               *next;
 366     struct Client               *prev;
 367
 368     /**
 369      * Tunnels that belong to this client
 370      */
 371     struct MESH_tunnel          *my_tunnels_head;
 372     struct MESH_tunnel          *my_tunnels_tail;
 373
 374     /**
 375      * If this tunnel was created by a local client, what's its handle?
 376      */
 377     struct GNUNET_SERVER_Client *handle;
 378
 379     /**
 380      * Messages that this client has declared interest in
 381      */
 382     uint16_t                    *messages_subscribed;
 383     unsigned int                messages_subscribed_counter;
 384
 385 };
 386
 387 /******************************************************************************/
 388 /***********************      GLOBAL VARIABLES     ****************************/
 389 /******************************************************************************/
 390
 391 /**
 392  * All the clients
 393  */
 394 // static struct Client            clients_head;
 395 // static struct Client            clients_tail;
 396
 397 /**
 398  * All the tunnels
 399  */
 400 // static struct MESH_tunnel       *tunnel_participation_head;
 401 // static struct MESH_tunnel       *tunnel_participation_tail;
 402
 403
 404 /******************************************************************************/
 405 /********************      MESH NETWORK HANDLERS     **************************/
 406 /******************************************************************************/
 407
 408 /**
 409  * Core handler for path creation
 410  * struct GNUNET_CORE_MessageHandler
 411  *
 412  * @param cls closure
 413  * @param message message
 414  * @param peer peer identity this notification is about
 415  * @param atsi performance data
 416  * @return GNUNET_OK to keep the connection open,
 417  *         GNUNET_SYSERR to close it (signal serious error)
 418  *
 419  */
 420 static int
 421 handle_mesh_path_create (void *cls,
 422                               const struct GNUNET_PeerIdentity *peer,
 423                               const struct GNUNET_MessageHeader *message,
 424                               const struct GNUNET_TRANSPORT_ATS_Information
 425                               *atsi)
 426 {
 427   /*
 428    * EXAMPLE OF USING THE API
 429    * NOT ACTUAL CODE!!!!!
 430    */
 431   /*client *c;
 432   tunnel *t;
 433
 434   t = new;
 435   GNUNET_CONTAINER_DLL_insert (c->my_tunnels_head,
 436                                c->my_tunnels_tail,
 437                                t);
 438
 439   while (NULL != (t = c->my_tunnels_head))
 440     {
 441       GNUNET_CONTAINER_DLL_remove (c->my_tunnels_head,
 442                                    c->my_tunnels_tail,
 443                                    t);
 444       GNUNET_free (t);
 445     }
 446   */
 447
 448
 449     /* Extract path */
 450     /* Find origin & self */
 451     /* Search for origin in local tunnels */
 452     /* Create tunnel / add path */
 453     /* Retransmit to next link in chain, if any (core_notify + callback) */
 454     return GNUNET_OK;
 455 }
 456
 457 /**
 458  * Core handler for mesh network traffic
 459  *
 460  * @param cls closure
 461  * @param message message
 462  * @param peer peer identity this notification is about
 463  * @param atsi performance data
 464  * @return GNUNET_OK to keep the connection open,
 465  *         GNUNET_SYSERR to close it (signal serious error)
 466  */
 467 static int
 468 handle_mesh_network_traffic (void *cls,
 469                              const struct GNUNET_PeerIdentity *peer,
 470                              const struct GNUNET_MessageHeader *message,
 471                              const struct GNUNET_TRANSPORT_ATS_Information
 472                              *atsi)
 473 {
 474     if(GNUNET_MESSAGE_TYPE_MESH_DATA_GO == ntohs(message->type)) {
 475         /* Retransmit to next in path of tunnel identified by message */
 476         return GNUNET_OK;
 477     } else { /* GNUNET_MESSAGE_TYPE_MESH_DATA_BACK */
 478         /* Retransmit to previous in path of tunnel identified by message */
 479         return GNUNET_OK;
 480     }
 481 }
 482
 483 /**
 484  * Functions to handle messages from core
 485  */
 486 static struct GNUNET_CORE_MessageHandler core_handlers[] = {
 487   {&handle_mesh_path_create, GNUNET_MESSAGE_TYPE_MESH_PATH_CREATE, 0},
 488   {&handle_mesh_network_traffic, GNUNET_MESSAGE_TYPE_MESH_DATA_GO, 0},
 489   {&handle_mesh_network_traffic, GNUNET_MESSAGE_TYPE_MESH_DATA_BACK, 0},
 490   {NULL, 0, 0}
 491 };
 492
 493
 494
 495 /******************************************************************************/
 496 /*********************       MESH LOCAL HANDLES      **************************/
 497 /******************************************************************************/
 498
 499 /**
 500  * Handler for client disconnection
 501  *
 502  * @param cls closure
 503  * @param client identification of the client; NULL
 504  *        for the last call when the server is destroyed
 505  */
 506 static void
 507 handle_client_disconnect (void *cls, struct GNUNET_SERVER_Client *client)
 508 {
 509     /* Remove client from list, delete all timers and queues associated */
 510     return;
 511 }
 512
 513 /**
 514  * Handler for new clients
 515  *
 516  * @param cls closure
 517  * @param client identification of the client
 518  * @param message the actual message, which includes messages the client wants
 519  */
 520 static void
 521 handle_local_new_client (void *cls,
 522                          struct GNUNET_SERVER_Client *client,
 523                          const struct GNUNET_MessageHeader *message)
 524 {
 525     return;
 526 }
 527
 528 /**
 529  * Handler for connection requests
 530  *
 531  * @param cls closure
 532  * @param client identification of the client
 533  * @param message the actual message
 534  */
 535 static void
 536 handle_local_connect (void *cls,
 537                          struct GNUNET_SERVER_Client *client,
 538                          const struct GNUNET_MessageHeader *message)
 539 {
 540     return;
 541 }
 542
 543 /**
 544  * Handler for client traffic
 545  *
 546  * @param cls closure
 547  * @param client identification of the client
 548  * @param message the actual message
 549  */
 550 static void
 551 handle_local_network_traffic (void *cls,
 552                          struct GNUNET_SERVER_Client *client,
 553                          const struct GNUNET_MessageHeader *message)
 554 {
 555     return;
 556 }
 557
 558 /**
 559  * Functions to handle messages from clients
 560  */
 561 /* MESSAGES DEFINED:
 562 #define GNUNET_MESSAGE_TYPE_MESH_LOCAL_CONNECT              272
 563 #define GNUNET_MESSAGE_TYPE_MESH_LOCAL_CONNECT_PEER_ANY     273
 564 #define GNUNET_MESSAGE_TYPE_MESH_LOCAL_CONNECT_PEER_ALL     274
 565 #define GNUNET_MESSAGE_TYPE_MESH_LOCAL_CONNECT_PEER_ADD     275
 566 #define GNUNET_MESSAGE_TYPE_MESH_LOCAL_CONNECT_PEER_DEL     276
 567 #define GNUNET_MESSAGE_TYPE_MESH_LOCAL_CONNECT_PEER_BY_TYPE 277
 568 #define GNUNET_MESSAGE_TYPE_MESH_LOCAL_CONNECT_PEER_CANCEL  278
 569 #define GNUNET_MESSAGE_TYPE_MESH_LOCAL_TRANSMIT_READY       279
 570 #define GNUNET_MESSAGE_TYPE_MESH_LOCAL_TUNNEL_CREATED       280
 571 #define GNUNET_MESSAGE_TYPE_MESH_LOCAL_TUNNEL_DESTROYED     281
 572 #define GNUNET_MESSAGE_TYPE_MESH_LOCAL_DATA                 282
 573 #define GNUNET_MESSAGE_TYPE_MESH_LOCAL_DATA_BROADCAST       283
 574  */
 575 static struct GNUNET_SERVER_MessageHandler plugin_handlers[] = {
 576   {&handle_local_new_client, NULL, GNUNET_MESSAGE_TYPE_MESH_LOCAL_CONNECT, 0},
 577   {&handle_local_connect, NULL, GNUNET_MESSAGE_TYPE_MESH_LOCAL_CONNECT_PEER_ADD, 0},
 578   {&handle_local_connect, NULL, GNUNET_MESSAGE_TYPE_MESH_LOCAL_CONNECT_PEER_DEL, 0},
 579   {&handle_local_connect, NULL, GNUNET_MESSAGE_TYPE_MESH_LOCAL_CONNECT_PEER_BY_TYPE, sizeof(struct GNUNET_MESH_ConnectPeerByType)},
 580   {&handle_local_connect, NULL, GNUNET_MESSAGE_TYPE_MESH_LOCAL_CONNECT_PEER_CANCEL, 0},
 581   {&handle_local_network_traffic, NULL, GNUNET_MESSAGE_TYPE_MESH_LOCAL_TRANSMIT_READY, 0},
 582   {&handle_local_network_traffic, NULL, GNUNET_MESSAGE_TYPE_MESH_LOCAL_DATA, 0}, /* FIXME needed? */
 583   {&handle_local_network_traffic, NULL, GNUNET_MESSAGE_TYPE_MESH_LOCAL_DATA_BROADCAST, 0}, /* FIXME needed? */
 584   {NULL, NULL, 0, 0}
 585 };
 586
 587
 588 /**
 589  * To be called on core init/fail.
 590  *
 591  * @param cls service closure
 592  * @param server handle to the server for this service
 593  * @param identity the public identity of this peer
 594  * @param publicKey the public key of this peer
 595  */
 596 static void
 597 core_init (void *cls,
 598            struct GNUNET_CORE_Handle *server,
 599            const struct GNUNET_PeerIdentity *identity,
 600            const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *publicKey)
 601 {
 602     return;
 603 }
 604
 605 /**
 606  * Method called whenever a given peer connects.
 607  *
 608  * @param cls closure
 609  * @param peer peer identity this notification is about
 610  * @param atsi performance data for the connection
 611  */
 612 static void
 613 core_connect (void *cls,
 614               const struct GNUNET_PeerIdentity *peer,
 615               const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 616 {
 617     return;
 618 }
 619
 620 /**
 621  * Method called whenever a peer disconnects.
 622  *
 623  * @param cls closure
 624  * @param peer peer identity this notification is about
 625  */
 626 static void
 627 core_disconnect (void *cls,
 628                 const struct
 629                 GNUNET_PeerIdentity *peer)
 630 {
 631     return;
 632 }
 633
 634 /******************************************************************************/
 635 /************************      MAIN FUNCTIONS      ****************************/
 636 /******************************************************************************/
 637
 638 /**
 639  * Process mesh requests. FIXME NON FUNCTIONAL, SKELETON
 640  *
 641  * @param cls closure
 642  * @param server the initialized server
 643  * @param c configuration to use
 644  */
 645 static void
 646 run (void *cls,
 647      struct GNUNET_SERVER_Handle *server,
 648      const struct GNUNET_CONFIGURATION_Handle *c)
 649 {
 650   struct GNUNET_CORE_Handle *core;
 651
 652   GNUNET_SERVER_add_handlers (server, plugin_handlers);
 653   GNUNET_SERVER_disconnect_notify (server, &handle_client_disconnect, NULL);
 654   core = GNUNET_CORE_connect (c,                        /* Main configuration */
 655                             32,                                 /* queue size */
 656                             NULL,         /* Closure passed to MESH functions */
 657                             &core_init,      /* Call core_init once connected */
 658                             &core_connect,                 /* Handle connects */
 659                             &core_disconnect,  /* remove peers on disconnects */
 660                             NULL,       /* Do we care about "status" updates? */
 661                             NULL, /* Don't notify about all incoming messages */
 662                             GNUNET_NO,     /* For header only in notification */
 663                             NULL, /* Don't notify about all outbound messages */
 664                             GNUNET_NO,    /* For header-only out notification */
 665                             core_handlers);        /* Register these handlers */
 666
 667   if (core == NULL)
 668     return;
 669 }
 670
 671 /**
 672  * The main function for the mesh service.
 673  *
 674  * @param argc number of arguments from the command line
 675  * @param argv command line arguments
 676  * @return 0 ok, 1 on error
 677  */
 678 int
 679 main (int argc, char *const *argv)
 680 {
 681   int ret;
 682
 683   ret = (GNUNET_OK ==
 684          GNUNET_SERVICE_run (argc,
 685                              argv,
 686                              "mesh",
 687                              GNUNET_SERVICE_OPTION_NONE, &run, NULL)) ? 0 : 1;
 688   return ret;
 689 }