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