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 --- FIXME 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      * Double linked list
 267      */
 268     struct Path                 *next;
 269     struct Path                 *prev;
 270     /**
 271      * Id of the path, in case it's needed
 272      */
 273     MESH_PathID                 id;
 274
 275     /**
 276      * Whether the path is serving traffic in a tunnel or is a backup
 277      */
 278     int                         in_use;
 279
 280     /**
 281      * List of all the peers that form the path from origin to target
 282      */
 283     GNUNET_PEER_Id              *peers;
 284 };
 285
 286
 287 struct Client; /* FWD declaration */
 288 /**
 289  * Struct containing all information regarding a tunnel
 290  * For an intermediate node the improtant info used will be:
 291  * - OID        \ To identify
 292  * - TID        / the tunnel
 293  * - paths[0]   | To know where to send it next
 294  * - metainfo: ready, speeds, accounting
 295  * For an end node more fields will be needed (client-handling)
 296  */
 297 struct MESH_tunnel
 298 {
 299
 300     /**
 301      * Double linked list
 302      */
 303     struct MESH_tunnel          *next;
 304     struct MESH_tunnel          *prev;
 305
 306     /**
 307      * Origin ID: Node that created the tunnel
 308      */
 309     GNUNET_PEER_Id              oid;
 310
 311     /**
 312      * Tunnel number (unique for a given oid)
 313      */
 314     MESH_TunnelID               tid;
 315
 316     /**
 317      * Minimal speed for this tunnel in kb/s
 318      */
 319     uint32_t                    speed_min;
 320
 321     /**
 322      * Maximal speed for this tunnel in kb/s
 323      */
 324     uint32_t                    speed_max;
 325
 326     /**
 327      * Last time the tunnel was used
 328      */
 329     struct GNUNET_TIME_Absolute timestamp;
 330
 331     /**
 332      * Peers in the tunnel, for future optimizations
 333      */
 334     struct PeerInfo             *peers_head;
 335     struct PeerInfo             *peers_tail;
 336
 337     /**
 338      * Number of peers that are connected and potentially ready to receive data
 339      */
 340     unsigned int                peers_ready;
 341
 342     /**
 343      * Number of peers that have been added to the tunnel
 344      */
 345     unsigned int                peers_total;
 346
 347     /**
 348      * Paths (used and backup)
 349      */
 350     struct Path                 *paths_head;
 351     struct Path                 *paths_tail;
 352
 353     /**
 354      * If this tunnel was created by a local client, what's its handle?
 355      */
 356     struct Client               *client;
 357
 358     /**
 359      * Messages ready to transmit??? -- FIXME real queues needed
 360      */
 361     struct GNUNET_MessageHeader *msg_out;
 362
 363     /**
 364      * Messages received and not processed??? -- FIXME real queues needed
 365      */
 366     struct GNUNET_MessageHeader *msg_in;
 367
 368 };
 369
 370 /**
 371  * Struct containing information about a client of the service
 372  */
 373 struct Client
 374 {
 375     /**
 376      * Double linked list
 377      */
 378     struct Client               *next;
 379     struct Client               *prev;
 380
 381     /**
 382      * Tunnels that belong to this client, for convenience on disconnect
 383      */
 384     struct MESH_tunnel          *tunnels_head;
 385     struct MESH_tunnel          *tunnels_tail;
 386
 387     /**
 388      * Handle to communicate with the client
 389      */
 390     struct GNUNET_SERVER_Client *handle;
 391
 392     /**
 393      * Messages that this client has declared interest in
 394      */
 395     GNUNET_MESH_ApplicationType *messages_subscribed;
 396     unsigned int                subscription_counter;
 397
 398 };
 399
 400 /******************************************************************************/
 401 /***********************      GLOBAL VARIABLES     ****************************/
 402 /******************************************************************************/
 403
 404 /**
 405  * All the clients
 406  */
 407 static struct Client            clients_head;
 408 static struct Client            clients_tail;
 409
 410 /**
 411  * All the tunnels
 412  */
 413 // static struct MESH_tunnel       *tunnel_participation_head;
 414 // static struct MESH_tunnel       *tunnel_participation_tail;
 415
 416 /**
 417  * All the paths (for future path optimization)
 418  */
 419 // static struct Path             *paths_head;
 420 // static struct Path             *paths_tail;
 421
 422 /******************************************************************************/
 423 /********************      MESH NETWORK HANDLERS     **************************/
 424 /******************************************************************************/
 425
 426 /**
 427  * Core handler for path creation
 428  * struct GNUNET_CORE_MessageHandler
 429  *
 430  * @param cls closure
 431  * @param message message
 432  * @param peer peer identity this notification is about
 433  * @param atsi performance data
 434  * @return GNUNET_OK to keep the connection open,
 435  *         GNUNET_SYSERR to close it (signal serious error)
 436  *
 437  */
 438 static int
 439 handle_mesh_path_create (void *cls,
 440                               const struct GNUNET_PeerIdentity *peer,
 441                               const struct GNUNET_MessageHeader *message,
 442                               const struct GNUNET_TRANSPORT_ATS_Information
 443                               *atsi)
 444 {
 445   /*
 446    * EXAMPLE OF USING THE API
 447    * NOT ACTUAL CODE!!!!!
 448    */
 449   /*client *c;
 450   tunnel *t;
 451
 452   t = new;
 453   GNUNET_CONTAINER_DLL_insert (c->my_tunnels_head,
 454                                c->my_tunnels_tail,
 455                                t);
 456
 457   while (NULL != (t = c->my_tunnels_head))
 458     {
 459       GNUNET_CONTAINER_DLL_remove (c->my_tunnels_head,
 460                                    c->my_tunnels_tail,
 461                                    t);
 462       GNUNET_free (t);
 463     }
 464   */
 465
 466
 467     /* Extract path */
 468     /* Find origin & self */
 469     /* Search for origin in local tunnels */
 470     /* Create tunnel / add path */
 471     /* Retransmit to next link in chain, if any (core_notify + callback) */
 472     return GNUNET_OK;
 473 }
 474
 475 /**
 476  * Core handler for mesh network traffic
 477  *
 478  * @param cls closure
 479  * @param message message
 480  * @param peer peer identity this notification is about
 481  * @param atsi performance data
 482  * @return GNUNET_OK to keep the connection open,
 483  *         GNUNET_SYSERR to close it (signal serious error)
 484  */
 485 static int
 486 handle_mesh_network_traffic (void *cls,
 487                              const struct GNUNET_PeerIdentity *peer,
 488                              const struct GNUNET_MessageHeader *message,
 489                              const struct GNUNET_TRANSPORT_ATS_Information
 490                              *atsi)
 491 {
 492     if(GNUNET_MESSAGE_TYPE_MESH_DATA_GO == ntohs(message->type)) {
 493         /* Retransmit to next in path of tunnel identified by message */
 494         return GNUNET_OK;
 495     } else { /* GNUNET_MESSAGE_TYPE_MESH_DATA_BACK */
 496         /* Retransmit to previous in path of tunnel identified by message */
 497         return GNUNET_OK;
 498     }
 499 }
 500
 501 /**
 502  * Functions to handle messages from core
 503  */
 504 static struct GNUNET_CORE_MessageHandler core_handlers[] = {
 505   {&handle_mesh_path_create, GNUNET_MESSAGE_TYPE_MESH_PATH_CREATE, 0},
 506   {&handle_mesh_network_traffic, GNUNET_MESSAGE_TYPE_MESH_DATA_GO, 0},
 507   {&handle_mesh_network_traffic, GNUNET_MESSAGE_TYPE_MESH_DATA_BACK, 0},
 508   {NULL, 0, 0}
 509 };
 510
 511
 512
 513 /******************************************************************************/
 514 /*********************       MESH LOCAL HANDLES      **************************/
 515 /******************************************************************************/
 516
 517 /**
 518  * Handler for client disconnection
 519  *
 520  * @param cls closure
 521  * @param client identification of the client; NULL
 522  *        for the last call when the server is destroyed
 523  */
 524 static void
 525 handle_client_disconnect (void *cls, struct GNUNET_SERVER_Client *client)
 526 {
 527     /* Remove client from list, delete all timers and queues associated */
 528     return;
 529 }
 530
 531 /**
 532  * Handler for new clients
 533  *
 534  * @param cls closure
 535  * @param client identification of the client
 536  * @param message the actual message, which includes messages the client wants
 537  */
 538 static void
 539 handle_local_new_client (void *cls,
 540                          struct GNUNET_SERVER_Client *client,
 541                          const struct GNUNET_MessageHeader *message)
 542 {
 543     struct Client               *c;
 544     unsigned int                payload_size;
 545 //     struct GNUNET_MESH_Connect  *connect_msg;
 546 //
 547 //     connect_msg = (struct GNUNET_MESH_Connect *) message;
 548
 549     /* FIXME: check if already exists? NO (optimization) */
 550
 551     /* FIXME: is this way correct? NO */
 552     GNUNET_assert(0 == payload_size % sizeof(GNUNET_MESH_ApplicationType));
 553     /* GNUNET_break */
 554     /* notify done with syserr */
 555     /* return */
 556     /* Create new client structure */
 557
 558     c = GNUNET_malloc(sizeof(struct Client));
 559     c->handle = client;
 560     c->tunnels_head = NULL;
 561     c->tunnels_tail = NULL;
 562     payload_size = message->size - sizeof(GNUNET_MessageHeader);
 563
 564     c->messages_subscribed = GNUNET_malloc(payload_size);
 565     memcpy(c->messages_subscribed, &message[1], payload_size);
 566     c->subscription_counter = payload_size / sizeof(GNUNET_MESH_ApplicationType);
 567
 568     /* Insert new client in DLL */
 569     GNUNET_CONTAINER_DLL_insert (clients_head, clients_tail, c);
 570
 571     /* FIXME: notify done */
 572 }
 573
 574 /**
 575  * Handler for connection requests
 576  *
 577  * @param cls closure
 578  * @param client identification of the client
 579  * @param message the actual message
 580  */
 581 static void
 582 handle_local_connect (void *cls,
 583                          struct GNUNET_SERVER_Client *client,
 584                          const struct GNUNET_MessageHeader *message)
 585 {
 586     return;
 587 }
 588
 589 /**
 590  * Handler for client traffic
 591  *
 592  * @param cls closure
 593  * @param client identification of the client
 594  * @param message the actual message
 595  */
 596 static void
 597 handle_local_network_traffic (void *cls,
 598                          struct GNUNET_SERVER_Client *client,
 599                          const struct GNUNET_MessageHeader *message)
 600 {
 601     return;
 602 }
 603
 604 /**
 605  * Functions to handle messages from clients
 606  */
 607 static struct GNUNET_SERVER_MessageHandler plugin_handlers[] = {
 608   {&handle_local_new_client, NULL, GNUNET_MESSAGE_TYPE_MESH_LOCAL_CONNECT, 0},
 609   {&handle_local_connect, NULL,
 610    GNUNET_MESSAGE_TYPE_MESH_LOCAL_CONNECT_PEER_ADD, 0},
 611   {&handle_local_connect, NULL,
 612    GNUNET_MESSAGE_TYPE_MESH_LOCAL_CONNECT_PEER_DEL, 0},
 613   {&handle_local_connect, NULL,
 614    GNUNET_MESSAGE_TYPE_MESH_LOCAL_CONNECT_PEER_BY_TYPE,
 615    sizeof(struct GNUNET_MESH_ConnectPeerByType)},
 616   {&handle_local_connect, NULL,
 617    GNUNET_MESSAGE_TYPE_MESH_LOCAL_CONNECT_PEER_CANCEL, 0},
 618   {&handle_local_network_traffic, NULL,
 619    GNUNET_MESSAGE_TYPE_MESH_LOCAL_TRANSMIT_READY, 0},
 620   {&handle_local_network_traffic, NULL,
 621    GNUNET_MESSAGE_TYPE_MESH_LOCAL_DATA, 0}, /* FIXME needed? */
 622   {&handle_local_network_traffic, NULL,
 623    GNUNET_MESSAGE_TYPE_MESH_LOCAL_DATA_BROADCAST, 0}, /* FIXME needed? */
 624   {NULL, NULL, 0, 0}
 625 };
 626
 627
 628 /**
 629  * To be called on core init/fail.
 630  *
 631  * @param cls service closure
 632  * @param server handle to the server for this service
 633  * @param identity the public identity of this peer
 634  * @param publicKey the public key of this peer
 635  */
 636 static void
 637 core_init (void *cls,
 638            struct GNUNET_CORE_Handle *server,
 639            const struct GNUNET_PeerIdentity *identity,
 640            const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *publicKey)
 641 {
 642     return;
 643 }
 644
 645 /**
 646  * Method called whenever a given peer connects.
 647  *
 648  * @param cls closure
 649  * @param peer peer identity this notification is about
 650  * @param atsi performance data for the connection
 651  */
 652 static void
 653 core_connect (void *cls,
 654               const struct GNUNET_PeerIdentity *peer,
 655               const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 656 {
 657     return;
 658 }
 659
 660 /**
 661  * Method called whenever a peer disconnects.
 662  *
 663  * @param cls closure
 664  * @param peer peer identity this notification is about
 665  */
 666 static void
 667 core_disconnect (void *cls,
 668                 const struct
 669                 GNUNET_PeerIdentity *peer)
 670 {
 671     return;
 672 }
 673
 674 /******************************************************************************/
 675 /************************      MAIN FUNCTIONS      ****************************/
 676 /******************************************************************************/
 677
 678 /**
 679  * Process mesh requests. FIXME NON FUNCTIONAL, SKELETON
 680  *
 681  * @param cls closure
 682  * @param server the initialized server
 683  * @param c configuration to use
 684  */
 685 static void
 686 run (void *cls,
 687      struct GNUNET_SERVER_Handle *server,
 688      const struct GNUNET_CONFIGURATION_Handle *c)
 689 {
 690   struct GNUNET_CORE_Handle *core;
 691
 692   GNUNET_SERVER_add_handlers (server, plugin_handlers);
 693   GNUNET_SERVER_disconnect_notify (server, &handle_client_disconnect, NULL);
 694   core = GNUNET_CORE_connect (c,                        /* Main configuration */
 695                             32,                                 /* queue size */
 696                             NULL,         /* Closure passed to MESH functions */
 697                             &core_init,      /* Call core_init once connected */
 698                             &core_connect,                 /* Handle connects */
 699                             &core_disconnect,  /* remove peers on disconnects */
 700                             NULL,       /* Do we care about "status" updates? */
 701                             NULL, /* Don't notify about all incoming messages */
 702                             GNUNET_NO,     /* For header only in notification */
 703                             NULL, /* Don't notify about all outbound messages */
 704                             GNUNET_NO,    /* For header-only out notification */
 705                             core_handlers);        /* Register these handlers */
 706
 707   if (core == NULL)
 708     return;
 709 }
 710
 711 /**
 712  * The main function for the mesh service.
 713  *
 714  * @param argc number of arguments from the command line
 715  * @param argv command line arguments
 716  * @return 0 ok, 1 on error
 717  */
 718 int
 719 main (int argc, char *const *argv)
 720 {
 721     int ret;
 722
 723     ret = (GNUNET_OK ==
 724            GNUNET_SERVICE_run (argc,
 725                                argv,
 726                                "mesh",
 727                                GNUNET_SERVICE_OPTION_NONE,
 728                                &run, NULL)) ? 0 : 1;
 729     return ret;
 730     }