src/mesh/gnunet-service-mesh-enc.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2001-2013 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-enc.c
  23  * @brief GNUnet MESH service with encryption
  24  * @author Bartlomiej Polot
  25  *
  26  *  FIXME in progress:
  27  * - when sending in-order buffered data, wait for client ACKs
  28  * - add signatures
  29  * - add encryption
  30  * - set connection IDs independently from tunnel, tunnel has no ID
  31  *
  32  * TODO:
  33  * - relay corking down to core
  34  * - set ttl relative to path length
  35  * TODO END
  36  *
  37  * Dictionary:
  38  * - peer: other mesh instance. If there is direct connection it's a neighbor.
  39  * - tunnel: encrypted connection to a peer, neighbor or not.
  40  * - channel: connection between two clients, on the same or different peers.
  41  *            have properties like reliability.
  42  * - path: series of directly connected peer from one peer to another.
  43  * - connection: path which is being used in a tunnel.
  44  */
  45
  46 #include "platform.h"
  47 #include "gnunet_crypto_lib.h"
  48 #include "mesh_enc.h"
  49 #include "mesh_protocol_enc.h"
  50 #include "mesh_path.h"
  51 #include "block_mesh.h"
  52 #include "gnunet_dht_service.h"
  53 #include "gnunet_statistics_service.h"
  54
  55 #define MESH_BLOOM_SIZE         128
  56
  57 #define MESH_DEBUG_DHT          GNUNET_NO
  58 #define MESH_DEBUG_CONNECTION   GNUNET_YES
  59 #define MESH_DEBUG_TIMING       __LINUX__ && GNUNET_NO
  60
  61 #define MESH_MAX_POLL_TIME      GNUNET_TIME_relative_multiply (\
  62                                   GNUNET_TIME_UNIT_MINUTES,\
  63                                   10)
  64 #define MESH_RETRANSMIT_TIME    GNUNET_TIME_UNIT_SECONDS
  65 #define MESH_RETRANSMIT_MARGIN  4
  66
  67 #if MESH_DEBUG_CONNECTION
  68 #define DEBUG_CONN(...) GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
  69 #else
  70 #define DEBUG_CONN(...)
  71 #endif
  72
  73 #if MESH_DEBUG_DHT
  74 #define DEBUG_DHT(...) GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
  75 #else
  76 #define DEBUG_DHT(...)
  77 #endif
  78
  79 #if MESH_DEBUG_TIMING
  80 #include <time.h>
  81 double __sum;
  82 uint64_t __count;
  83 struct timespec __mesh_start;
  84 struct timespec __mesh_end;
  85 #define INTERVAL_START clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &(__mesh_start))
  86 #define INTERVAL_END \
  87 do {\
  88   clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &(__mesh_end));\
  89   double __diff = __mesh_end.tv_nsec - __mesh_start.tv_nsec;\
  90   if (__diff < 0) __diff += 1000000000;\
  91   __sum += __diff;\
  92   __count++;\
  93 } while (0)
  94 #define INTERVAL_SHOW \
  95 if (0 < __count)\
  96   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "AVG process time: %f ns\n", __sum/__count)
  97 #else
  98 #define INTERVAL_START
  99 #define INTERVAL_END
 100 #define INTERVAL_SHOW
 101 #endif
 102
 103 /**
 104  * All the states a tunnel can be in.
 105  */
 106 enum MeshTunnelState
 107 {
 108     /**
 109      * Uninitialized status, should never appear in operation.
 110      */
 111   MESH_TUNNEL_NEW,
 112
 113     /**
 114      * Path to the peer not known yet
 115      */
 116   MESH_TUNNEL_SEARCHING,
 117
 118     /**
 119      * Request sent, not yet answered.
 120      */
 121   MESH_TUNNEL_WAITING,
 122
 123     /**
 124      * Peer connected and ready to accept data
 125      */
 126   MESH_TUNNEL_READY,
 127
 128     /**
 129      * Peer connected previosly but not responding
 130      */
 131   MESH_TUNNEL_RECONNECTING
 132 };
 133
 134
 135 /**
 136  * All the states a connection can be in.
 137  */
 138 enum MeshConnectionState
 139 {
 140   /**
 141    * Uninitialized status, should never appear in operation.
 142    */
 143   MESH_CONNECTION_NEW,
 144
 145   /**
 146    * Connection create message sent, waiting for ACK.
 147    */
 148   MESH_CONNECTION_SENT,
 149
 150   /**
 151    * Connection ACK sent, waiting for ACK.
 152    */
 153   MESH_CONNECTION_ACK,
 154
 155   /**
 156    * Connection confirmed, ready to carry traffic.
 157    */
 158   MESH_CONNECTION_READY,
 159 };
 160
 161
 162 /**
 163  * All the states a connection can be in.
 164  */
 165 enum MeshChannelState
 166 {
 167   /**
 168    * Uninitialized status, should never appear in operation.
 169    */
 170   MESH_CHANNEL_NEW,
 171
 172   /**
 173    * Connection create message sent, waiting for ACK.
 174    */
 175   MESH_CHANNEL_SENT,
 176
 177   /**
 178    * Connection confirmed, ready to carry traffic..
 179    */
 180   MESH_CHANNEL_READY,
 181 };
 182
 183
 184 /******************************************************************************/
 185 /************************      DATA STRUCTURES     ****************************/
 186 /******************************************************************************/
 187
 188 /** FWD declaration */
 189 struct MeshClient;
 190 struct MeshPeer;
 191 struct MeshTunnel2;
 192 struct MeshConnection;
 193 struct MeshChannel;
 194 struct MeshChannelReliability;
 195
 196
 197 /**
 198  * Struct containing info about a queued transmission to this peer
 199  */
 200 struct MeshPeerQueue
 201 {
 202     /**
 203       * DLL next
 204       */
 205   struct MeshPeerQueue *next;
 206
 207     /**
 208       * DLL previous
 209       */
 210   struct MeshPeerQueue *prev;
 211
 212     /**
 213      * Peer this transmission is directed to.
 214      */
 215   struct MeshPeer *peer;
 216
 217     /**
 218      * Connection this message belongs to.
 219      */
 220   struct MeshConnection *c;
 221
 222     /**
 223      * Is FWD in c?
 224      */
 225   int fwd;
 226
 227     /**
 228      * Channel this message belongs to, if known.
 229      */
 230   struct MeshChannel *ch;
 231
 232     /**
 233      * Pointer to info stucture used as cls.
 234      */
 235   void *cls;
 236
 237     /**
 238      * Type of message
 239      */
 240   uint16_t type;
 241
 242     /**
 243      * Size of the message
 244      */
 245   size_t size;
 246 };
 247
 248
 249 /**
 250  * Struct to encapsulate all the Flow Control information to a peer to which
 251  * we are directly connected (on a core level).
 252  */
 253 struct MeshFlowControl
 254 {
 255   /**
 256    * Connection this controls.
 257    */
 258   struct MeshConnection *c;
 259
 260   /**
 261    * How many messages are in the queue on this connection.
 262    */
 263   unsigned int queue_n;
 264
 265   /**
 266    * How many messages do we accept in the queue.
 267    */
 268   unsigned int queue_max;
 269
 270   /**
 271    * Next ID to use.
 272    */
 273   uint32_t next_pid;
 274
 275   /**
 276    * ID of the last packet sent towards the peer.
 277    */
 278   uint32_t last_pid_sent;
 279
 280   /**
 281    * ID of the last packet received from the peer.
 282    */
 283   uint32_t last_pid_recv;
 284
 285   /**
 286    * Last ACK sent to the peer (peer can't send more than this PID).
 287    */
 288   uint32_t last_ack_sent;
 289
 290   /**
 291    * Last ACK sent towards the origin (for traffic towards leaf node).
 292    */
 293   uint32_t last_ack_recv;
 294
 295   /**
 296    * Task to poll the peer in case of a lost ACK causes stall.
 297    */
 298   GNUNET_SCHEDULER_TaskIdentifier poll_task;
 299
 300   /**
 301    * How frequently to poll for ACKs.
 302    */
 303   struct GNUNET_TIME_Relative poll_time;
 304 };
 305
 306
 307 /**
 308  * Struct containing all information regarding a given peer
 309  */
 310 struct MeshPeer
 311 {
 312     /**
 313      * ID of the peer
 314      */
 315   GNUNET_PEER_Id id;
 316
 317     /**
 318      * Last time we heard from this peer
 319      */
 320   struct GNUNET_TIME_Absolute last_contact;
 321
 322     /**
 323      * Paths to reach the peer, ordered by ascending hop count
 324      */
 325   struct MeshPeerPath *path_head;
 326
 327     /**
 328      * Paths to reach the peer, ordered by ascending hop count
 329      */
 330   struct MeshPeerPath *path_tail;
 331
 332     /**
 333      * Handle to stop the DHT search for paths to this peer
 334      */
 335   struct GNUNET_DHT_GetHandle *dhtget;
 336
 337     /**
 338      * Tunnel to this peer, if any.
 339      */
 340   struct MeshTunnel2 *tunnel;
 341
 342     /**
 343      * Connections that go through this peer, indexed by tid;
 344      */
 345   struct GNUNET_CONTAINER_MultiHashMap *connections;
 346
 347     /**
 348      * Handle for queued transmissions
 349      */
 350   struct GNUNET_CORE_TransmitHandle *core_transmit;
 351
 352   /**
 353    * Transmission queue to core DLL head
 354    */
 355   struct MeshPeerQueue *queue_head;
 356
 357   /**
 358    * Transmission queue to core DLL tail
 359    */
 360   struct MeshPeerQueue *queue_tail;
 361
 362   /**
 363    * How many messages are in the queue to this peer.
 364    */
 365   unsigned int queue_n;
 366 };
 367
 368
 369 /**
 370  * Info needed to retry a message in case it gets lost.
 371  */
 372 struct MeshReliableMessage
 373 {
 374     /**
 375      * Double linked list, FIFO style
 376      */
 377   struct MeshReliableMessage    *next;
 378   struct MeshReliableMessage    *prev;
 379
 380     /**
 381      * Type of message (payload, channel management).
 382      */
 383   int16_t type;
 384
 385     /**
 386      * Tunnel Reliability queue this message is in.
 387      */
 388   struct MeshChannelReliability  *rel;
 389
 390     /**
 391      * ID of the message (ACK needed to free)
 392      */
 393   uint32_t                      mid;
 394
 395     /**
 396      * When was this message issued (to calculate ACK delay)
 397      */
 398   struct GNUNET_TIME_Absolute   timestamp;
 399
 400   /* struct GNUNET_MESH_Data with payload */
 401 };
 402
 403
 404 /**
 405  * Info about the traffic state for a client in a channel.
 406  */
 407 struct MeshChannelReliability
 408 {
 409     /**
 410      * Channel this is about.
 411      */
 412   struct MeshChannel *ch;
 413
 414     /**
 415      * DLL of messages sent and not yet ACK'd.
 416      */
 417   struct MeshReliableMessage        *head_sent;
 418   struct MeshReliableMessage        *tail_sent;
 419
 420     /**
 421      * Messages pending to send.
 422      */
 423   unsigned int                      n_sent;
 424
 425     /**
 426      * DLL of messages received out of order.
 427      */
 428   struct MeshReliableMessage        *head_recv;
 429   struct MeshReliableMessage        *tail_recv;
 430
 431     /**
 432      * Messages received.
 433      */
 434   unsigned int                      n_recv;
 435
 436     /**
 437      * Next MID to use for outgoing traffic.
 438      */
 439   uint32_t                          mid_send;
 440
 441     /**
 442      * Next MID expected for incoming traffic.
 443      */
 444   uint32_t                          mid_recv;
 445
 446     /**
 447      * Can we send data to the client?
 448      */
 449   int                               client_ready;
 450
 451     /**
 452      * Task to resend/poll in case no ACK is received.
 453      */
 454   GNUNET_SCHEDULER_TaskIdentifier   retry_task;
 455
 456     /**
 457      * Counter for exponential backoff.
 458      */
 459   struct GNUNET_TIME_Relative       retry_timer;
 460
 461     /**
 462      * How long does it usually take to get an ACK.
 463      */
 464   struct GNUNET_TIME_Relative       expected_delay;
 465 };
 466
 467
 468 /**
 469  * Struct containing all information regarding a channel to a remote client.
 470  */
 471 struct MeshChannel
 472 {
 473     /**
 474      * Tunnel this channel is in.
 475      */
 476   struct MeshTunnel2 *t;
 477
 478     /**
 479      * Double linked list.
 480      */
 481   struct MeshChannel    *next;
 482   struct MeshChannel    *prev;
 483
 484     /**
 485      * Destination port of the channel.
 486      */
 487   uint32_t port;
 488
 489     /**
 490      * Global channel number ( < GNUNET_MESH_LOCAL_CHANNEL_ID_CLI)
 491      */
 492   MESH_ChannelNumber gid;
 493
 494     /**
 495      * Local tunnel number for root (owner) client.
 496      * ( >= GNUNET_MESH_LOCAL_CHANNEL_ID_CLI or 0 )
 497      */
 498   MESH_ChannelNumber lid_root;
 499
 500     /**
 501      * Local tunnel number for local destination clients (incoming number)
 502      * ( >= GNUNET_MESH_LOCAL_CHANNEL_ID_SERV or 0).
 503      */
 504   MESH_ChannelNumber lid_dest;
 505
 506     /**
 507      * Channel state.
 508      */
 509   enum MeshChannelState state;
 510
 511     /**
 512      * Is the tunnel bufferless (minimum latency)?
 513      */
 514   int nobuffer;
 515
 516     /**
 517      * Is the tunnel reliable?
 518      */
 519   int reliable;
 520
 521     /**
 522      * Last time the channel was used
 523      */
 524   struct GNUNET_TIME_Absolute timestamp;
 525
 526     /**
 527      * Client owner of the tunnel, if any
 528      */
 529   struct MeshClient *root;
 530
 531     /**
 532      * Client destination of the tunnel, if any.
 533      */
 534   struct MeshClient *dest;
 535
 536     /**
 537      * Flag to signal the destruction of the channel.
 538      * If this is set GNUNET_YES the channel will be destroyed
 539      * when the queue is empty.
 540      */
 541   int destroy;
 542
 543     /**
 544      * Total messages pending for this channel, payload or not.
 545      */
 546   unsigned int pending_messages;
 547
 548     /**
 549      * Reliability data.
 550      * Only present (non-NULL) at the owner of a tunnel.
 551      */
 552   struct MeshChannelReliability *root_rel;
 553
 554     /**
 555      * Reliability data.
 556      * Only present (non-NULL) at the destination of a tunnel.
 557      */
 558   struct MeshChannelReliability *dest_rel;
 559
 560 };
 561
 562
 563 /**
 564  * Struct containing all information regarding a connection to a peer.
 565  */
 566 struct MeshConnection
 567 {
 568   /**
 569    * DLL
 570    */
 571   struct MeshConnection *next;
 572   struct MeshConnection *prev;
 573
 574   /**
 575    * Tunnel this connection is part of.
 576    */
 577   struct MeshTunnel2 *t;
 578
 579   /**
 580    * Flow control information for traffic fwd.
 581    */
 582   struct MeshFlowControl fwd_fc;
 583
 584   /**
 585    * Flow control information for traffic bck.
 586    */
 587   struct MeshFlowControl bck_fc;
 588
 589   /**
 590    * ID of the connection.
 591    */
 592   struct GNUNET_HashCode id;
 593
 594   /**
 595    * State of the connection.
 596    */
 597   enum MeshConnectionState state;
 598
 599   /**
 600    * Path being used for the tunnel.
 601    */
 602   struct MeshPeerPath *path;
 603
 604   /**
 605    * Position of the local peer in the path.
 606    */
 607   unsigned int own_pos;
 608
 609   /**
 610    * Task to keep the used paths alive at the owner,
 611    * time tunnel out on all the other peers.
 612    */
 613   GNUNET_SCHEDULER_TaskIdentifier fwd_maintenance_task;
 614
 615   /**
 616    * Task to keep the used paths alive at the destination,
 617    * time tunnel out on all the other peers.
 618    */
 619   GNUNET_SCHEDULER_TaskIdentifier bck_maintenance_task;
 620
 621   /**
 622    * Pending message count.
 623    */
 624   int pending_messages;
 625
 626   /**
 627    * Destroy flag: if true, destroy on last message.
 628    */
 629   int destroy;
 630 };
 631
 632
 633 /**
 634  * Struct used to queue messages in a tunnel.
 635  */
 636 struct MeshTunnelQueue
 637 {
 638   /**
 639    * DLL
 640    */
 641   struct MeshTunnelQueue *next;
 642   struct MeshTunnelQueue *prev;
 643
 644   /**
 645    * Channel.
 646    */
 647   struct MeshChannel *ch;
 648
 649   /**
 650    * Message to send.
 651    */
 652   /* struct GNUNET_MessageHeader *msg; */
 653 };
 654
 655
 656 /**
 657  * Struct containing all information regarding a tunnel to a peer.
 658  */
 659 struct MeshTunnel2
 660 {
 661     /**
 662      * Endpoint of the tunnel.
 663      */
 664   struct MeshPeer *peer;
 665
 666     /**
 667      * State of the tunnel.
 668      */
 669   enum MeshTunnelState state;
 670
 671   /**
 672    * Local peer ephemeral private key
 673    */
 674   struct GNUNET_CRYPTO_EccPrivateKey *my_eph_key;
 675
 676   /**
 677    * Local peer ephemeral public key
 678    */
 679   struct GNUNET_CRYPTO_EccPublicKey *my_eph;
 680
 681   /**
 682    * Remote peer's public key.
 683    */
 684   struct GNUNET_CRYPTO_EccPublicKey *peers_eph;
 685
 686   /**
 687    * Encryption ("our") key.
 688    */
 689   struct GNUNET_CRYPTO_AesSessionKey e_key;
 690
 691   /**
 692    * Decryption ("their") key.
 693    */
 694   struct GNUNET_CRYPTO_AesSessionKey d_key;
 695
 696   /**
 697    * Paths that are actively used to reach the destination peer.
 698    */
 699   struct MeshConnection *connection_head;
 700   struct MeshConnection *connection_tail;
 701
 702   /**
 703    * Next connection number.
 704    */
 705   uint32_t next_cid;
 706
 707   /**
 708    * Channels inside this tunnel.
 709    */
 710   struct MeshChannel *channel_head;
 711   struct MeshChannel *channel_tail;
 712
 713   /**
 714    * Channel ID for the next created channel.
 715    */
 716   MESH_ChannelNumber next_chid;
 717
 718   /**
 719    * Channel ID for the next incoming channel.
 720    */
 721   MESH_ChannelNumber next_local_chid;
 722
 723   /**
 724    * Pending message count.
 725    */
 726   int pending_messages;
 727
 728   /**
 729    * Destroy flag: if true, destroy on last message.
 730    */
 731   int destroy;
 732
 733   /**
 734    * Queued messages, to transmit once tunnel gets connected.
 735    */
 736   struct MeshTunnelQueue *tq_head;
 737   struct MeshTunnelQueue *tq_tail;
 738 };
 739
 740
 741
 742 /**
 743  * Struct containing information about a client of the service
 744  *
 745  * TODO: add a list of 'waiting' ports
 746  */
 747 struct MeshClient
 748 {
 749     /**
 750      * Linked list next
 751      */
 752   struct MeshClient *next;
 753
 754     /**
 755      * Linked list prev
 756      */
 757   struct MeshClient *prev;
 758
 759     /**
 760      * Tunnels that belong to this client, indexed by local id
 761      */
 762   struct GNUNET_CONTAINER_MultiHashMap32 *own_channels;
 763
 764    /**
 765      * Tunnels this client has accepted, indexed by incoming local id
 766      */
 767   struct GNUNET_CONTAINER_MultiHashMap32 *incoming_channels;
 768
 769     /**
 770      * Handle to communicate with the client
 771      */
 772   struct GNUNET_SERVER_Client *handle;
 773
 774     /**
 775      * Ports that this client has declared interest in.
 776      * Indexed by port, contains *Client.
 777      */
 778   struct GNUNET_CONTAINER_MultiHashMap32 *ports;
 779
 780     /**
 781      * Whether the client is active or shutting down (don't send confirmations
 782      * to a client that is shutting down.
 783      */
 784   int shutting_down;
 785
 786     /**
 787      * ID of the client, mainly for debug messages
 788      */
 789   unsigned int id;
 790 };
 791
 792
 793 /******************************************************************************/
 794 /************************      DEBUG FUNCTIONS     ****************************/
 795 /******************************************************************************/
 796
 797 #if MESH_DEBUG
 798 /**
 799  * GNUNET_SCHEDULER_Task for printing a message after some operation is done
 800  * @param cls string to print
 801  * @param success  GNUNET_OK if the PUT was transmitted,
 802  *                GNUNET_NO on timeout,
 803  *                GNUNET_SYSERR on disconnect from service
 804  *                after the PUT message was transmitted
 805  *                (so we don't know if it was received or not)
 806  */
 807
 808 #if 0
 809 static void
 810 mesh_debug (void *cls, int success)
 811 {
 812   char *s = cls;
 813
 814   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "%s (%d)\n", s, success);
 815 }
 816 #endif
 817
 818 #endif
 819
 820 /******************************************************************************/
 821 /***********************      GLOBAL VARIABLES     ****************************/
 822 /******************************************************************************/
 823
 824 /************************** Configuration parameters **************************/
 825
 826 /**
 827  * How often to send path keepalives. Paths timeout after 4 missed.
 828  */
 829 static struct GNUNET_TIME_Relative refresh_connection_time;
 830
 831 /**
 832  * How often to PUT own ID in the DHT.
 833  */
 834 static struct GNUNET_TIME_Relative id_announce_time;
 835
 836 /**
 837  * Maximum time allowed to connect to a peer found by string.
 838  */
 839 static struct GNUNET_TIME_Relative connect_timeout;
 840
 841 /**
 842  * Default TTL for payload packets.
 843  */
 844 static unsigned long long default_ttl;
 845
 846 /**
 847  * DHT replication level, see DHT API: GNUNET_DHT_get_start, GNUNET_DHT_put.
 848  */
 849 static unsigned long long dht_replication_level;
 850
 851 /**
 852  * How many connections are we willing to maintain.
 853  * Local connections are always allowed, even if there are more connections than max.
 854  */
 855 static unsigned long long max_connections;
 856
 857 /**
 858  * How many messages *in total* are we willing to queue, divide by number of
 859  * connections to get connection queue size.
 860  */
 861 static unsigned long long max_msgs_queue;
 862
 863 /**
 864  * How many peers do we want to remember?
 865  */
 866 static unsigned long long max_peers;
 867
 868 /**
 869  * Percentage of messages that will be dropped (for test purposes only).
 870  */
 871 static unsigned long long drop_percent;
 872
 873 /*************************** Static global variables **************************/
 874
 875 /**
 876  * DLL with all the clients, head.
 877  */
 878 static struct MeshClient *clients_head;
 879
 880 /**
 881  * DLL with all the clients, tail.
 882  */
 883 static struct MeshClient *clients_tail;
 884
 885 /**
 886  * Connections known, indexed by cid (MeshConnection).
 887  */
 888 static struct GNUNET_CONTAINER_MultiHashMap *connections;
 889
 890 /**
 891  * Peers known, indexed by PeerIdentity (MeshPeer).
 892  */
 893 static struct GNUNET_CONTAINER_MultiHashMap *peers;
 894
 895 /**
 896  * Handle to communicate with core.
 897  */
 898 static struct GNUNET_CORE_Handle *core_handle;
 899
 900 /**
 901  * Handle to use DHT.
 902  */
 903 static struct GNUNET_DHT_Handle *dht_handle;
 904
 905 /**
 906  * Handle to server lib.
 907  */
 908 static struct GNUNET_SERVER_Handle *server_handle;
 909
 910 /**
 911  * Handle to the statistics service.
 912  */
 913 static struct GNUNET_STATISTICS_Handle *stats;
 914
 915 /**
 916  * Notification context, to send messages to local clients.
 917  */
 918 static struct GNUNET_SERVER_NotificationContext *nc;
 919
 920 /**
 921  * Local peer own ID (memory efficient handle).
 922  */
 923 static GNUNET_PEER_Id myid;
 924
 925 /**
 926  * Local peer own ID (full value).
 927  */
 928 static struct GNUNET_PeerIdentity my_full_id;
 929
 930 /**
 931  * Own private key.
 932  */
 933 static struct GNUNET_CRYPTO_EccPrivateKey *my_private_key;
 934
 935 /**
 936  * Own public key.
 937  */
 938 static struct GNUNET_CRYPTO_EccPublicKey my_public_key;
 939
 940 /**
 941  * All ports clients of this peer have opened.
 942  */
 943 static struct GNUNET_CONTAINER_MultiHashMap32 *ports;
 944
 945 /**
 946  * Task to periodically announce itself in the network.
 947  */
 948 GNUNET_SCHEDULER_TaskIdentifier announce_id_task;
 949
 950 /**
 951  * Next ID to assign to a client.
 952  */
 953 unsigned int next_client_id;
 954
 955
 956 /******************************************************************************/
 957 /***********************         DECLARATIONS        **************************/
 958 /******************************************************************************/
 959
 960 /**
 961  * Function to process paths received for a new peer addition. The recorded
 962  * paths form the initial tunnel, which can be optimized later.
 963  * Called on each result obtained for the DHT search.
 964  *
 965  * @param cls closure
 966  * @param exp when will this value expire
 967  * @param key key of the result
 968  * @param type type of the result
 969  * @param size number of bytes in data
 970  * @param data pointer to the result data
 971  */
 972 static void
 973 dht_get_id_handler (void *cls, struct GNUNET_TIME_Absolute exp,
 974                     const struct GNUNET_HashCode * key,
 975                     const struct GNUNET_PeerIdentity *get_path,
 976                     unsigned int get_path_length,
 977                     const struct GNUNET_PeerIdentity *put_path,
 978                     unsigned int put_path_length, enum GNUNET_BLOCK_Type type,
 979                     size_t size, const void *data);
 980
 981
 982 /**
 983  * Retrieve the MeshPeer stucture associated with the peer, create one
 984  * and insert it in the appropriate structures if the peer is not known yet.
 985  *
 986  * @param peer Full identity of the peer.
 987  *
 988  * @return Existing or newly created peer info.
 989  */
 990 static struct MeshPeer *
 991 peer_get (const struct GNUNET_PeerIdentity *peer);
 992
 993
 994 /**
 995  * Retrieve the MeshPeer stucture associated with the peer, create one
 996  * and insert it in the appropriate structures if the peer is not known yet.
 997  *
 998  * @param peer Short identity of the peer.
 999  *
1000  * @return Existing or newly created peer info.
1001  */
1002 static struct MeshPeer *
1003 peer_get_short (const GNUNET_PEER_Id peer);
1004
1005
1006 /**
1007  * Build a PeerPath from the paths returned from the DHT, reversing the paths
1008  * to obtain a local peer -> destination path and interning the peer ids.
1009  *
1010  * @return Newly allocated and created path
1011  */
1012 static struct MeshPeerPath *
1013 path_build_from_dht (const struct GNUNET_PeerIdentity *get_path,
1014                      unsigned int get_path_length,
1015                      const struct GNUNET_PeerIdentity *put_path,
1016                      unsigned int put_path_length);
1017
1018
1019 /**
1020  * Adds a path to the data structs of all the peers in the path
1021  *
1022  * @param p Path to process.
1023  * @param confirmed Whether we know if the path works or not.
1024  */
1025 static void
1026 path_add_to_peers (struct MeshPeerPath *p, int confirmed);
1027
1028
1029 /**
1030  * Search for a tunnel by global ID using full PeerIdentities.
1031  *
1032  * @param t Tunnel containing the channel.
1033  * @param chid Public channel number.
1034  *
1035  * @return channel handler, NULL if doesn't exist
1036  */
1037 static struct MeshChannel *
1038 channel_get (struct MeshTunnel2 *t, MESH_ChannelNumber chid);
1039
1040 /**
1041  * Modify the data message ID from global to local and send to client.
1042  *
1043  * @param ch Channel on which to send the message.
1044  * @param msg Message to modify and send.
1045  * @param fwd Forward?
1046  */
1047 static void
1048 channel_send_client_data (struct MeshChannel *ch,
1049                           const struct GNUNET_MESH_Data *msg,
1050                           int fwd);
1051
1052
1053 /**
1054  * Change the tunnel state.
1055  *
1056  * @param t Tunnel whose state to change.
1057  * @param state New state.
1058  */
1059 static void
1060 tunnel_change_state (struct MeshTunnel2 *t, enum MeshTunnelState state);
1061
1062
1063 /**
1064  * Notify a tunnel that a connection has broken that affects at least
1065  * some of its peers.
1066  *
1067  * @param t Tunnel affected.
1068  * @param p1 Peer that got disconnected from p2.
1069  * @param p2 Peer that got disconnected from p1.
1070  *
1071  * @return Short ID of the peer disconnected (either p1 or p2).
1072  *         0 if the tunnel remained unaffected.
1073  */
1074 static GNUNET_PEER_Id
1075 tunnel_notify_connection_broken (struct MeshTunnel2 *t,
1076                                  GNUNET_PEER_Id p1, GNUNET_PEER_Id p2);
1077
1078 /**
1079  * @brief Use the given path for the tunnel.
1080  * Update the next and prev hops (and RCs).
1081  * (Re)start the path refresh in case the tunnel is locally owned.
1082  *
1083  * @param t Tunnel to update.
1084  * @param p Path to use.
1085  *
1086  * @return Connection created.
1087  */
1088 static struct MeshConnection *
1089 tunnel_use_path (struct MeshTunnel2 *t, struct MeshPeerPath *p);
1090
1091 /**
1092  * Tunnel is empty: destroy it.
1093  *
1094  * Notifies all participants (peers, cleints) about the destruction.
1095  *
1096  * @param t Tunnel to destroy.
1097  */
1098 static void
1099 tunnel_destroy_empty (struct MeshTunnel2 *t);
1100
1101 /**
1102  * Destroy the tunnel.
1103  *
1104  * This function does not generate any warning traffic to clients or peers.
1105  *
1106  * Tasks:
1107  * Cancel messages belonging to this tunnel queued to neighbors.
1108  * Free any allocated resources linked to the tunnel.
1109  *
1110  * @param t The tunnel to destroy.
1111  */
1112 static void
1113 tunnel_destroy (struct MeshTunnel2 *t);
1114
1115 /**
1116  * Create a connection.
1117  *
1118  * @param cid Connection ID.
1119  */
1120 static struct MeshConnection *
1121 connection_new (const struct GNUNET_HashCode *cid);
1122
1123 /**
1124  * Connection is no longer needed: destroy it and remove from tunnel.
1125  *
1126  * @param c Connection to destroy.
1127  */
1128 static void
1129 connection_destroy (struct MeshConnection *c);
1130
1131 /**
1132  * Send FWD keepalive packets for a connection.
1133  *
1134  * @param cls Closure (connection for which to send the keepalive).
1135  * @param tc Notification context.
1136  */
1137 static void
1138 connection_fwd_keepalive (void *cls,
1139                           const struct GNUNET_SCHEDULER_TaskContext *tc);
1140
1141 /**
1142  * Send BCK keepalive packets for a connection.
1143  *
1144  * @param cls Closure (connection for which to send the keepalive).
1145  * @param tc Notification context.
1146  */
1147 static void
1148 connection_bck_keepalive (void *cls,
1149                           const struct GNUNET_SCHEDULER_TaskContext *tc);
1150
1151
1152 /**
1153  * Change the tunnel state.
1154  *
1155  * @param c Connection whose state to change.
1156  * @param state New state.
1157  */
1158 static void
1159 connection_change_state (struct MeshConnection* c,
1160                          enum MeshConnectionState state);
1161
1162
1163
1164 /**
1165  * @brief Queue and pass message to core when possible.
1166  *
1167  * @param cls Closure (@c type dependant). It will be used by queue_send to
1168  *            build the message to be sent if not already prebuilt.
1169  * @param type Type of the message, 0 for a raw message.
1170  * @param size Size of the message.
1171  * @param c Connection this message belongs to (cannot be NULL).
1172  * @param ch Channel this message belongs to, if applicable (otherwise NULL).
1173  * @param fwd Is this a message going root->dest? (FWD ACK are NOT FWD!)
1174  */
1175 static void
1176 queue_add (void* cls,
1177            uint16_t type,
1178            size_t size,
1179            struct MeshConnection* c,
1180            struct MeshChannel* ch,
1181            int fwd);
1182
1183
1184 /**
1185  * Free a transmission that was already queued with all resources
1186  * associated to the request.
1187  *
1188  * @param queue Queue handler to cancel.
1189  * @param clear_cls Is it necessary to free associated cls?
1190  */
1191 static void
1192 queue_destroy (struct MeshPeerQueue *queue, int clear_cls);
1193
1194
1195 /**
1196  * Core callback to write a queued packet to core buffer
1197  *
1198  * @param cls Closure (peer info).
1199  * @param size Number of bytes available in buf.
1200  * @param buf Where the to write the message.
1201  *
1202  * @return number of bytes written to buf
1203  */
1204 static size_t
1205 queue_send (void *cls, size_t size, void *buf);
1206
1207
1208 /**
1209  * Demultiplex by message type and call appropriate handler for a message
1210  * towards a channel of a local tunnel.
1211  *
1212  * @param t Tunnel this message came on.
1213  * @param msgh Message header.
1214  * @param fwd Is this message fwd?
1215  */
1216 static void
1217 handle_decrypted (struct MeshTunnel2 *t,
1218                   const struct GNUNET_MessageHeader *msgh,
1219                   int fwd);
1220
1221
1222 /**
1223  * Dummy function to separate declarations from definitions in function list.
1224  */
1225 void
1226 __mesh_divider______________________________________________________________();
1227
1228
1229 /**
1230  * Get string description for tunnel state.
1231  *
1232  * @param s Tunnel state.
1233  *
1234  * @return String representation.
1235  */
1236 static const char *
1237 GNUNET_MESH_DEBUG_TS2S (enum MeshTunnelState s)
1238 {
1239   static char buf[128];
1240
1241   switch (s)
1242   {
1243     case MESH_TUNNEL_NEW:
1244       return "MESH_TUNNEL_NEW";
1245     case MESH_TUNNEL_SEARCHING:
1246       return "MESH_TUNNEL_SEARCHING";
1247     case MESH_TUNNEL_WAITING:
1248       return "MESH_TUNNEL_WAITING";
1249     case MESH_TUNNEL_READY:
1250       return "MESH_TUNNEL_READY";
1251     case MESH_TUNNEL_RECONNECTING:
1252       return "MESH_TUNNEL_RECONNECTING";
1253
1254     default:
1255       sprintf (buf, "%u (UNKNOWN STATE)", s);
1256       return buf;
1257   }
1258 }
1259
1260
1261 /**
1262  * Get string description for tunnel state.
1263  *
1264  * @param s Tunnel state.
1265  *
1266  * @return String representation.
1267  */
1268 static const char *
1269 GNUNET_MESH_DEBUG_CS2S (enum MeshTunnelState s)
1270 {
1271   switch (s)
1272   {
1273     case MESH_CONNECTION_NEW:
1274       return "MESH_CONNECTION_NEW";
1275     case MESH_CONNECTION_SENT:
1276       return "MESH_CONNECTION_SENT";
1277     case MESH_CONNECTION_READY:
1278       return "MESH_CONNECTION_READY";
1279     default:
1280       return "MESH_CONNECTION_STATE_ERROR";
1281   }
1282 }
1283
1284
1285
1286 /******************************************************************************/
1287 /************************    PERIODIC FUNCTIONS    ****************************/
1288 /******************************************************************************/
1289
1290 /**
1291  * Periodically announce self id in the DHT
1292  *
1293  * @param cls closure
1294  * @param tc task context
1295  */
1296 static void
1297 announce_id (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1298 {
1299   struct PBlock block;
1300
1301   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
1302   {
1303     announce_id_task = GNUNET_SCHEDULER_NO_TASK;
1304     return;
1305   }
1306   /* TODO
1307    * - Set data expiration in function of X
1308    * - Adapt X to churn
1309    */
1310   DEBUG_DHT ("DHT_put for ID %s started.\n", GNUNET_i2s (&my_full_id));
1311
1312   block.id = my_full_id;
1313   GNUNET_DHT_put (dht_handle,   /* DHT handle */
1314                   &my_full_id.hashPubKey,       /* Key to use */
1315                   dht_replication_level,     /* Replication level */
1316                   GNUNET_DHT_RO_RECORD_ROUTE | GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,    /* DHT options */
1317                   GNUNET_BLOCK_TYPE_MESH_PEER,       /* Block type */
1318                   sizeof (block),  /* Size of the data */
1319                   (const char *) &block, /* Data itself */
1320                   GNUNET_TIME_UNIT_FOREVER_ABS,  /* Data expiration */
1321                   GNUNET_TIME_UNIT_FOREVER_REL, /* Retry time */
1322                   NULL,         /* Continuation */
1323                   NULL);        /* Continuation closure */
1324   announce_id_task =
1325       GNUNET_SCHEDULER_add_delayed (id_announce_time, &announce_id, cls);
1326 }
1327
1328
1329 /******************************************************************************/
1330 /******************      GENERAL HELPER FUNCTIONS      ************************/
1331 /******************************************************************************/
1332
1333
1334 /**
1335  * Get the static string for a peer ID.
1336  *
1337  * @param peer Peer.
1338  *
1339  * @return Static string for it's ID.
1340  */
1341 static const char *
1342 peer2s (const struct MeshPeer *peer)
1343 {
1344   if (NULL == peer)
1345     return "(NULL)";
1346   return GNUNET_i2s (GNUNET_PEER_resolve2 (peer->id));
1347 }
1348
1349
1350 /**
1351  * Get the previous hop in a connection
1352  *
1353  * @param c Connection.
1354  *
1355  * @return Previous peer in the connection.
1356  */
1357 static struct MeshPeer *
1358 connection_get_prev_hop (struct MeshConnection *c)
1359 {
1360   GNUNET_PEER_Id id;
1361
1362   if (0 == c->own_pos || c->path->length < 2)
1363     id = c->path->peers[0];
1364   else
1365     id = c->path->peers[c->own_pos - 1];
1366
1367   return peer_get_short (id);
1368 }
1369
1370
1371 /**
1372  * Get the next hop in a connection
1373  *
1374  * @param c Connection.
1375  *
1376  * @return Next peer in the connection.
1377  */
1378 static struct MeshPeer *
1379 connection_get_next_hop (struct MeshConnection *c)
1380 {
1381   GNUNET_PEER_Id id;
1382
1383   if ((c->path->length - 1) == c->own_pos || c->path->length < 2)
1384     id = c->path->peers[c->path->length - 1];
1385   else
1386     id = c->path->peers[c->own_pos + 1];
1387
1388   return peer_get_short (id);
1389 }
1390
1391
1392 /**
1393  * Get the hop in a connection.
1394  *
1395  * @param c Connection.
1396  * @param fwd Next hop?
1397  *
1398  * @return Next peer in the connection.
1399  */
1400 static struct MeshPeer *
1401 connection_get_hop (struct MeshConnection *c, int fwd)
1402 {
1403   if (fwd)
1404     return connection_get_next_hop (c);
1405   return connection_get_prev_hop (c);
1406 }
1407
1408 /**
1409  * Check if client has registered with the service and has not disconnected
1410  *
1411  * @param client the client to check
1412  *
1413  * @return non-NULL if client exists in the global DLL
1414  */
1415 static struct MeshClient *
1416 client_get (struct GNUNET_SERVER_Client *client)
1417 {
1418   return GNUNET_SERVER_client_get_user_context (client, struct MeshClient);
1419 }
1420
1421
1422 /**
1423  * Deletes a tunnel from a client (either owner or destination).
1424  *
1425  * @param c Client whose tunnel to delete.
1426  * @param ch Channel which should be deleted.
1427  */
1428 static void
1429 client_delete_channel (struct MeshClient *c, struct MeshChannel *ch)
1430 {
1431   int res;
1432
1433   if (c == ch->root)
1434   {
1435     res = GNUNET_CONTAINER_multihashmap32_remove (c->own_channels,
1436                                                   ch->lid_root, ch);
1437     if (GNUNET_YES != res)
1438       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "client_delete_channel owner KO\n");
1439   }
1440   if (c == ch->dest)
1441   {
1442     res = GNUNET_CONTAINER_multihashmap32_remove (c->incoming_channels,
1443                                                   ch->lid_dest, ch);
1444     if (GNUNET_YES != res)
1445       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "client_delete_tunnel client KO\n");
1446   }
1447 }
1448
1449
1450 /**
1451  * Notify the appropriate client that a new incoming channel was created.
1452  *
1453  * @param ch Channel that was created.
1454  */
1455 static void
1456 send_local_channel_create (struct MeshChannel *ch)
1457 {
1458   struct GNUNET_MESH_ChannelMessage msg;
1459   struct MeshTunnel2 *t = ch->t;
1460
1461   if (NULL == ch->dest)
1462     return;
1463   msg.header.size = htons (sizeof (msg));
1464   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_TUNNEL_CREATE);
1465   msg.channel_id = htonl (ch->lid_dest);
1466   msg.port = htonl (ch->port);
1467   msg.opt = 0;
1468   msg.opt |= GNUNET_YES == ch->reliable ? GNUNET_MESH_OPTION_RELIABLE : 0;
1469   msg.opt |= GNUNET_YES == ch->nobuffer ? GNUNET_MESH_OPTION_NOBUFFER : 0;
1470   msg.opt = htonl (msg.opt);
1471   GNUNET_PEER_resolve (t->peer->id, &msg.peer);
1472   GNUNET_SERVER_notification_context_unicast (nc, ch->dest->handle,
1473                                               &msg.header, GNUNET_NO);
1474 }
1475
1476
1477 /**
1478  * Notify a client that the incoming tunnel is no longer valid.
1479  *
1480  * @param ch Channel that is destroyed.
1481  * @param fwd Forward notification (owner->dest)?
1482  */
1483 static void
1484 send_local_channel_destroy (struct MeshChannel *ch, int fwd)
1485 {
1486   struct GNUNET_MESH_ChannelMessage msg;
1487   struct MeshClient *c;
1488
1489   c = fwd ? ch->dest : ch->root;
1490   if (NULL == c)
1491   {
1492     GNUNET_break (0);
1493     return;
1494   }
1495   msg.header.size = htons (sizeof (msg));
1496   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_TUNNEL_DESTROY);
1497   msg.channel_id = htonl (fwd ? ch->lid_dest : ch->lid_root);
1498   msg.port = htonl (0);
1499   memset (&msg.peer, 0, sizeof (msg.peer));
1500   msg.opt = htonl (0);
1501   GNUNET_SERVER_notification_context_unicast (nc, c->handle,
1502                                               &msg.header, GNUNET_NO);
1503 }
1504
1505
1506 /**
1507  * Build a local ACK message and send it to a local client, if needed.
1508  *
1509  * If the client was already allowed to send data, do nothing.
1510  *
1511  * @param ch Channel on which to send the ACK.
1512  * @param c Client to whom send the ACK.
1513  * @param fwd Set to GNUNET_YES for FWD ACK (dest->root)
1514  */
1515 static void
1516 send_local_ack (struct MeshChannel *ch, int fwd)
1517 {
1518   struct GNUNET_MESH_LocalAck msg;
1519   struct MeshChannelReliability *rel;
1520   struct MeshClient *c;
1521
1522   c   = fwd ? ch->root     : ch->dest;
1523   rel = fwd ? ch->root_rel : ch->dest_rel;
1524
1525   if (GNUNET_YES == rel->client_ready)
1526     return; /* don't send double ACKs to client */
1527
1528   rel->client_ready = GNUNET_YES;
1529
1530   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1531               "send local %s ack on %s:%X towards %p\n",
1532               fwd ? "FWD" : "BCK", peer2s (ch->t->peer), ch->gid, c);
1533
1534   if (NULL == c
1535       || ( fwd && (0 == ch->lid_root || c != ch->root))
1536       || (!fwd && (0 == ch->lid_dest || c != ch->dest)) )
1537   {
1538     GNUNET_break (0);
1539     return;
1540   }
1541   msg.header.size = htons (sizeof (msg));
1542   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_ACK);
1543   msg.channel_id = htonl (fwd ? ch->lid_root : ch->lid_dest);
1544   GNUNET_SERVER_notification_context_unicast (nc,
1545                                               c->handle,
1546                                               &msg.header,
1547                                               GNUNET_NO);
1548
1549 }
1550
1551
1552 /**
1553  * Count established (ready) connections of a tunnel.
1554  *
1555  * @param t Tunnel on which to send the message.
1556  *
1557  * @return Number of connections.
1558  */
1559 static unsigned int
1560 tunnel_count_connections (struct MeshTunnel2 *t)
1561 {
1562   struct MeshConnection *c;
1563   unsigned int i;
1564
1565   for (c = t->connection_head, i = 0; NULL != c; c = c->next, i++);
1566
1567   return i;
1568 }
1569
1570
1571 /**
1572  * Pick a connection on which send the next data message.
1573  *
1574  * @param t Tunnel on which to send the message.
1575  * @param fwd Is this a fwd message?
1576  *
1577  * @return The connection on which to send the next message.
1578  */
1579 static struct MeshConnection *
1580 tunnel_get_connection (struct MeshTunnel2 *t, int fwd)
1581 {
1582   struct MeshConnection *c;
1583   struct MeshConnection *best;
1584   struct MeshFlowControl *fc;
1585   unsigned int lowest_q;
1586
1587   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "tunnel_get_connection %s\n",
1588               peer2s (t->peer));
1589   best = NULL;
1590   lowest_q = UINT_MAX;
1591   for (c = t->connection_head; NULL != c; c = c->next)
1592   {
1593     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  connection %s, \n",
1594                 GNUNET_h2s (&c->id));
1595     if (MESH_CONNECTION_READY == c->state)
1596     {
1597       fc = fwd ? &c->fwd_fc : &c->bck_fc;
1598       if (NULL == fc)
1599       {
1600         GNUNET_break (0);
1601         continue;
1602       }
1603       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "    q_n %u, \n", fc->queue_n);
1604       if (fc->queue_n < lowest_q)
1605       {
1606         best = c;
1607         lowest_q = fc->queue_n;
1608       }
1609     }
1610   }
1611   return best;
1612 }
1613
1614
1615 /**
1616  * Is this peer the first one on the connection?
1617  *
1618  * @param c Connection.
1619  * @param fwd Is this about fwd traffic?
1620  *
1621  * @return GNUNET_YES if origin, GNUNET_NO if relay/terminal.
1622  */
1623 static int
1624 connection_is_origin (struct MeshConnection *c, int fwd)
1625 {
1626   if (!fwd && c->own_pos == c->path->length - 1)
1627     return GNUNET_YES;
1628   if (fwd && c->own_pos == 0)
1629     return GNUNET_YES;
1630   return GNUNET_NO;
1631 }
1632
1633
1634 /**
1635  * Is this peer the last one on the connection?
1636  *
1637  * @param c Connection.
1638  * @param fwd Is this about fwd traffic?
1639  *            Note that the ROOT is the terminal for BCK traffic!
1640  *
1641  * @return GNUNET_YES if terminal, GNUNET_NO if relay/origin.
1642  */
1643 static int
1644 connection_is_terminal (struct MeshConnection *c, int fwd)
1645 {
1646   if (fwd && c->own_pos == c->path->length - 1)
1647     return GNUNET_YES;
1648   if (!fwd && c->own_pos == 0)
1649     return GNUNET_YES;
1650   return GNUNET_NO;
1651 }
1652
1653
1654 /**
1655  * Is the recipient client for this channel on this peer?
1656  *
1657  * @param ch Channel.
1658  * @param fwd Is this for fwd traffic?
1659  *
1660  * @return GNUNET_YES in case it is.
1661  */
1662 static int
1663 channel_is_terminal (struct MeshChannel *ch, int fwd)
1664 {
1665   if (NULL == ch->t || NULL == ch->t->connection_head)
1666   {
1667     GNUNET_break (0);
1668     return GNUNET_NO;
1669   }
1670   return connection_is_terminal (ch->t->connection_head, fwd);
1671 }
1672
1673
1674 /**
1675  * Get free buffer space towards the client on a specific channel.
1676  *
1677  * @param ch Channel.
1678  * @param fwd Is query about FWD traffic?
1679  *
1680  * @return Free buffer space [0 - 64]
1681  */
1682 static unsigned int
1683 channel_get_buffer (struct MeshChannel *ch, int fwd)
1684 {
1685   struct MeshChannelReliability *rel;
1686
1687   rel = fwd ? ch->dest_rel : ch->root_rel;
1688
1689   /* If rel is NULL it means that the end is not yet created,
1690    * most probably is a loopback channel at the point of sending
1691    * the ChannelCreate to itself.
1692    */
1693   if (NULL == rel)
1694     return 64;
1695
1696   return (64 - rel->n_recv);
1697 }
1698
1699
1700 /**
1701  * Get free buffer space in a connection.
1702  *
1703  * @param c Connection.
1704  * @param fwd Is query about FWD traffic?
1705  *
1706  * @return Free buffer space [0 - max_msgs_queue/max_connections]
1707  */
1708 static unsigned int
1709 connection_get_buffer (struct MeshConnection *c, int fwd)
1710 {
1711   struct MeshFlowControl *fc;
1712
1713   fc = fwd ? &c->fwd_fc : &c->bck_fc;
1714
1715   return (fc->queue_max - fc->queue_n);
1716 }
1717
1718
1719 /**
1720  * Get the total buffer space for a tunnel.
1721  */
1722 static unsigned int
1723 tunnel_get_buffer (struct MeshTunnel2 *t, int fwd)
1724 {
1725   struct MeshConnection *c;
1726   struct MeshFlowControl *fc;
1727   unsigned int buffer;
1728
1729   c = t->connection_head;
1730   buffer = 0;
1731
1732   if (NULL == c)
1733   {
1734     GNUNET_break (0);
1735     return 0;
1736   }
1737
1738   /* If terminal, return biggest channel buffer */
1739   if (connection_is_terminal (c, fwd))
1740   {
1741     struct MeshChannel *ch;
1742     unsigned int ch_buf;
1743
1744     if (NULL == t->channel_head)
1745       return 64;
1746
1747     for (ch = t->channel_head; NULL != ch; ch = ch->next)
1748     {
1749       ch_buf = channel_get_buffer (ch, fwd);
1750       if (ch_buf > buffer)
1751         buffer = ch_buf;
1752     }
1753     return buffer;
1754   }
1755
1756   /* If not terminal, return sum of connection buffers */
1757   while (NULL != c)
1758   {
1759     if (c->state != MESH_CONNECTION_READY)
1760       continue;
1761
1762     fc = fwd ? &c->fwd_fc : &c->bck_fc;
1763     buffer += fc->last_ack_recv - fc->last_pid_sent;
1764     c = c->next;
1765   }
1766
1767   return buffer;
1768 }
1769
1770
1771 /**
1772  * FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME
1773  * Encrypt data with the tunnel key.
1774  *
1775  * @param t Tunnel whose key to use.
1776  * @param dst Destination for the encrypted data.
1777  * @param src Source of the plaintext.
1778  * @param size Size of the plaintext.
1779  * @param iv Initialization Vector to use.
1780  * @param fwd Is this a fwd message?
1781  */
1782 static void
1783 tunnel_encrypt (struct MeshTunnel2 *t,
1784                 void *dst, const void *src,
1785                 size_t size, uint64_t iv, int fwd)
1786 {
1787   memcpy (dst, src, size);
1788 }
1789
1790
1791 /**
1792  * FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME
1793  * Decrypt data with the tunnel key.
1794  *
1795  * @param t Tunnel whose key to use.
1796  * @param dst Destination for the plaintext.
1797  * @param src Source of the encrypted data.
1798  * @param size Size of the encrypted data.
1799  * @param iv Initialization Vector to use.
1800  * @param fwd Is this a fwd message?
1801  */
1802 static void
1803 tunnel_decrypt (struct MeshTunnel2 *t,
1804                 void *dst, const void *src,
1805                 size_t size, uint64_t iv, int fwd)
1806 {
1807   memcpy (dst, src, size);
1808 }
1809
1810
1811 /**
1812  * Sends an already built message on a connection, properly registering
1813  * all used resources.
1814  *
1815  * @param message Message to send. Function makes a copy of it.
1816  *                If message is not hop-by-hop, decrements TTL of copy.
1817  * @param c Connection on which this message is transmitted.
1818  * @param ch Channel on which this message is transmitted, or NULL.
1819  * @param fwd Is this a fwd message?
1820  */
1821 static void
1822 send_prebuilt_message_connection (const struct GNUNET_MessageHeader *message,
1823                                   struct MeshConnection *c,
1824                                   struct MeshChannel *ch,
1825                                   int fwd)
1826 {
1827   void *data;
1828   size_t size;
1829   uint16_t type;
1830
1831   size = ntohs (message->size);
1832   data = GNUNET_malloc (size);
1833   memcpy (data, message, size);
1834   type = ntohs (message->type);
1835   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Send %s (%u) on connection %s\n",
1836               GNUNET_MESH_DEBUG_M2S (type), size, GNUNET_h2s (&c->id));
1837
1838   switch (type)
1839   {
1840     struct GNUNET_MESH_Encrypted *emsg;
1841     struct GNUNET_MESH_ACK       *amsg;
1842     struct GNUNET_MESH_Poll      *pmsg;
1843     uint32_t ttl;
1844
1845     case GNUNET_MESSAGE_TYPE_MESH_FWD:
1846     case GNUNET_MESSAGE_TYPE_MESH_BCK:
1847       emsg = (struct GNUNET_MESH_Encrypted *) data;
1848       ttl = ntohl (emsg->ttl);
1849       if (0 == ttl)
1850       {
1851         GNUNET_break_op (0);
1852         return;
1853       }
1854       emsg->cid = c->id;
1855       emsg->ttl = htonl (ttl - 1);
1856       emsg->pid = htonl (fwd ? c->fwd_fc.next_pid++ : c->bck_fc.next_pid++);
1857       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " pid %u\n", ntohl (emsg->pid));
1858       break;
1859
1860     case GNUNET_MESSAGE_TYPE_MESH_ACK:
1861       amsg = (struct GNUNET_MESH_ACK *) data;
1862       amsg->cid = c->id;
1863       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " ack %u\n", ntohl (amsg->ack));
1864       break;
1865
1866     case GNUNET_MESSAGE_TYPE_MESH_POLL:
1867       pmsg = (struct GNUNET_MESH_Poll *) data;
1868       pmsg->cid = c->id;
1869       pmsg->pid = htonl (fwd ? c->fwd_fc.last_pid_sent : c->bck_fc.last_pid_sent);
1870       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " poll %u\n", ntohl (pmsg->pid));
1871       break;
1872
1873     default:
1874       GNUNET_break (0);
1875   }
1876
1877   queue_add (data,
1878              type,
1879              size,
1880              c,
1881              ch,
1882              fwd);
1883 }
1884
1885
1886 /**
1887  * Sends an already built message on a tunnel, choosing the best connection.
1888  *
1889  * @param message Message to send. Function modifies it.
1890  * @param t Tunnel on which this message is transmitted.
1891  * @param ch Channel on which this message is transmitted.
1892  * @param fwd Is this a fwd message?
1893  */
1894 static void
1895 send_prebuilt_message_tunnel (struct GNUNET_MESH_Encrypted *msg,
1896                               struct MeshTunnel2 *t,
1897                               struct MeshChannel *ch,
1898                               int fwd)
1899 {
1900   struct MeshConnection *c;
1901   uint16_t type;
1902
1903   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Send on Tunnel %s\n",
1904               peer2s (t->peer));
1905   c = tunnel_get_connection (t, fwd);
1906   if (NULL == c)
1907   {
1908     GNUNET_break (GNUNET_YES == t->destroy);
1909     return;
1910   }
1911   type = ntohs (msg->header.type);
1912   switch (type)
1913   {
1914     case GNUNET_MESSAGE_TYPE_MESH_FWD:
1915     case GNUNET_MESSAGE_TYPE_MESH_BCK:
1916     case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_CREATE:
1917     case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_DESTROY:
1918       msg->cid = c->id;
1919       msg->ttl = htonl (default_ttl);
1920       break;
1921     default:
1922       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "unkown type %s\n",
1923                   GNUNET_MESH_DEBUG_M2S (type));
1924       GNUNET_break (0);
1925   }
1926   msg->reserved = 0;
1927
1928   send_prebuilt_message_connection (&msg->header, c, ch, fwd);
1929 }
1930
1931
1932 /**
1933  * Sends an already built message on a channel, properly registering
1934  * all used resources and encrypting the message with the tunnel's key.
1935  *
1936  * @param message Message to send. Function makes a copy of it.
1937  * @param ch Channel on which this message is transmitted.
1938  * @param fwd Is this a fwd message?
1939  */
1940 static void
1941 send_prebuilt_message_channel (const struct GNUNET_MessageHeader *message,
1942                                struct MeshChannel *ch,
1943                                int fwd)
1944 {
1945   struct GNUNET_MESH_Encrypted *msg;
1946   size_t size = ntohs (message->size);
1947   char *cbuf[sizeof (struct GNUNET_MESH_Encrypted) + size];
1948   uint16_t type;
1949   uint64_t iv;
1950
1951   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Send on Channel %s:%X\n",
1952               peer2s (ch->t->peer), ch->gid);
1953   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  %s\n",
1954               GNUNET_MESH_DEBUG_M2S (ntohs (message->type)));
1955
1956   if (channel_is_terminal (ch, fwd))
1957   {
1958     handle_decrypted (ch->t, message, fwd);
1959     return;
1960   }
1961
1962   type = fwd ? GNUNET_MESSAGE_TYPE_MESH_FWD : GNUNET_MESSAGE_TYPE_MESH_BCK;
1963   iv = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_NONCE, UINT64_MAX);
1964
1965   msg = (struct GNUNET_MESH_Encrypted *) cbuf;
1966   msg->header.type = htons (type);
1967   msg->header.size = htons (sizeof (struct GNUNET_MESH_Encrypted) + size);
1968   msg->iv = GNUNET_htonll (iv);
1969   tunnel_encrypt (ch->t, &msg[1], message, size, iv, fwd);
1970   send_prebuilt_message_tunnel (msg, ch->t, ch, fwd);
1971 }
1972
1973
1974 /**
1975  * Sends a CREATE CONNECTION message for a path to a peer.
1976  * Changes the connection and tunnel states if necessary.
1977  *
1978  * @param connection Connection to create.
1979  */
1980 static void
1981 send_connection_create (struct MeshConnection *connection)
1982 {
1983   struct MeshTunnel2 *t;
1984
1985   t = connection->t;
1986   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Send connection create\n");
1987   queue_add (NULL,
1988              GNUNET_MESSAGE_TYPE_MESH_CONNECTION_CREATE,
1989              sizeof (struct GNUNET_MESH_ConnectionCreate) +
1990                 (connection->path->length *
1991                  sizeof (struct GNUNET_PeerIdentity)),
1992              connection,
1993              NULL,
1994              GNUNET_YES);
1995   if (NULL != t &&
1996       (MESH_TUNNEL_SEARCHING == t->state || MESH_TUNNEL_NEW == t->state))
1997     tunnel_change_state (t, MESH_TUNNEL_WAITING);
1998   if (MESH_CONNECTION_NEW == connection->state)
1999     connection_change_state (connection, MESH_CONNECTION_SENT);
2000 }
2001
2002
2003 /**
2004  * Sends a CONNECTION ACK message in reponse to a received CONNECTION_CREATE
2005  * directed to us.
2006  *
2007  * @param connection Connection to confirm.
2008  * @param fwd Is this a fwd ACK? (First is bck (SYNACK), second is fwd (ACK))
2009  */
2010 static void
2011 send_connection_ack (struct MeshConnection *connection, int fwd)
2012 {
2013   struct MeshTunnel2 *t;
2014
2015   t = connection->t;
2016   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Send connection ack\n");
2017   queue_add (NULL,
2018              GNUNET_MESSAGE_TYPE_MESH_CONNECTION_ACK,
2019              sizeof (struct GNUNET_MESH_ConnectionACK),
2020              connection,
2021              NULL,
2022              fwd);
2023   if (MESH_TUNNEL_NEW == t->state)
2024     tunnel_change_state (t, MESH_TUNNEL_WAITING);
2025 }
2026
2027
2028 /**
2029   * Core callback to write a pre-constructed data packet to core buffer
2030   *
2031   * @param cls Closure (MeshTransmissionDescriptor with data in "data" member).
2032   * @param size Number of bytes available in buf.
2033   * @param buf Where the to write the message.
2034   *
2035   * @return number of bytes written to buf
2036   */
2037 static size_t
2038 send_core_data_raw (void *cls, size_t size, void *buf)
2039 {
2040   struct GNUNET_MessageHeader *msg = cls;
2041   size_t total_size;
2042
2043   GNUNET_assert (NULL != msg);
2044   total_size = ntohs (msg->size);
2045
2046   if (total_size > size)
2047   {
2048     GNUNET_break (0);
2049     return 0;
2050   }
2051   memcpy (buf, msg, total_size);
2052   GNUNET_free (cls);
2053   return total_size;
2054 }
2055
2056
2057 /**
2058  * Function to send a create connection message to a peer.
2059  *
2060  * @param c Connection to create.
2061  * @param size number of bytes available in buf
2062  * @param buf where the callee should write the message
2063  * @return number of bytes written to buf
2064  */
2065 static size_t
2066 send_core_connection_create (struct MeshConnection *c, size_t size, void *buf)
2067 {
2068   struct GNUNET_MESH_ConnectionCreate *msg;
2069   struct GNUNET_PeerIdentity *peer_ptr;
2070   struct MeshPeerPath *p = c->path;
2071   size_t size_needed;
2072   int i;
2073
2074   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending CONNECTION CREATE...\n");
2075   size_needed =
2076       sizeof (struct GNUNET_MESH_ConnectionCreate) +
2077       p->length * sizeof (struct GNUNET_PeerIdentity);
2078
2079   if (size < size_needed || NULL == buf)
2080   {
2081     GNUNET_break (0);
2082     return 0;
2083   }
2084   msg = (struct GNUNET_MESH_ConnectionCreate *) buf;
2085   msg->header.size = htons (size_needed);
2086   msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_CONNECTION_CREATE);
2087   msg->cid = c->id;
2088
2089   peer_ptr = (struct GNUNET_PeerIdentity *) &msg[1];
2090   for (i = 0; i < p->length; i++)
2091   {
2092     GNUNET_PEER_resolve (p->peers[i], peer_ptr++);
2093   }
2094
2095   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2096               "CONNECTION CREATE (%u bytes long) sent!\n", size_needed);
2097   return size_needed;
2098 }
2099
2100
2101 /**
2102  * Creates a path ack message in buf and frees all unused resources.
2103  *
2104  * @param c Connection to send an ACK on.
2105  * @param size number of bytes available in buf
2106  * @param buf where the callee should write the message
2107  *
2108  * @return number of bytes written to buf
2109  */
2110 static size_t
2111 send_core_connection_ack (struct MeshConnection *c, size_t size, void *buf)
2112 {
2113   struct GNUNET_MESH_ConnectionACK *msg = buf;
2114   struct MeshTunnel2 *t = c->t;
2115
2116   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending CONNECTION ACK...\n");
2117   GNUNET_assert (NULL != t);
2118   if (sizeof (struct GNUNET_MESH_ConnectionACK) > size)
2119   {
2120     GNUNET_break (0);
2121     return 0;
2122   }
2123   msg->header.size = htons (sizeof (struct GNUNET_MESH_ConnectionACK));
2124   msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_CONNECTION_ACK);
2125   msg->cid = c->id;
2126
2127   /* TODO add signature */
2128
2129   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "CONNECTION ACK sent!\n");
2130   return sizeof (struct GNUNET_MESH_ConnectionACK);
2131 }
2132
2133
2134 /**
2135  * Destroy the peer_info and free any allocated resources linked to it
2136  *
2137  * @param peer The peer_info to destroy.
2138  *
2139  * @return GNUNET_OK on success
2140  */
2141 static int
2142 peer_destroy (struct MeshPeer *peer)
2143 {
2144   struct GNUNET_PeerIdentity id;
2145   struct MeshPeerPath *p;
2146   struct MeshPeerPath *nextp;
2147
2148   GNUNET_PEER_resolve (peer->id, &id);
2149   GNUNET_PEER_change_rc (peer->id, -1);
2150
2151   if (GNUNET_YES !=
2152       GNUNET_CONTAINER_multihashmap_remove (peers, &id.hashPubKey, peer))
2153   {
2154     GNUNET_break (0);
2155     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
2156                 "removing peer %s, not in hashmap\n", GNUNET_i2s (&id));
2157   }
2158   if (NULL != peer->dhtget)
2159   {
2160     GNUNET_DHT_get_stop (peer->dhtget);
2161   }
2162   p = peer->path_head;
2163   while (NULL != p)
2164   {
2165     nextp = p->next;
2166     GNUNET_CONTAINER_DLL_remove (peer->path_head, peer->path_tail, p);
2167     path_destroy (p);
2168     p = nextp;
2169   }
2170   tunnel_destroy_empty (peer->tunnel);
2171   GNUNET_free (peer);
2172   return GNUNET_OK;
2173 }
2174
2175
2176 /**
2177  * Returns if peer is used (has a tunnel, is neighbor).
2178  *
2179  * @peer Peer to check.
2180  *
2181  * @return GNUNET_YES if peer is in use.
2182  */
2183 static int
2184 peer_is_used (struct MeshPeer *peer)
2185 {
2186   struct MeshPeerPath *p;
2187
2188   if (NULL != peer->tunnel)
2189     return GNUNET_YES;
2190
2191   for (p = peer->path_head; NULL != p; p = p->next)
2192   {
2193     if (p->length < 3)
2194       return GNUNET_YES;
2195   }
2196   return GNUNET_NO;
2197 }
2198
2199 /**
2200  * Iterator over all the peers to get the oldest timestamp.
2201  *
2202  * @param cls Closure (unsued).
2203  * @param key ID of the peer.
2204  * @param value Peer_Info of the peer.
2205  */
2206 static int
2207 peer_get_oldest (void *cls,
2208                  const struct GNUNET_HashCode *key,
2209                  void *value)
2210 {
2211   struct MeshPeer *p = value;
2212   struct GNUNET_TIME_Absolute *abs = cls;
2213
2214   /* Don't count active peers */
2215   if (GNUNET_YES == peer_is_used (p))
2216     return GNUNET_YES;
2217
2218   if (abs->abs_value_us < p->last_contact.abs_value_us)
2219     abs->abs_value_us = p->last_contact.abs_value_us;
2220
2221   return GNUNET_YES;
2222 }
2223
2224
2225 /**
2226  * Iterator over all the peers to remove the oldest entry.
2227  *
2228  * @param cls Closure (unsued).
2229  * @param key ID of the peer.
2230  * @param value Peer_Info of the peer.
2231  */
2232 static int
2233 peer_timeout (void *cls,
2234               const struct GNUNET_HashCode *key,
2235               void *value)
2236 {
2237   struct MeshPeer *p = value;
2238   struct GNUNET_TIME_Absolute *abs = cls;
2239
2240   if (p->last_contact.abs_value_us == abs->abs_value_us &&
2241       GNUNET_NO == peer_is_used (p))
2242   {
2243     peer_destroy (p);
2244     return GNUNET_NO;
2245   }
2246   return GNUNET_YES;
2247 }
2248
2249
2250 /**
2251  * Delete oldest unused peer.
2252  */
2253 static void
2254 peer_delete_oldest (void)
2255 {
2256   struct GNUNET_TIME_Absolute abs;
2257
2258   abs = GNUNET_TIME_UNIT_FOREVER_ABS;
2259
2260   GNUNET_CONTAINER_multihashmap_iterate (peers,
2261                                          &peer_get_oldest,
2262                                          &abs);
2263   GNUNET_CONTAINER_multihashmap_iterate (peers,
2264                                          &peer_timeout,
2265                                          &abs);
2266 }
2267
2268
2269 /**
2270  * Retrieve the MeshPeer stucture associated with the peer, create one
2271  * and insert it in the appropriate structures if the peer is not known yet.
2272  *
2273  * @param peer Full identity of the peer.
2274  *
2275  * @return Existing or newly created peer info.
2276  */
2277 static struct MeshPeer *
2278 peer_get (const struct GNUNET_PeerIdentity *peer_id)
2279 {
2280   struct MeshPeer *peer;
2281
2282   peer = GNUNET_CONTAINER_multihashmap_get (peers, &peer_id->hashPubKey);
2283   if (NULL == peer)
2284   {
2285     peer = GNUNET_new (struct MeshPeer);
2286     if (GNUNET_CONTAINER_multihashmap_size (peers) > max_peers)
2287     {
2288       peer_delete_oldest ();
2289     }
2290     GNUNET_CONTAINER_multihashmap_put (peers, &peer_id->hashPubKey, peer,
2291                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
2292     peer->id = GNUNET_PEER_intern (peer_id);
2293   }
2294   peer->last_contact = GNUNET_TIME_absolute_get();
2295
2296   return peer;
2297 }
2298
2299
2300 /**
2301  * Retrieve the MeshPeer stucture associated with the peer, create one
2302  * and insert it in the appropriate structures if the peer is not known yet.
2303  *
2304  * @param peer Short identity of the peer.
2305  *
2306  * @return Existing or newly created peer info.
2307  */
2308 static struct MeshPeer *
2309 peer_get_short (const GNUNET_PEER_Id peer)
2310 {
2311   return peer_get (GNUNET_PEER_resolve2 (peer));
2312 }
2313
2314
2315 /**
2316  * Get a cost of a path for a peer considering existing tunnel connections.
2317  *
2318  * @param peer Peer towards which the path is considered.
2319  * @param path Candidate path.
2320  *
2321  * @return Cost of the path (path length + number of overlapping nodes)
2322  */
2323 static unsigned int
2324 peer_get_path_cost (const struct MeshPeer *peer,
2325                     const struct MeshPeerPath *path)
2326 {
2327   struct MeshConnection *c;
2328   unsigned int overlap;
2329   unsigned int i;
2330   unsigned int j;
2331
2332   if (NULL == path)
2333     return 0;
2334
2335   overlap = 0;
2336   GNUNET_assert (NULL != peer->tunnel);
2337
2338   for (i = 0; i < path->length; i++)
2339   {
2340     for (c = peer->tunnel->connection_head; NULL != c; c = c->next)
2341     {
2342       for (j = 0; j < c->path->length; j++)
2343       {
2344         if (path->peers[i] == c->path->peers[j])
2345         {
2346           overlap++;
2347           break;
2348         }
2349       }
2350     }
2351   }
2352   return (path->length + overlap) * (path->score * -1);
2353 }
2354
2355
2356 /**
2357  * Choose the best path towards a peer considering the tunnel properties.
2358  *
2359  * @param peer The destination peer.
2360  *
2361  * @return Best current known path towards the peer, if any.
2362  */
2363 static struct MeshPeerPath *
2364 peer_get_best_path (const struct MeshPeer *peer)
2365 {
2366   struct MeshPeerPath *best_p;
2367   struct MeshPeerPath *p;
2368   struct MeshConnection *c;
2369   unsigned int best_cost;
2370   unsigned int cost;
2371
2372   best_cost = UINT_MAX;
2373   best_p = NULL;
2374   for (p = peer->path_head; NULL != p; p = p->next)
2375   {
2376     for (c = peer->tunnel->connection_head; NULL != c; c = c->next)
2377       if (c->path == p)
2378         break;
2379     if (NULL != c)
2380       continue; /* If path is in use in a connection, skip it. */
2381
2382     if ((cost = peer_get_path_cost (peer, p)) < best_cost)
2383     {
2384       best_cost = cost;
2385       best_p = p;
2386     }
2387   }
2388   return best_p;
2389 }
2390
2391 static int
2392 queue_is_sendable (struct MeshPeerQueue *q)
2393 {
2394   struct MeshFlowControl *fc;
2395
2396   /* Is PID-independent? */
2397   switch (q->type)
2398   {
2399     case GNUNET_MESSAGE_TYPE_MESH_ACK:
2400     case GNUNET_MESSAGE_TYPE_MESH_POLL:
2401       return GNUNET_YES;
2402   }
2403
2404   /* Is PID allowed? */
2405   fc = q->fwd ? &q->c->fwd_fc : &q->c->bck_fc;
2406   if (GMC_is_pid_bigger (fc->last_ack_recv, fc->last_pid_sent))
2407     return GNUNET_YES;
2408
2409   return GNUNET_NO;
2410 }
2411
2412
2413 /**
2414  * Get first sendable message.
2415  *
2416  * @param peer The destination peer.
2417  *
2418  * @return Best current known path towards the peer, if any.
2419  */
2420 static struct MeshPeerQueue *
2421 peer_get_first_message (const struct MeshPeer *peer)
2422 {
2423   struct MeshPeerQueue *q;
2424
2425   for (q = peer->queue_head; NULL != q; q = q->next)
2426   {
2427     if (queue_is_sendable (q))
2428       return q;
2429   }
2430
2431   return NULL;
2432 }
2433
2434
2435 /**
2436  * Try to establish a new connection to this peer in the given tunnel.
2437  * If the peer doesn't have any path to it yet, try to get one.
2438  * If the peer already has some path, send a CREATE CONNECTION towards it.
2439  *
2440  * @param peer PeerInfo of the peer.
2441  */
2442 static void
2443 peer_connect (struct MeshPeer *peer)
2444 {
2445   struct MeshTunnel2 *t;
2446   struct MeshPeerPath *p;
2447   struct MeshConnection *c;
2448
2449   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2450               "peer_connect towards %s\n",
2451               peer2s (peer));
2452   t = peer->tunnel;
2453   if (NULL != peer->path_head)
2454   {
2455     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "path exists\n");
2456     p = peer_get_best_path (peer);
2457     if (NULL != p)
2458     {
2459       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  %u hops\n", p->length);
2460       c = tunnel_use_path (t, p);
2461       send_connection_create (c);
2462     }
2463   }
2464   else if (NULL == peer->dhtget)
2465   {
2466     const struct GNUNET_PeerIdentity *id;
2467
2468     id = GNUNET_PEER_resolve2 (peer->id);
2469     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2470                 "  Starting DHT GET for peer %s\n", peer2s (peer));
2471     peer->dhtget = GNUNET_DHT_get_start (dht_handle,    /* handle */
2472                                          GNUNET_BLOCK_TYPE_MESH_PEER, /* type */
2473                                          &id->hashPubKey,     /* key to search */
2474                                          dht_replication_level, /* replication level */
2475                                          GNUNET_DHT_RO_RECORD_ROUTE |
2476                                          GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
2477                                          NULL,       /* xquery */
2478                                          0,     /* xquery bits */
2479                                          &dht_get_id_handler, peer);
2480     if (MESH_TUNNEL_NEW == t->state)
2481       tunnel_change_state (t, MESH_TUNNEL_SEARCHING);
2482   }
2483   else
2484   {
2485     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2486                 "There is no path but the DHT GET is already started.\n");
2487   }
2488 }
2489
2490
2491 /**
2492  * Get the first transmittable message for a connection.
2493  *
2494  * @param c Connection.
2495  * @param fwd Is this FWD?
2496  *
2497  * @return First transmittable message.
2498  */
2499 static struct MeshPeerQueue *
2500 connection_get_first_message (struct MeshConnection *c, int fwd)
2501 {
2502   struct MeshPeerQueue *q;
2503   struct MeshPeer *p;
2504
2505   p = connection_get_hop (c, fwd);
2506
2507   for (q = p->queue_head; NULL != q; q = q->next)
2508   {
2509     if (q->c != c)
2510       continue;
2511     if (queue_is_sendable (q))
2512       return q;
2513   }
2514
2515   return NULL;
2516 }
2517
2518
2519 /**
2520  * @brief Re-initiate traffic on this connection if necessary.
2521  *
2522  * Check if there is traffic queued towards this peer
2523  * and the core transmit handle is NULL (traffic was stalled).
2524  * If so, call core tmt rdy.
2525  *
2526  * @param c Connection on which initiate traffic.
2527  * @param fwd Is this about fwd traffic?
2528  */
2529 static void
2530 connection_unlock_queue (struct MeshConnection *c, int fwd)
2531 {
2532   struct MeshPeer *peer;
2533   struct MeshPeerQueue *q;
2534   size_t size;
2535
2536   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2537               "connection_unlock_queue %s on %s\n",
2538               fwd ? "FWD" : "BCK", GNUNET_h2s (&c->id));
2539
2540   if (connection_is_origin (c, fwd))
2541   {
2542     struct MeshTunnel2 *t = c->t;
2543     struct MeshChannel *ch;
2544     struct MeshChannelReliability *rel;
2545
2546     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " is origin!\n");
2547     /* FIXME randomize channel selection, not always first channel */
2548     for (ch = t->channel_head; NULL != ch; ch = ch->next)
2549     {
2550       rel = fwd ? ch->root_rel : ch->dest_rel;
2551
2552       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  channel %X - %s\n",
2553                   ch->gid, rel->client_ready ? "ready " : "not ready");
2554       if (GNUNET_NO == rel->client_ready)
2555       {
2556         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "    sending local ack!\n");
2557         send_local_ack (ch, fwd);
2558         return; /* FIXME authorize all channels? */
2559       }
2560     }
2561     return;
2562   }
2563
2564   peer = connection_get_hop (c, fwd);
2565
2566   if (NULL != peer->core_transmit)
2567   {
2568     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  already unlocked!\n");
2569     return; /* Already unlocked */
2570   }
2571
2572   q = connection_get_first_message (c, fwd);
2573   if (NULL == q)
2574   {
2575     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  queue empty!\n");
2576     return; /* Nothing to transmit */
2577   }
2578
2579   size = q->size;
2580   peer->core_transmit =
2581       GNUNET_CORE_notify_transmit_ready (core_handle,
2582                                          GNUNET_NO,
2583                                          0,
2584                                          GNUNET_TIME_UNIT_FOREVER_REL,
2585                                          GNUNET_PEER_resolve2 (peer->id),
2586                                          size,
2587                                          &queue_send,
2588                                          peer);
2589 }
2590
2591
2592 /**
2593  * Cancel all transmissions that belong to a certain connection.
2594  *
2595  * @param c Connection which to cancel.
2596  * @param fwd Cancel fwd traffic?
2597  */
2598 static void
2599 connection_cancel_queues (struct MeshConnection *c, int fwd)
2600 {
2601   struct MeshPeerQueue *q;
2602   struct MeshPeerQueue *next;
2603   struct MeshFlowControl *fc;
2604   struct MeshPeer *peer;
2605
2606   if (NULL == c)
2607   {
2608     GNUNET_break (0);
2609     return;
2610   }
2611   fc = fwd ? &c->fwd_fc : &c->bck_fc;
2612   peer = connection_get_hop (c, fwd);
2613
2614   for (q = peer->queue_head; NULL != q; q = next)
2615   {
2616     next = q->next;
2617     if (q->c == c)
2618     {
2619       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2620                   "connection_cancel_queue %s\n",
2621                   GNUNET_MESH_DEBUG_M2S (q->type));
2622       queue_destroy (q, GNUNET_YES);
2623     }
2624   }
2625   if (NULL == peer->queue_head)
2626   {
2627     if (NULL != peer->core_transmit)
2628     {
2629       GNUNET_CORE_notify_transmit_ready_cancel (peer->core_transmit);
2630       peer->core_transmit = NULL;
2631     }
2632     if (GNUNET_SCHEDULER_NO_TASK != fc->poll_task)
2633     {
2634       GNUNET_SCHEDULER_cancel (fc->poll_task);
2635       fc->poll_task = GNUNET_SCHEDULER_NO_TASK;
2636     }
2637   }
2638 }
2639
2640
2641 /**
2642  * Remove all paths that rely on a direct connection between p1 and p2
2643  * from the peer itself and notify all tunnels about it.
2644  *
2645  * @param peer PeerInfo of affected peer.
2646  * @param p1 GNUNET_PEER_Id of one peer.
2647  * @param p2 GNUNET_PEER_Id of another peer that was connected to the first and
2648  *           no longer is.
2649  *
2650  * TODO: optimize (see below)
2651  */
2652 static void
2653 peer_remove_path (struct MeshPeer *peer, GNUNET_PEER_Id p1,
2654                   GNUNET_PEER_Id p2)
2655 {
2656   struct MeshPeerPath *p;
2657   struct MeshPeerPath *next;
2658   struct MeshPeer *peer_d;
2659   GNUNET_PEER_Id d;
2660   unsigned int destroyed;
2661   unsigned int i;
2662
2663   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "peer_info_remove_path\n");
2664   destroyed = 0;
2665   for (p = peer->path_head; NULL != p; p = next)
2666   {
2667     next = p->next;
2668     for (i = 0; i < (p->length - 1); i++)
2669     {
2670       if ((p->peers[i] == p1 && p->peers[i + 1] == p2) ||
2671           (p->peers[i] == p2 && p->peers[i + 1] == p1))
2672       {
2673         GNUNET_CONTAINER_DLL_remove (peer->path_head, peer->path_tail, p);
2674         path_destroy (p);
2675         destroyed++;
2676         break;
2677       }
2678     }
2679   }
2680   if (0 == destroyed)
2681     return;
2682
2683
2684   d = tunnel_notify_connection_broken (peer->tunnel, p1, p2);
2685
2686   peer_d = peer_get_short (d); // FIXME
2687   next = peer_get_best_path (peer_d);
2688   tunnel_use_path (peer->tunnel, next);
2689   peer_connect (peer_d);
2690
2691   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "peer_info_remove_path END\n");
2692 }
2693
2694
2695 /**
2696  * Add the path to the peer and update the path used to reach it in case this
2697  * is the shortest.
2698  *
2699  * @param peer_info Destination peer to add the path to.
2700  * @param path New path to add. Last peer must be the peer in arg 1.
2701  *             Path will be either used of freed if already known.
2702  * @param trusted Do we trust that this path is real?
2703  */
2704 void
2705 peer_add_path (struct MeshPeer *peer_info, struct MeshPeerPath *path,
2706                     int trusted)
2707 {
2708   struct MeshPeerPath *aux;
2709   unsigned int l;
2710   unsigned int l2;
2711
2712   if ((NULL == peer_info) || (NULL == path))
2713   {
2714     GNUNET_break (0);
2715     path_destroy (path);
2716     return;
2717   }
2718   if (path->peers[path->length - 1] != peer_info->id)
2719   {
2720     GNUNET_break (0);
2721     path_destroy (path);
2722     return;
2723   }
2724   if (2 >= path->length && GNUNET_NO == trusted)
2725   {
2726     /* Only allow CORE to tell us about direct paths */
2727     path_destroy (path);
2728     return;
2729   }
2730   for (l = 1; l < path->length; l++)
2731   {
2732     if (path->peers[l] == myid)
2733     {
2734       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "shortening path by %u\n", l);
2735       for (l2 = 0; l2 < path->length - l; l2++)
2736       {
2737         path->peers[l2] = path->peers[l + l2];
2738       }
2739       path->length -= l;
2740       l = 1;
2741       path->peers =
2742           GNUNET_realloc (path->peers, path->length * sizeof (GNUNET_PEER_Id));
2743     }
2744   }
2745
2746   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "adding path [%u] to peer %s\n",
2747               path->length, peer2s (peer_info));
2748
2749   l = path_get_length (path);
2750   if (0 == l)
2751   {
2752     path_destroy (path);
2753     return;
2754   }
2755
2756   GNUNET_assert (peer_info->id == path->peers[path->length - 1]);
2757   for (aux = peer_info->path_head; aux != NULL; aux = aux->next)
2758   {
2759     l2 = path_get_length (aux);
2760     if (l2 > l)
2761     {
2762       GNUNET_CONTAINER_DLL_insert_before (peer_info->path_head,
2763                                           peer_info->path_tail, aux, path);
2764       return;
2765     }
2766     else
2767     {
2768       if (l2 == l && memcmp (path->peers, aux->peers, l) == 0)
2769       {
2770         path_destroy (path);
2771         return;
2772       }
2773     }
2774   }
2775   GNUNET_CONTAINER_DLL_insert_tail (peer_info->path_head, peer_info->path_tail,
2776                                     path);
2777   return;
2778 }
2779
2780
2781 /**
2782  * Add the path to the origin peer and update the path used to reach it in case
2783  * this is the shortest.
2784  * The path is given in peer_info -> destination, therefore we turn the path
2785  * upside down first.
2786  *
2787  * @param peer_info Peer to add the path to, being the origin of the path.
2788  * @param path New path to add after being inversed.
2789  *             Path will be either used or freed.
2790  * @param trusted Do we trust that this path is real?
2791  */
2792 static void
2793 peer_add_path_to_origin (struct MeshPeer *peer_info,
2794                          struct MeshPeerPath *path, int trusted)
2795 {
2796   path_invert (path);
2797   peer_add_path (peer_info, path, trusted);
2798 }
2799
2800
2801
2802 /**
2803  * Function called if a connection has been stalled for a while,
2804  * possibly due to a missed ACK. Poll the neighbor about its ACK status.
2805  *
2806  * @param cls Closure (poll ctx).
2807  * @param tc TaskContext.
2808  */
2809 static void
2810 connection_poll (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
2811 {
2812   struct MeshFlowControl *fc = cls;
2813   struct GNUNET_MESH_Poll msg;
2814   struct MeshConnection *c;
2815
2816   fc->poll_task = GNUNET_SCHEDULER_NO_TASK;
2817   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
2818   {
2819     return;
2820   }
2821
2822   c = fc->c;
2823   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " *** Polling!\n");
2824   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " *** connection %s[%X]\n",
2825               peer2s (c->t->peer), c->id);
2826   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " ***   %s\n",
2827               fc == &c->fwd_fc ? "FWD" : "BCK");
2828
2829   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_POLL);
2830   msg.header.size = htons (sizeof (msg));
2831   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " *** pid (%u)!\n", fc->last_pid_sent);
2832   send_prebuilt_message_connection (&msg.header, c, NULL, fc == &c->fwd_fc);
2833   fc->poll_time = GNUNET_TIME_STD_BACKOFF (fc->poll_time);
2834   fc->poll_task = GNUNET_SCHEDULER_add_delayed (fc->poll_time,
2835                                                 &connection_poll, fc);
2836 }
2837
2838
2839 /**
2840  * Build a PeerPath from the paths returned from the DHT, reversing the paths
2841  * to obtain a local peer -> destination path and interning the peer ids.
2842  *
2843  * @return Newly allocated and created path
2844  */
2845 static struct MeshPeerPath *
2846 path_build_from_dht (const struct GNUNET_PeerIdentity *get_path,
2847                      unsigned int get_path_length,
2848                      const struct GNUNET_PeerIdentity *put_path,
2849                      unsigned int put_path_length)
2850 {
2851   struct MeshPeerPath *p;
2852   GNUNET_PEER_Id id;
2853   int i;
2854
2855   p = path_new (1);
2856   p->peers[0] = myid;
2857   GNUNET_PEER_change_rc (myid, 1);
2858   i = get_path_length;
2859   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   GET has %d hops.\n", i);
2860   for (i--; i >= 0; i--)
2861   {
2862     id = GNUNET_PEER_intern (&get_path[i]);
2863     if (p->length > 0 && id == p->peers[p->length - 1])
2864     {
2865       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   Optimizing 1 hop out.\n");
2866       GNUNET_PEER_change_rc (id, -1);
2867     }
2868     else
2869     {
2870       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   Adding from GET: %s.\n",
2871                   GNUNET_i2s (&get_path[i]));
2872       p->length++;
2873       p->peers = GNUNET_realloc (p->peers, sizeof (GNUNET_PEER_Id) * p->length);
2874       p->peers[p->length - 1] = id;
2875     }
2876   }
2877   i = put_path_length;
2878   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   PUT has %d hops.\n", i);
2879   for (i--; i >= 0; i--)
2880   {
2881     id = GNUNET_PEER_intern (&put_path[i]);
2882     if (id == myid)
2883     {
2884       /* PUT path went through us, so discard the path up until now and start
2885        * from here to get a much shorter (and loop-free) path.
2886        */
2887       path_destroy (p);
2888       p = path_new (0);
2889     }
2890     if (p->length > 0 && id == p->peers[p->length - 1])
2891     {
2892       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   Optimizing 1 hop out.\n");
2893       GNUNET_PEER_change_rc (id, -1);
2894     }
2895     else
2896     {
2897       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   Adding from PUT: %s.\n",
2898                   GNUNET_i2s (&put_path[i]));
2899       p->length++;
2900       p->peers = GNUNET_realloc (p->peers, sizeof (GNUNET_PEER_Id) * p->length);
2901       p->peers[p->length - 1] = id;
2902     }
2903   }
2904 #if MESH_DEBUG
2905   if (get_path_length > 0)
2906     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   (first of GET: %s)\n",
2907                 GNUNET_i2s (&get_path[0]));
2908   if (put_path_length > 0)
2909     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   (first of PUT: %s)\n",
2910                 GNUNET_i2s (&put_path[0]));
2911   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   In total: %d hops\n",
2912               p->length);
2913   for (i = 0; i < p->length; i++)
2914   {
2915     struct GNUNET_PeerIdentity peer_id;
2916
2917     GNUNET_PEER_resolve (p->peers[i], &peer_id);
2918     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "       %u: %s\n", p->peers[i],
2919                 GNUNET_i2s (&peer_id));
2920   }
2921 #endif
2922   return p;
2923 }
2924
2925
2926 /**
2927  * Adds a path to the peer_infos of all the peers in the path
2928  *
2929  * @param p Path to process.
2930  * @param confirmed Whether we know if the path works or not.
2931  */
2932 static void
2933 path_add_to_peers (struct MeshPeerPath *p, int confirmed)
2934 {
2935   unsigned int i;
2936
2937   /* TODO: invert and add */
2938   for (i = 0; i < p->length && p->peers[i] != myid; i++) /* skip'em */ ;
2939   for (i++; i < p->length; i++)
2940   {
2941     struct MeshPeer *aux;
2942     struct MeshPeerPath *copy;
2943
2944     aux = peer_get_short (p->peers[i]);
2945     copy = path_duplicate (p);
2946     copy->length = i + 1;
2947     peer_add_path (aux, copy, p->length < 3 ? GNUNET_NO : confirmed);
2948   }
2949 }
2950
2951
2952 /**
2953  * Search for a channel among the channels for a client
2954  *
2955  * @param c the client whose channels to search in
2956  * @param chid the local id of the channel
2957  *
2958  * @return channel handler, NULL if doesn't exist
2959  */
2960 static struct MeshChannel *
2961 channel_get_by_local_id (struct MeshClient *c, MESH_ChannelNumber chid)
2962 {
2963   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   -- get CHID %X\n", chid);
2964   if (0 == (chid & GNUNET_MESH_LOCAL_CHANNEL_ID_CLI))
2965   {
2966     GNUNET_break_op (0);
2967     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "CHID %X not a local chid\n", chid);
2968     return NULL;
2969   }
2970   if (chid >= GNUNET_MESH_LOCAL_CHANNEL_ID_SERV)
2971     return GNUNET_CONTAINER_multihashmap32_get (c->incoming_channels, chid);
2972   return GNUNET_CONTAINER_multihashmap32_get (c->own_channels, chid);
2973 }
2974
2975 #if 0
2976
2977 static void
2978 channel_debug (struct MeshChannel *ch)
2979 {
2980   if (NULL == ch)
2981   {
2982     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "*** DEBUG NULL CHANNEL ***\n");
2983     return;
2984   }
2985   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Channel %s:%X\n",
2986               peer2s (ch->t->peer), ch->gid);
2987   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  root %p/%p\n",
2988               ch->root, ch->root_rel);
2989   if (NULL != ch->root)
2990   {
2991     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  cli %u\n", ch->root->id);
2992     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  ready %s\n",
2993                 ch->root_rel->client_ready ? "YES" : "NO");
2994     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  id %X\n", ch->lid_root);
2995   }
2996   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  root %p/%p\n",
2997               ch->dest, ch->dest_rel);
2998   if (NULL != ch->dest)
2999   {
3000     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  cli %u\n", ch->dest->id);
3001     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  ready %s\n",
3002                 ch->dest_rel->client_ready ? "YES" : "NO");
3003     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  id %X\n", ch->lid_dest);
3004   }
3005 }
3006
3007 static void
3008 fc_debug (struct MeshFlowControl *fc)
3009 {
3010   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "    IN: %u/%u\n",
3011               fc->last_pid_recv, fc->last_ack_sent);
3012   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "    OUT: %u/%u\n",
3013               fc->last_pid_sent, fc->last_ack_recv);
3014   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "    QUEUE: %u/%u\n",
3015               fc->queue_n, fc->queue_max);
3016 }
3017
3018 static void
3019 connection_debug (struct MeshConnection *c)
3020 {
3021   if (NULL == c)
3022   {
3023     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "*** DEBUG NULL CONNECTION ***\n");
3024     return;
3025   }
3026   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connection %s:%X\n",
3027               peer2s (c->t->peer), GNUNET_h2s (&c->id));
3028   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  state: %u, pending msgs: %u\n",
3029               c->state, c->pending_messages);
3030   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  FWD FC\n");
3031   fc_debug (&c->fwd_fc);
3032   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  BCK FC\n");
3033   fc_debug (&c->bck_fc);
3034 }
3035
3036 #endif
3037
3038 static struct MeshChannel *
3039 channel_get (struct MeshTunnel2 *t, MESH_ChannelNumber chid)
3040 {
3041   struct MeshChannel *ch;
3042
3043   if (NULL == t)
3044     return NULL;
3045
3046   for (ch = t->channel_head; NULL != ch; ch = ch->next)
3047   {
3048     if (ch->gid == chid)
3049       break;
3050   }
3051
3052   return ch;
3053 }
3054
3055
3056 /**
3057  * Change the tunnel state.
3058  *
3059  * @param t Tunnel whose state to change.
3060  * @param state New state.
3061  */
3062 static void
3063 tunnel_change_state (struct MeshTunnel2* t, enum MeshTunnelState state)
3064 {
3065   if (NULL == t)
3066     return;
3067   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3068               "Tunnel %s state was %s\n",
3069               peer2s (t->peer),
3070               GNUNET_MESH_DEBUG_TS2S (t->state));
3071   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3072               "Tunnel %s state is now %s\n",
3073               peer2s (t->peer),
3074               GNUNET_MESH_DEBUG_TS2S (state));
3075   t->state = state;
3076 }
3077
3078
3079 /**
3080  * Cache a message to be sent once tunnel is online.
3081  *
3082  * @param t Tunnel to hold the message.
3083  * @param ch Channel the message is about.
3084  * @param msg Message itself (copy will be made).
3085  * @param fwd Is this fwd?
3086  */
3087 static void
3088 tunnel_queue_data (struct MeshTunnel2 *t,
3089                    struct MeshChannel *ch,
3090                    struct GNUNET_MessageHeader *msg,
3091                    int fwd)
3092 {
3093   struct MeshTunnelQueue *tq;
3094   uint16_t size = ntohs (msg->size);
3095
3096   tq = GNUNET_malloc (sizeof (struct MeshTunnelQueue) + size);
3097
3098   tq->ch = ch;
3099   memcpy (&tq[1], msg, size);
3100   GNUNET_CONTAINER_DLL_insert_tail (t->tq_head, t->tq_tail, tq);
3101 }
3102
3103
3104 /**
3105  * Send all cached messages that we can, tunnel is online.
3106  *
3107  * @param t Tunnel that holds the messages.
3108  * @param fwd Is this fwd?
3109  */
3110 static void
3111 tunnel_send_queued_data (struct MeshTunnel2 *t, int fwd)
3112 {
3113   struct MeshTunnelQueue *tq;
3114   struct MeshTunnelQueue *next;
3115   unsigned int room;
3116
3117   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3118               "tunnel_send_queued_data on tunnel %s\n",
3119               peer2s (t->peer));
3120   room = tunnel_get_buffer (t, fwd);
3121   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  buffer space: %u\n", room);
3122   for (tq = t->tq_head; NULL != tq && room > 0; tq = next)
3123   {
3124     next = tq->next;
3125     room--;
3126     GNUNET_CONTAINER_DLL_remove (t->tq_head, t->tq_tail, tq);
3127     send_prebuilt_message_channel ((struct GNUNET_MessageHeader *) &tq[1],
3128                                    tq->ch, fwd);
3129
3130     GNUNET_free (tq);
3131   }
3132 }
3133
3134
3135 static void
3136 connection_change_state (struct MeshConnection* c,
3137                          enum MeshConnectionState state)
3138 {
3139   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3140               "Connection %s state was %s\n",
3141               GNUNET_h2s (&c->id), GNUNET_MESH_DEBUG_CS2S (c->state));
3142   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3143               "Connection %s state is now %s\n",
3144               GNUNET_h2s (&c->id), GNUNET_MESH_DEBUG_CS2S (state));
3145   c->state = state;
3146 }
3147
3148
3149 /**
3150  * Add a client to a channel, initializing all needed data structures.
3151  *
3152  * @param ch Channel to which add the client.
3153  * @param c Client which to add to the channel.
3154  */
3155 static void
3156 channel_add_client (struct MeshChannel *ch, struct MeshClient *c)
3157 {
3158   struct MeshTunnel2 *t = ch->t;
3159
3160   if (NULL != ch->dest)
3161   {
3162     GNUNET_break (0);
3163     return;
3164   }
3165
3166   /* Assign local id as destination */
3167   while (NULL != channel_get_by_local_id (c, t->next_local_chid))
3168     t->next_local_chid = (t->next_local_chid + 1) | GNUNET_MESH_LOCAL_CHANNEL_ID_SERV;
3169   ch->lid_dest = t->next_local_chid++;
3170   t->next_local_chid = t->next_local_chid | GNUNET_MESH_LOCAL_CHANNEL_ID_SERV;
3171
3172   /* Store in client's hashmap */
3173   if (GNUNET_OK !=
3174       GNUNET_CONTAINER_multihashmap32_put (c->incoming_channels,
3175                                            ch->lid_dest, ch,
3176                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
3177   {
3178     GNUNET_break (0);
3179     return;
3180   }
3181
3182   GNUNET_break (NULL == ch->dest_rel);
3183   ch->dest_rel = GNUNET_new (struct MeshChannelReliability);
3184   ch->dest_rel->ch = ch;
3185   ch->dest_rel->expected_delay = MESH_RETRANSMIT_TIME;
3186
3187   ch->dest = c;
3188 }
3189
3190
3191 static struct MeshConnection *
3192 tunnel_use_path (struct MeshTunnel2 *t, struct MeshPeerPath *p)
3193 {
3194   struct MeshConnection *c;
3195   struct GNUNET_HashCode cid;
3196   struct MeshPeer *peer;
3197   unsigned int own_pos;
3198
3199   GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_NONCE, &cid);
3200
3201   c = connection_new (&cid);
3202   c->t = t;
3203   for (own_pos = 0; own_pos < p->length; own_pos++)
3204   {
3205     if (p->peers[own_pos] == myid)
3206       break;
3207   }
3208   if (own_pos > p->length - 1)
3209   {
3210     GNUNET_break (0);
3211     connection_destroy (c);
3212     return NULL;
3213   }
3214   c->own_pos = own_pos;
3215   c->path = p;
3216
3217   if (0 == own_pos)
3218   {
3219     c->fwd_maintenance_task =
3220         GNUNET_SCHEDULER_add_delayed (refresh_connection_time,
3221                                       &connection_fwd_keepalive, c);
3222   }
3223
3224   peer = connection_get_next_hop (c);
3225   GNUNET_CONTAINER_multihashmap_put (peer->connections, &c->id, c,
3226                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
3227   peer = connection_get_prev_hop (c);
3228   GNUNET_CONTAINER_multihashmap_put (peer->connections, &c->id, c,
3229                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
3230   return c;
3231 }
3232
3233
3234 /**
3235  * Notifies a tunnel that a connection has broken that affects at least
3236  * some of its peers. Sends a notification towards the root of the tree.
3237  * In case the peer is the owner of the tree, notifies the client that owns
3238  * the tunnel and tries to reconnect.
3239  *
3240  * FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME
3241  *
3242  * @param t Tunnel affected.
3243  * @param p1 Peer that got disconnected from p2.
3244  * @param p2 Peer that got disconnected from p1.
3245  *
3246  * @return Short ID of the peer disconnected (either p1 or p2).
3247  *         0 if the tunnel remained unaffected.
3248  */
3249 static GNUNET_PEER_Id
3250 tunnel_notify_connection_broken (struct MeshTunnel2* t,
3251                                  GNUNET_PEER_Id p1, GNUNET_PEER_Id p2)
3252 {
3253 //   if (myid != p1 && myid != p2) FIXME
3254 //   {
3255 //     return;
3256 //   }
3257 //
3258 //   if (tree_get_predecessor (t->tree) != 0)
3259 //   {
3260 //     /* We are the peer still connected, notify owner of the disconnection. */
3261 //     struct GNUNET_MESH_PathBroken msg;
3262 //     struct GNUNET_PeerIdentity neighbor;
3263 //
3264 //     msg.header.size = htons (sizeof (msg));
3265 //     msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_PATH_BROKEN);
3266 //     GNUNET_PEER_resolve (t->id.oid, &msg.oid);
3267 //     msg.tid = htonl (t->id.tid);
3268 //     msg.peer1 = my_full_id;
3269 //     GNUNET_PEER_resolve (pid, &msg.peer2);
3270 //     GNUNET_PEER_resolve (tree_get_predecessor (t->tree), &neighbor);
3271 //     send_prebuilt_message (&msg.header, &neighbor, t);
3272 //   }
3273   return 0;
3274 }
3275
3276
3277 /**
3278  * Send an end-to-end ACK message for the most recent in-sequence payload.
3279  *
3280  * If channel is not reliable, do nothing.
3281  *
3282  * @param ch Channel this is about.
3283  * @param fwd Is for FWD traffic? (ACK dest->owner)
3284  */
3285 static void
3286 channel_send_data_ack (struct MeshChannel *ch, int fwd)
3287 {
3288   struct GNUNET_MESH_DataACK msg;
3289   struct MeshChannelReliability *rel;
3290   struct MeshReliableMessage *copy;
3291   unsigned int delta;
3292   uint64_t mask;
3293   uint16_t type;
3294
3295   if (GNUNET_NO == ch->reliable)
3296   {
3297     return;
3298   }
3299   rel = fwd ? ch->dest_rel : ch->root_rel;
3300   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3301               "send_data_ack for %u\n",
3302               rel->mid_recv - 1);
3303
3304   type = GNUNET_MESSAGE_TYPE_MESH_DATA_ACK;
3305   msg.header.type = htons (type);
3306   msg.header.size = htons (sizeof (msg));
3307   msg.chid = htonl (ch->gid);
3308   msg.mid = htonl (rel->mid_recv - 1);
3309   msg.futures = 0;
3310   for (copy = rel->head_recv; NULL != copy; copy = copy->next)
3311   {
3312     if (copy->type != type)
3313       continue;
3314     delta = copy->mid - rel->mid_recv;
3315     if (63 < delta)
3316       break;
3317     mask = 0x1LL << delta;
3318     msg.futures |= mask;
3319     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3320                 " setting bit for %u (delta %u) (%llX) -> %llX\n",
3321                 copy->mid, delta, mask, msg.futures);
3322   }
3323   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " final futures %llX\n", msg.futures);
3324
3325   send_prebuilt_message_channel (&msg.header, ch, fwd);
3326   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "send_data_ack END\n");
3327 }
3328
3329
3330 /**
3331  * Send an ACK informing the predecessor about the available buffer space.
3332  *
3333  * Note that for fwd ack, the FWD mean forward *traffic* (root->dest),
3334  * the ACK itself goes "back" (dest->root).
3335  *
3336  * @param c Connection on which to send the ACK.
3337  * @param buffer How much space free to advertise?
3338  * @param fwd Is this FWD ACK? (Going dest->owner)
3339  */
3340 static void
3341 connection_send_ack (struct MeshConnection *c, unsigned int buffer, int fwd)
3342 {
3343   struct MeshFlowControl *next_fc;
3344   struct MeshFlowControl *prev_fc;
3345   struct GNUNET_MESH_ACK msg;
3346   uint32_t ack;
3347   int delta;
3348
3349   next_fc = fwd ? &c->fwd_fc : &c->bck_fc;
3350   prev_fc = fwd ? &c->bck_fc : &c->fwd_fc;
3351
3352   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3353               "connection send %s ack on %s\n",
3354               fwd ? "FWD" : "BCK", GNUNET_h2s (&c->id));
3355
3356   /* Check if we need to transmit the ACK */
3357   if (prev_fc->last_ack_sent - prev_fc->last_pid_recv > 3)
3358   {
3359     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Not sending ACK, buffer > 3\n");
3360     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3361                 "  last pid recv: %u, last ack sent: %u\n",
3362                 prev_fc->last_pid_recv, prev_fc->last_ack_sent);
3363     return;
3364   }
3365
3366   /* Ok, ACK might be necessary, what PID to ACK? */
3367   delta = next_fc->queue_max - next_fc->queue_n;
3368   ack = prev_fc->last_pid_recv + delta;
3369   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " ACK %u\n", ack);
3370   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3371               " last pid %u, last ack %u, qmax %u, q %u\n",
3372               prev_fc->last_pid_recv, prev_fc->last_ack_sent,
3373               next_fc->queue_max, next_fc->queue_n);
3374   if (ack == prev_fc->last_ack_sent)
3375   {
3376     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Not sending FWD ACK, not needed\n");
3377     return;
3378   }
3379
3380   prev_fc->last_ack_sent = ack;
3381
3382   /* Build ACK message and send on connection */
3383   msg.header.size = htons (sizeof (msg));
3384   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_ACK);
3385   msg.ack = htonl (ack);
3386   msg.cid = c->id;
3387
3388   send_prebuilt_message_connection (&msg.header, c, NULL, !fwd);
3389 }
3390
3391
3392 /**
3393  * Modify the mesh message TID from global to local and send to client.
3394  *
3395  * @param ch Channel on which to send the message.
3396  * @param msg Message to modify and send.
3397  * @param c Client to send to.
3398  * @param tid Tunnel ID to use (c can be both owner and client).
3399  */
3400 static void
3401 channel_send_client_to_tid (struct MeshChannel *ch,
3402                              const struct GNUNET_MESH_Data *msg,
3403                              struct MeshClient *c, MESH_ChannelNumber id)
3404 {
3405   struct GNUNET_MESH_LocalData *copy;
3406   uint16_t size = ntohs (msg->header.size) - sizeof (struct GNUNET_MESH_Data);
3407   char cbuf[size + sizeof (struct GNUNET_MESH_LocalData)];
3408
3409   if (size < sizeof (struct GNUNET_MessageHeader))
3410   {
3411     GNUNET_break_op (0);
3412     return;
3413   }
3414   if (NULL == c)
3415   {
3416     GNUNET_break (0);
3417     return;
3418   }
3419   copy = (struct GNUNET_MESH_LocalData *) cbuf;
3420   memcpy (&copy[1], &msg[1], size);
3421   copy->header.size = htons (sizeof (struct GNUNET_MESH_LocalData) + size);
3422   copy->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_DATA);
3423   copy->id = htonl (id);
3424   GNUNET_SERVER_notification_context_unicast (nc, c->handle,
3425                                               &copy->header, GNUNET_NO);
3426 }
3427
3428
3429 /**
3430  * We have received a message out of order, or the client is not ready.
3431  * Buffer it until we receive an ACK from the client or the missing
3432  * message from the channel.
3433  *
3434  * @param msg Message to buffer (MUST be of type MESH_DATA).
3435  * @param rel Reliability data to the corresponding direction.
3436  */
3437 static void
3438 channel_rel_add_buffered_data (const struct GNUNET_MESH_Data *msg,
3439                                struct MeshChannelReliability *rel)
3440 {
3441   struct MeshReliableMessage *copy;
3442   struct MeshReliableMessage *prev;
3443   uint32_t mid;
3444   uint16_t size;
3445
3446   size = ntohs (msg->header.size);
3447   mid = ntohl (msg->mid);
3448
3449   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "add_buffered_data %u\n", mid);
3450
3451   copy = GNUNET_malloc (sizeof (*copy) + size);
3452   copy->mid = mid;
3453   copy->rel = rel;
3454   memcpy (&copy[1], msg, size);
3455
3456   rel->n_recv++;
3457
3458   // FIXME do something better than O(n), although n < 64...
3459   // FIXME start from the end (most messages are the latest ones)
3460   for (prev = rel->head_recv; NULL != prev; prev = prev->next)
3461   {
3462     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " prev %u\n", prev->mid);
3463     if (GMC_is_pid_bigger (prev->mid, mid))
3464     {
3465       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " bingo!\n");
3466       GNUNET_CONTAINER_DLL_insert_before (rel->head_recv, rel->tail_recv,
3467                                           prev, copy);
3468       return;
3469     }
3470   }
3471     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " insert at tail!\n");
3472     GNUNET_CONTAINER_DLL_insert_tail (rel->head_recv, rel->tail_recv, copy);
3473     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "add_buffered_data END\n");
3474 }
3475
3476
3477 static void
3478 channel_send_client_data (struct MeshChannel *ch,
3479                           const struct GNUNET_MESH_Data *msg,
3480                           int fwd)
3481 {
3482   if (fwd)
3483   {
3484     if (ch->dest_rel->client_ready)
3485       channel_send_client_to_tid (ch, msg, ch->dest, ch->lid_dest);
3486     else
3487       channel_rel_add_buffered_data (msg, ch->dest_rel);
3488   }
3489   else
3490   {
3491     if (ch->root_rel->client_ready)
3492       channel_send_client_to_tid (ch, msg, ch->root, ch->lid_root);
3493     else
3494       channel_rel_add_buffered_data (msg, ch->root_rel);
3495   }
3496 }
3497
3498
3499 /**
3500  * Send a buffered message to the client, for in order delivery or
3501  * as result of client ACK.
3502  *
3503  * @param ch Channel on which to empty the message buffer.
3504  * @param c Client to send to.
3505  * @param rel Reliability structure to corresponding peer.
3506  *            If rel == bck_rel, this is FWD data.
3507  */
3508 static void
3509 channel_send_client_buffered_data (struct MeshChannel *ch,
3510                                    struct MeshClient *c,
3511                                    int fwd)
3512 {
3513   struct MeshReliableMessage *copy;
3514   struct MeshChannelReliability *rel;
3515
3516   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "send_buffered_data\n");
3517   rel = fwd ? ch->dest_rel : ch->root_rel;
3518   if (GNUNET_NO == rel->client_ready)
3519   {
3520     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "client not ready\n");
3521     return;
3522   }
3523
3524   copy = rel->head_recv;
3525   /* We never buffer channel management messages */
3526   if (NULL != copy)
3527   {
3528     if (copy->mid == rel->mid_recv || GNUNET_NO == ch->reliable)
3529     {
3530       struct GNUNET_MESH_Data *msg = (struct GNUNET_MESH_Data *) &copy[1];
3531
3532       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3533                   " have %u! now expecting %u\n",
3534                   copy->mid, rel->mid_recv + 1);
3535       channel_send_client_data (ch, msg, fwd);
3536       rel->n_recv--;
3537       rel->mid_recv++;
3538       GNUNET_CONTAINER_DLL_remove (rel->head_recv, rel->tail_recv, copy);
3539       GNUNET_free (copy);
3540     }
3541     else
3542     {
3543       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3544                   " reliable && don't have %u, next is %u\n",
3545                   rel->mid_recv,
3546                   copy->mid);
3547       return;
3548     }
3549   }
3550   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "send_buffered_data END\n");
3551 }
3552
3553
3554 /**
3555  * Destroy a reliable message after it has been acknowledged, either by
3556  * direct mid ACK or bitfield. Updates the appropriate data structures and
3557  * timers and frees all memory.
3558  *
3559  * @param copy Message that is no longer needed: remote peer got it.
3560  */
3561 static void
3562 rel_message_free (struct MeshReliableMessage *copy)
3563 {
3564   struct MeshChannelReliability *rel;
3565   struct GNUNET_TIME_Relative time;
3566
3567   rel = copy->rel;
3568   time = GNUNET_TIME_absolute_get_duration (copy->timestamp);
3569   rel->expected_delay.rel_value_us *= 7;
3570   rel->expected_delay.rel_value_us += time.rel_value_us;
3571   rel->expected_delay.rel_value_us /= 8;
3572   rel->n_sent--;
3573   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "!!! Freeing %u\n", copy->mid);
3574   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "    n_sent %u\n", rel->n_sent);
3575   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "!!!  took %s\n",
3576               GNUNET_STRINGS_relative_time_to_string (time, GNUNET_NO));
3577   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "!!!  new expected delay %s\n",
3578               GNUNET_STRINGS_relative_time_to_string (rel->expected_delay,
3579                                                       GNUNET_NO));
3580   rel->retry_timer = rel->expected_delay;
3581   GNUNET_CONTAINER_DLL_remove (rel->head_sent, rel->tail_sent, copy);
3582   GNUNET_free (copy);
3583 }
3584
3585
3586 /**
3587  * Destroy all reliable messages queued for a channel,
3588  * during a channel destruction.
3589  * Frees the reliability structure itself.
3590  *
3591  * @param rel Reliability data for a channel.
3592  */
3593 static void
3594 channel_rel_free_all (struct MeshChannelReliability *rel)
3595 {
3596   struct MeshReliableMessage *copy;
3597   struct MeshReliableMessage *next;
3598
3599   if (NULL == rel)
3600     return;
3601
3602   for (copy = rel->head_recv; NULL != copy; copy = next)
3603   {
3604     next = copy->next;
3605     GNUNET_CONTAINER_DLL_remove (rel->head_recv, rel->tail_recv, copy);
3606     GNUNET_free (copy);
3607   }
3608   for (copy = rel->head_sent; NULL != copy; copy = next)
3609   {
3610     next = copy->next;
3611     GNUNET_CONTAINER_DLL_remove (rel->head_sent, rel->tail_sent, copy);
3612     GNUNET_free (copy);
3613   }
3614   if (GNUNET_SCHEDULER_NO_TASK != rel->retry_task)
3615     GNUNET_SCHEDULER_cancel (rel->retry_task);
3616   GNUNET_free (rel);
3617 }
3618
3619
3620 /**
3621  * Mark future messages as ACK'd.
3622  *
3623  * @param rel Reliability data.
3624  * @param msg DataACK message with a bitfield of future ACK'd messages.
3625  */
3626 static void
3627 channel_rel_free_sent (struct MeshChannelReliability *rel,
3628                        const struct GNUNET_MESH_DataACK *msg)
3629 {
3630   struct MeshReliableMessage *copy;
3631   struct MeshReliableMessage *next;
3632   uint64_t bitfield;
3633   uint64_t mask;
3634   uint32_t mid;
3635   uint32_t target;
3636   unsigned int i;
3637
3638   bitfield = msg->futures;
3639   mid = ntohl (msg->mid);
3640   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3641               "free_sent_reliable %u %llX\n",
3642               mid, bitfield);
3643   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3644               " rel %p, head %p\n",
3645               rel, rel->head_sent);
3646   for (i = 0, copy = rel->head_sent;
3647        i < 64 && NULL != copy && 0 != bitfield;
3648        i++)
3649   {
3650     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3651                 " trying bit %u (mid %u)\n",
3652                 i, mid + i + 1);
3653     mask = 0x1LL << i;
3654     if (0 == (bitfield & mask))
3655      continue;
3656
3657     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " set!\n");
3658     /* Bit was set, clear the bit from the bitfield */
3659     bitfield &= ~mask;
3660
3661     /* The i-th bit was set. Do we have that copy? */
3662     /* Skip copies with mid < target */
3663     target = mid + i + 1;
3664     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " target %u\n", target);
3665     while (NULL != copy && GMC_is_pid_bigger (target, copy->mid))
3666      copy = copy->next;
3667
3668     /* Did we run out of copies? (previously freed, it's ok) */
3669     if (NULL == copy)
3670     {
3671      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "run out of copies...\n");
3672      return;
3673     }
3674
3675     /* Did we overshoot the target? (previously freed, it's ok) */
3676     if (GMC_is_pid_bigger (copy->mid, target))
3677     {
3678      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " next copy %u\n", copy->mid);
3679      continue;
3680     }
3681
3682     /* Now copy->mid == target, free it */
3683     next = copy->next;
3684     rel_message_free (copy);
3685     copy = next;
3686   }
3687   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "free_sent_reliable END\n");
3688 }
3689
3690
3691 /**
3692  * We haven't received an ACK after a certain time: restransmit the message.
3693  *
3694  * @param cls Closure (MeshReliableMessage with the message to restransmit)
3695  * @param tc TaskContext.
3696  */
3697 static void
3698 channel_retransmit_message (void *cls,
3699                             const struct GNUNET_SCHEDULER_TaskContext *tc)
3700 {
3701   struct MeshChannelReliability *rel = cls;
3702   struct MeshReliableMessage *copy;
3703   struct MeshPeerQueue *q;
3704   struct MeshChannel *ch;
3705   struct MeshConnection *c;
3706   struct GNUNET_MESH_Data *payload;
3707   struct MeshPeer *hop;
3708   int fwd;
3709
3710   rel->retry_task = GNUNET_SCHEDULER_NO_TASK;
3711   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
3712     return;
3713
3714   ch = rel->ch;
3715   copy = rel->head_sent;
3716   if (NULL == copy)
3717   {
3718     GNUNET_break (0);
3719     return;
3720   }
3721
3722   /* Search the message to be retransmitted in the outgoing queue.
3723    * Check only the queue for the connection that is going to be used,
3724    * if the message is stuck in some other connection's queue we shouldn't
3725    * act upon it:
3726    * - cancelling it and sending the new one doesn't guarantee it's delivery,
3727    *   the old connection could be temporary stalled or the queue happened to
3728    *   be long at time of insertion.
3729    * - not sending the new one could cause terrible delays the old connection
3730    *   is stalled.
3731    */
3732   payload = (struct GNUNET_MESH_Data *) &copy[1];
3733   fwd = (rel == ch->root_rel);
3734   c = tunnel_get_connection (ch->t, fwd);
3735   hop = connection_get_hop (c, fwd);
3736   for (q = hop->queue_head; NULL != q; q = q->next)
3737   {
3738     if (ntohs (payload->header.type) == q->type && ch == q->ch)
3739     {
3740       struct GNUNET_MESH_Data *queued_data = q->cls;
3741
3742       if (queued_data->mid == payload->mid)
3743         break;
3744     }
3745   }
3746
3747   /* Message not found in the queue that we are going to use. */
3748   if (NULL == q)
3749   {
3750     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "!!! RETRANSMIT %u\n", copy->mid);
3751
3752     send_prebuilt_message_channel (&payload->header, ch, fwd);
3753     GNUNET_STATISTICS_update (stats, "# data retransmitted", 1, GNUNET_NO);
3754   }
3755   else
3756   {
3757     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "!!! ALREADY IN QUEUE %u\n", copy->mid);
3758   }
3759
3760   rel->retry_timer = GNUNET_TIME_STD_BACKOFF (rel->retry_timer);
3761   rel->retry_task = GNUNET_SCHEDULER_add_delayed (rel->retry_timer,
3762                                                   &channel_retransmit_message,
3763                                                   cls);
3764 }
3765
3766
3767 /**
3768  * Send ACK on one or more connections due to buffer space to the client.
3769  *
3770  * Iterates all connections of the tunnel and sends ACKs appropriately.
3771  *
3772  * @param ch Channel which has some free buffer space.
3773  * @param fwd Is this in for FWD traffic? (ACK goes dest->root)
3774  */
3775 static void
3776 channel_send_connections_ack (struct MeshChannel *ch,
3777                               unsigned int buffer,
3778                               int fwd)
3779 {
3780   struct MeshTunnel2 *t = ch->t;
3781   struct MeshConnection *c;
3782   struct MeshFlowControl *fc;
3783   uint32_t allowed;
3784   uint32_t to_allow;
3785   uint32_t allow_per_connection;
3786   unsigned int cs;
3787
3788   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3789               "Channel send connection %s ack on %s:%X\n",
3790               fwd ? "FWD" : "BCK", peer2s (ch->t->peer), ch->gid);
3791
3792   /* Count connections, how many messages are already allowed */
3793   for (cs = 0, allowed = 0, c = t->connection_head; NULL != c; c = c->next)
3794   {
3795     fc = fwd ? &c->fwd_fc : &c->bck_fc;
3796     if (GMC_is_pid_bigger(fc->last_pid_recv, fc->last_ack_sent))
3797     {
3798       GNUNET_break (0);
3799       continue;
3800     }
3801     allowed += fc->last_ack_sent - fc->last_pid_recv;
3802     cs++;
3803   }
3804
3805   /* Make sure there is no overflow */
3806   if (allowed > buffer)
3807   {
3808     GNUNET_break (0);
3809     return;
3810   }
3811
3812   /* Authorize connections to send more data */
3813   to_allow = buffer - allowed;
3814
3815   for (c = t->connection_head; NULL != c && to_allow > 0; c = c->next)
3816   {
3817     allow_per_connection = to_allow/cs;
3818     to_allow -= allow_per_connection;
3819     cs--;
3820     fc = fwd ? &c->fwd_fc : &c->bck_fc;
3821     if (fc->last_ack_sent - fc->last_pid_recv > 64 / 3)
3822     {
3823       continue;
3824     }
3825     connection_send_ack (c, allow_per_connection, fwd);
3826   }
3827
3828   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3829                 "Channel send connection %s ack on %s:%X\n",
3830                 fwd ? "FWD" : "BCK", peer2s (ch->t->peer), ch->gid);
3831   GNUNET_break (to_allow == 0);
3832 }
3833
3834
3835 /**
3836  * Send an ACK on the appropriate connection/channel, depending on
3837  * the direction and the position of the peer.
3838  *
3839  * @param c Which connection to send the hop-by-hop ACK.
3840  * @param ch Channel, if any.
3841  * @param fwd Is this a fwd ACK? (will go dest->root)
3842  */
3843 static void
3844 send_ack (struct MeshConnection *c, struct MeshChannel *ch, int fwd)
3845 {
3846   unsigned int buffer;
3847
3848   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3849               "send ack %s on %p %p\n",
3850               fwd ? "FWD" : "BCK", c, ch);
3851   if (NULL == c || connection_is_terminal (c, fwd))
3852   {
3853     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  getting from Channel\n");
3854     buffer = tunnel_get_buffer (NULL == c ? ch->t : c->t, fwd);
3855   }
3856   else
3857   {
3858     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  getting from Connection\n");
3859     GNUNET_assert (NULL != c);
3860     buffer = connection_get_buffer (c, fwd);
3861   }
3862   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  buffer available: %u\n", buffer);
3863
3864   if (NULL == c)
3865   {
3866     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  sending on all connections\n");
3867     GNUNET_assert (NULL != ch);
3868     channel_send_connections_ack (ch, buffer, fwd);
3869   }
3870   else if (connection_is_origin (c, fwd))
3871   {
3872     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  sending on channel...\n");
3873     if (0 < buffer)
3874     {
3875       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  really sending!\n");
3876       GNUNET_assert (NULL != ch);
3877       send_local_ack (ch, fwd);
3878     }
3879   }
3880   else
3881   {
3882     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  sending on connection\n");
3883     connection_send_ack (c, buffer, fwd);
3884   }
3885 }
3886
3887
3888 /**
3889  * Channel was ACK'd by remote peer, mark as ready and cancel retransmission.
3890  *
3891  * @param ch Channel to mark as ready.
3892  * @param fwd Was the CREATE message sent fwd?
3893  */
3894 static void
3895 channel_confirm (struct MeshChannel *ch, int fwd)
3896 {
3897   struct MeshChannelReliability *rel;
3898   struct MeshReliableMessage *copy;
3899   struct MeshReliableMessage *next;
3900
3901   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3902               "  channel confirm %s %s:%X\n",
3903               fwd ? "FWD" : "BCK", peer2s (ch->t->peer), ch->gid);
3904   ch->state = MESH_CHANNEL_READY;
3905
3906   rel = fwd ? ch->root_rel : ch->dest_rel;
3907   for (copy = rel->head_sent; NULL != copy; copy = next)
3908   {
3909     struct GNUNET_MessageHeader *msg;
3910
3911     next = copy->next;
3912     msg = (struct GNUNET_MessageHeader *) &copy[1];
3913     if (ntohs (msg->type) == GNUNET_MESSAGE_TYPE_MESH_CHANNEL_CREATE)
3914     {
3915       rel_message_free (copy);
3916       /* TODO return? */
3917     }
3918   }
3919   if (GNUNET_NO == rel->client_ready)
3920     send_local_ack (ch, fwd);
3921 }
3922
3923
3924 /**
3925  * Save a copy to retransmit in case it gets lost.
3926  *
3927  * Initializes all needed callbacks and timers.
3928  *
3929  * @param ch Channel this message goes on.
3930  * @param msg Message to copy.
3931  * @param fwd Is this fwd traffic?
3932  */
3933 static void
3934 channel_save_copy (struct MeshChannel *ch,
3935                    const struct GNUNET_MessageHeader *msg,
3936                    int fwd)
3937 {
3938   struct MeshChannelReliability *rel;
3939   struct MeshReliableMessage *copy;
3940   uint32_t mid;
3941   uint16_t type;
3942   uint16_t size;
3943
3944   rel = fwd ? ch->root_rel : ch->dest_rel;
3945   mid = rel->mid_send;
3946   type = ntohs (msg->type);
3947   size = ntohs (msg->size);
3948
3949   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "!!! SAVE %u\n", mid);
3950   copy = GNUNET_malloc (sizeof (struct MeshReliableMessage) + size);
3951   copy->mid = mid;
3952   copy->timestamp = GNUNET_TIME_absolute_get ();
3953   copy->rel = rel;
3954   copy->type = type;
3955   memcpy (&copy[1], msg, size);
3956   rel->n_sent++;
3957   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " n_sent %u\n", rel->n_sent);
3958   GNUNET_CONTAINER_DLL_insert_tail (rel->head_sent, rel->tail_sent, copy);
3959   if (GNUNET_SCHEDULER_NO_TASK == rel->retry_task)
3960   {
3961     rel->retry_timer =
3962         GNUNET_TIME_relative_multiply (rel->expected_delay,
3963                                         MESH_RETRANSMIT_MARGIN);
3964     rel->retry_task =
3965         GNUNET_SCHEDULER_add_delayed (rel->retry_timer,
3966                                       &channel_retransmit_message,
3967                                       rel);
3968   }
3969 }
3970
3971
3972 /**
3973  * Send keepalive packets for a connection.
3974  *
3975  * @param c Connection to keep alive..
3976  * @param fwd Is this a FWD keepalive? (owner -> dest).
3977  */
3978 static void
3979 connection_keepalive (struct MeshConnection *c, int fwd)
3980 {
3981   struct GNUNET_MESH_ConnectionKeepAlive *msg;
3982   size_t size = sizeof (struct GNUNET_MESH_ConnectionKeepAlive);
3983   char cbuf[size];
3984   uint16_t type;
3985
3986   type = fwd ? GNUNET_MESSAGE_TYPE_MESH_FWD_KEEPALIVE :
3987                GNUNET_MESSAGE_TYPE_MESH_BCK_KEEPALIVE;
3988
3989   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3990               "sending %s keepalive for connection %s[%d]\n",
3991               fwd ? "FWD" : "BCK",
3992               peer2s (c->t->peer),
3993               c->id);
3994
3995   msg = (struct GNUNET_MESH_ConnectionKeepAlive *) cbuf;
3996   msg->header.size = htons (size);
3997   msg->header.type = htons (type);
3998   msg->cid = c->id;
3999
4000   send_prebuilt_message_connection (&msg->header, c, NULL, fwd);
4001 }
4002
4003
4004 /**
4005  * Send CONNECTION_{CREATE/ACK} packets for a connection.
4006  *
4007  * @param c Connection for which to send the message.
4008  * @param fwd If GNUNET_YES, send CREATE, otherwise send ACK.
4009  */
4010 static void
4011 connection_recreate (struct MeshConnection *c, int fwd)
4012 {
4013   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "sending connection recreate\n");
4014   if (fwd)
4015     send_connection_create (c);
4016   else
4017     send_connection_ack (c, GNUNET_NO);
4018 }
4019
4020
4021 /**
4022  * Generic connection timer management.
4023  * Depending on the role of the peer in the connection will send the
4024  * appropriate message (build or keepalive)
4025  *
4026  * @param c Conncetion to maintain.
4027  * @param fwd Is FWD?
4028  */
4029 static void
4030 connection_maintain (struct MeshConnection *c, int fwd)
4031 {
4032   if (MESH_TUNNEL_SEARCHING == c->t->state)
4033   {
4034     /* TODO DHT GET with RO_BART */
4035     return;
4036   }
4037   switch (c->state)
4038   {
4039     case MESH_CONNECTION_NEW:
4040       GNUNET_break (0);
4041     case MESH_CONNECTION_SENT:
4042       connection_recreate (c, fwd);
4043       break;
4044     case MESH_CONNECTION_READY:
4045       connection_keepalive (c, fwd);
4046       break;
4047     default:
4048       break;
4049   }
4050 }
4051
4052
4053 static void
4054 connection_fwd_keepalive (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
4055 {
4056   struct MeshConnection *c = cls;
4057
4058   c->fwd_maintenance_task = GNUNET_SCHEDULER_NO_TASK;
4059   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
4060     return;
4061
4062   connection_maintain (c, GNUNET_YES);
4063   c->fwd_maintenance_task = GNUNET_SCHEDULER_add_delayed (refresh_connection_time,
4064                                                           &connection_fwd_keepalive,
4065                                                           c);
4066 }
4067
4068
4069 static void
4070 connection_bck_keepalive (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
4071 {
4072   struct MeshConnection *c = cls;
4073
4074   c->bck_maintenance_task = GNUNET_SCHEDULER_NO_TASK;
4075   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
4076     return;
4077
4078   connection_maintain (c, GNUNET_NO);
4079   c->bck_maintenance_task = GNUNET_SCHEDULER_add_delayed (refresh_connection_time,
4080                                                           &connection_bck_keepalive,
4081                                                           c);
4082 }
4083
4084
4085 /**
4086  * Send a message to all peers in this connection that the connection
4087  * is no longer valid.
4088  *
4089  * If some peer should not receive the message, it should be zero'ed out
4090  * before calling this function.
4091  *
4092  * @param c The connection whose peers to notify.
4093  */
4094 static void
4095 connection_send_destroy (struct MeshConnection *c)
4096 {
4097   struct GNUNET_MESH_ConnectionDestroy msg;
4098
4099   msg.header.size = htons (sizeof (msg));
4100   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_TUNNEL_DESTROY);;
4101   msg.cid = c->id;
4102   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4103               "  sending connection destroy for connection %s[%X]\n",
4104               peer2s (c->t->peer),
4105               c->id);
4106
4107   send_prebuilt_message_connection (&msg.header, c, NULL, GNUNET_YES);
4108   send_prebuilt_message_connection (&msg.header, c, NULL, GNUNET_NO);
4109   c->destroy = GNUNET_YES;
4110 }
4111
4112
4113 /**
4114  * Confirm we got a channel create.
4115  *
4116  * @param ch The channel to confirm.
4117  * @param fwd Should we send the ACK fwd?
4118  */
4119 static void
4120 channel_send_ack (struct MeshChannel *ch, int fwd)
4121 {
4122   struct GNUNET_MESH_ChannelManage msg;
4123
4124   msg.header.size = htons (sizeof (msg));
4125   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_CHANNEL_ACK);
4126   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4127               "  sending channel ack for channel %s:%X\n",
4128               peer2s (ch->t->peer),
4129               ch->gid);
4130
4131   msg.chid = htonl (ch->gid);
4132   send_prebuilt_message_channel (&msg.header, ch, fwd);
4133 }
4134
4135
4136 /**
4137  * Send a message to all clients (local and remote) of this channel
4138  * notifying that the channel is no longer valid.
4139  *
4140  * If some peer or client should not receive the message,
4141  * should be zero'ed out before calling this function.
4142  *
4143  * @param ch The channel whose clients to notify.
4144  */
4145 static void
4146 channel_send_destroy (struct MeshChannel *ch)
4147 {
4148   struct GNUNET_MESH_ChannelManage msg;
4149
4150   msg.header.size = htons (sizeof (msg));
4151   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_CHANNEL_DESTROY);
4152   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4153               "  sending channel destroy for channel %s:%X\n",
4154               peer2s (ch->t->peer),
4155               ch->gid);
4156
4157   if (channel_is_terminal (ch, GNUNET_NO))
4158   {
4159     if (NULL != ch->root)
4160     {
4161       msg.chid = htonl (ch->lid_root);
4162       send_local_channel_destroy (ch, GNUNET_NO);
4163     }
4164   }
4165   else
4166   {
4167     msg.chid = htonl (ch->gid);
4168     send_prebuilt_message_channel (&msg.header, ch, GNUNET_NO);
4169   }
4170
4171   if (channel_is_terminal (ch, GNUNET_YES))
4172   {
4173     if (NULL != ch->dest)
4174     {
4175       msg.chid = htonl (ch->lid_dest);
4176       send_local_channel_destroy (ch, GNUNET_YES);
4177     }
4178   }
4179   else
4180   {
4181     msg.chid = htonl (ch->gid);
4182     send_prebuilt_message_channel (&msg.header, ch, GNUNET_YES);
4183   }
4184 }
4185
4186
4187 /**
4188  * Create a tunnel.
4189  */
4190 static struct MeshTunnel2 *
4191 tunnel_new (void)
4192 {
4193   struct MeshTunnel2 *t;
4194
4195   t = GNUNET_new (struct MeshTunnel2);
4196   t->next_chid = 0;
4197   t->next_local_chid = GNUNET_MESH_LOCAL_CHANNEL_ID_SERV;
4198 //   if (GNUNET_OK !=
4199 //       GNUNET_CONTAINER_multihashmap_put (tunnels, tid, t,
4200 //                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
4201 //   {
4202 //     GNUNET_break (0);
4203 //     tunnel_destroy (t);
4204 //     return NULL;
4205 //   }
4206
4207 //   char salt[] = "salt";
4208 //   GNUNET_CRYPTO_kdf (&t->e_key, sizeof (struct GNUNET_CRYPTO_AesSessionKey),
4209 //                      salt, sizeof (salt),
4210 //                      &t->e_key, sizeof (struct GNUNET_CRYPTO_AesSessionKey),
4211 //                      &my_full_id, sizeof (struct GNUNET_PeerIdentity),
4212 //                      GNUNET_PEER_resolve2 (t->peer->id), sizeof (struct GNUNET_PeerIdentity),
4213 //                      NULL);
4214 //   GNUNET_CRYPTO_kdf (&t->d_key, sizeof (struct GNUNET_CRYPTO_AesSessionKey),
4215 //                      salt, sizeof (salt),
4216 //                      &t->d_key, sizeof (struct GNUNET_CRYPTO_AesSessionKey),
4217 //                      GNUNET_PEER_resolve2 (t->peer->id), sizeof (struct GNUNET_PeerIdentity),
4218 //                      &my_full_id, sizeof (struct GNUNET_PeerIdentity),
4219 //                      NULL);
4220
4221   return t;
4222 }
4223
4224
4225 /**
4226  * Add a connection to a tunnel.
4227  *
4228  * @param t Tunnel.
4229  * @param c Connection.
4230  */
4231 static void
4232 tunnel_add_connection (struct MeshTunnel2 *t, struct MeshConnection *c)
4233 {
4234   c->t = t;
4235   GNUNET_CONTAINER_DLL_insert_tail (t->connection_head, t->connection_tail, c);
4236 }
4237
4238
4239 /**
4240  * Initialize a Flow Control structure to the initial state.
4241  *
4242  * @param fc Flow Control structure to initialize.
4243  */
4244 static void
4245 fc_init (struct MeshFlowControl *fc)
4246 {
4247   fc->next_pid = 0;
4248   fc->last_pid_sent = (uint32_t) -1; /* Next (expected) = 0 */
4249   fc->last_pid_recv = (uint32_t) -1;
4250   fc->last_ack_sent = (uint32_t) 0;
4251   fc->last_ack_recv = (uint32_t) 0;
4252   fc->poll_task = GNUNET_SCHEDULER_NO_TASK;
4253   fc->poll_time = GNUNET_TIME_UNIT_SECONDS;
4254   fc->queue_n = 0;
4255   fc->queue_max = (max_msgs_queue / max_connections) + 1;
4256 }
4257
4258
4259 static struct MeshConnection *
4260 connection_new (const struct GNUNET_HashCode *cid)
4261 {
4262   struct MeshConnection *c;
4263
4264   c = GNUNET_new (struct MeshConnection);
4265   c->id = *cid;
4266   GNUNET_CONTAINER_multihashmap_put (connections, &c->id, c,
4267                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
4268   fc_init (&c->fwd_fc);
4269   fc_init (&c->bck_fc);
4270   c->fwd_fc.c = c;
4271   c->bck_fc.c = c;
4272
4273   return c;
4274 }
4275
4276
4277 /**
4278  * Find a connection.
4279  *
4280  * @param cid Connection ID.
4281  */
4282 static struct MeshConnection *
4283 connection_get (const struct GNUNET_HashCode *cid)
4284 {
4285   return GNUNET_CONTAINER_multihashmap_get (connections, cid);
4286 }
4287
4288
4289 static void
4290 connection_destroy (struct MeshConnection *c)
4291 {
4292   struct MeshPeer *peer;
4293
4294   if (NULL == c)
4295     return;
4296
4297   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "destroying connection %s[%X]\n",
4298               peer2s (c->t->peer),
4299               c->id);
4300
4301   /* Cancel all traffic */
4302   connection_cancel_queues (c, GNUNET_YES);
4303   connection_cancel_queues (c, GNUNET_NO);
4304
4305   /* Cancel maintainance task (keepalive/timeout) */
4306   if (GNUNET_SCHEDULER_NO_TASK != c->fwd_maintenance_task)
4307     GNUNET_SCHEDULER_cancel (c->fwd_maintenance_task);
4308   if (GNUNET_SCHEDULER_NO_TASK != c->bck_maintenance_task)
4309     GNUNET_SCHEDULER_cancel (c->bck_maintenance_task);
4310
4311   /* Deregister from neighbors */
4312   peer = connection_get_next_hop (c);
4313   if (NULL != peer)
4314     GNUNET_CONTAINER_multihashmap_remove (peer->connections, &c->id, c);
4315   peer = connection_get_prev_hop (c);
4316   if (NULL != peer)
4317     GNUNET_CONTAINER_multihashmap_remove (peer->connections, &c->id, c);
4318
4319   /* Delete */
4320   GNUNET_STATISTICS_update (stats, "# connections", -1, GNUNET_NO);
4321   GNUNET_CONTAINER_DLL_remove (c->t->connection_head, c->t->connection_tail, c);
4322   GNUNET_free (c);
4323 }
4324
4325
4326 static void
4327 tunnel_destroy (struct MeshTunnel2 *t)
4328 {
4329   struct MeshConnection *c;
4330   struct MeshConnection *next;
4331
4332   if (NULL == t)
4333     return;
4334
4335   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "destroying tunnel %s\n",
4336               peer2s (t->peer));
4337
4338 //   if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove (tunnels, &t->id, t))
4339 //     GNUNET_break (0);
4340
4341   for (c = t->connection_head; NULL != c; c = next)
4342   {
4343     next = c->next;
4344     connection_destroy (c);
4345   }
4346
4347   GNUNET_STATISTICS_update (stats, "# tunnels", -1, GNUNET_NO);
4348
4349   GNUNET_free (t);
4350 }
4351
4352
4353 /**
4354  * Tunnel is empty: destroy it.
4355  *
4356  * Notifies all connections about the destruction.
4357  *
4358  * @param t Tunnel to destroy.
4359  */
4360 static void
4361 tunnel_destroy_empty (struct MeshTunnel2 *t)
4362 {
4363   struct MeshConnection *c;
4364
4365   for (c = t->connection_head; NULL != c; c = c->next)
4366   {
4367     if (GNUNET_NO == c->destroy)
4368       connection_send_destroy (c);
4369   }
4370
4371   if (0 == t->pending_messages)
4372     tunnel_destroy (t);
4373   else
4374     t->destroy = GNUNET_YES;
4375 }
4376
4377
4378 /**
4379  * Destroy tunnel if empty (no more channels).
4380  *
4381  * @param t Tunnel to destroy if empty.
4382  */
4383 static void
4384 tunnel_destroy_if_empty (struct MeshTunnel2 *t)
4385 {
4386   if (NULL != t->channel_head)
4387     return;
4388
4389   tunnel_destroy_empty (t);
4390 }
4391
4392
4393 /**
4394  * Destroy a channel and free all resources.
4395  *
4396  * @param ch Channel to destroy.
4397  */
4398 static void
4399 channel_destroy (struct MeshChannel *ch)
4400 {
4401   struct MeshClient *c;
4402
4403   if (NULL == ch)
4404     return;
4405
4406   c = ch->root;
4407   if (NULL != c)
4408   {
4409     if (GNUNET_YES != GNUNET_CONTAINER_multihashmap32_remove (c->own_channels,
4410                                                               ch->lid_root, ch))
4411     {
4412       GNUNET_break (0);
4413     }
4414   }
4415
4416   c = ch->dest;
4417   if (NULL != c)
4418   {
4419     if (GNUNET_YES !=
4420         GNUNET_CONTAINER_multihashmap32_remove (c->incoming_channels,
4421                                                 ch->lid_dest, ch))
4422     {
4423       GNUNET_break (0);
4424     }
4425   }
4426
4427   channel_rel_free_all (ch->root_rel);
4428   channel_rel_free_all (ch->dest_rel);
4429
4430   GNUNET_CONTAINER_DLL_remove (ch->t->channel_head, ch->t->channel_tail, ch);
4431   GNUNET_STATISTICS_update (stats, "# channels", -1, GNUNET_NO);
4432
4433   GNUNET_free (ch);
4434 }
4435
4436 /**
4437  * Create a new channel.
4438  *
4439  * @param t Tunnel this channel is in.
4440  * @param owner Client that owns the channel, NULL for foreign channels.
4441  * @param lid_root Local ID for root client.
4442  *
4443  * @return A new initialized channel. NULL on error.
4444  */
4445 static struct MeshChannel *
4446 channel_new (struct MeshTunnel2 *t,
4447              struct MeshClient *owner, MESH_ChannelNumber lid_root)
4448 {
4449   struct MeshChannel *ch;
4450
4451   ch = GNUNET_new (struct MeshChannel);
4452   ch->root = owner;
4453   ch->lid_root = lid_root;
4454   ch->t = t;
4455
4456   GNUNET_CONTAINER_DLL_insert (t->channel_head, t->channel_tail, ch);
4457
4458   GNUNET_STATISTICS_update (stats, "# channels", 1, GNUNET_NO);
4459
4460   if (NULL != owner)
4461   {
4462     while (NULL != channel_get (t, t->next_chid))
4463       t->next_chid = (t->next_chid + 1) & ~GNUNET_MESH_LOCAL_CHANNEL_ID_CLI;
4464     ch->gid = t->next_chid;
4465     t->next_chid = (t->next_chid + 1) & ~GNUNET_MESH_LOCAL_CHANNEL_ID_CLI;
4466
4467     if(GNUNET_OK !=
4468        GNUNET_CONTAINER_multihashmap32_put (owner->own_channels, lid_root, ch,
4469                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
4470     {
4471       GNUNET_break (0);
4472       channel_destroy (ch);
4473       GNUNET_SERVER_receive_done (owner->handle, GNUNET_SYSERR);
4474       return NULL;
4475     }
4476   }
4477
4478   return ch;
4479 }
4480
4481
4482 /**
4483  * Set options in a channel, extracted from a bit flag field
4484  *
4485  * @param ch Channel to set options to.
4486  * @param options Bit array in host byte order.
4487  */
4488 static void
4489 channel_set_options (struct MeshChannel *ch, uint32_t options)
4490 {
4491   ch->nobuffer = (options & GNUNET_MESH_OPTION_NOBUFFER) != 0 ?
4492                  GNUNET_YES : GNUNET_NO;
4493   ch->reliable = (options & GNUNET_MESH_OPTION_RELIABLE) != 0 ?
4494                  GNUNET_YES : GNUNET_NO;
4495 }
4496
4497
4498 /**
4499  * Iterator for deleting each channel whose client endpoint disconnected.
4500  *
4501  * @param cls Closure (client that has disconnected).
4502  * @param key The local channel id (used to access the hashmap).
4503  * @param value The value stored at the key (channel to destroy).
4504  *
4505  * @return GNUNET_OK, keep iterating.
4506  */
4507 static int
4508 channel_destroy_iterator (void *cls,
4509                           uint32_t key,
4510                           void *value)
4511 {
4512   struct MeshChannel *ch = value;
4513   struct MeshClient *c = cls;
4514   struct MeshTunnel2 *t;
4515
4516   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4517               " Channel %X (%X / %X) destroy, due to client %u shutdown.\n",
4518               ch->gid, ch->lid_root, ch->lid_dest, c->id);
4519
4520   if (c == ch->dest)
4521   {
4522     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " Client %u is destination.\n", c->id);
4523     ch->dest = NULL;
4524   }
4525   if (c == ch->root)
4526   {
4527     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " Client %u is owner.\n", c->id);
4528     ch->root = NULL;
4529   }
4530
4531   t = ch->t;
4532   channel_send_destroy (ch);
4533   channel_destroy (ch);
4534   tunnel_destroy_if_empty (t);
4535
4536   return GNUNET_OK;
4537 }
4538
4539
4540 /**
4541  * Remove client's ports from the global hashmap on disconnect.
4542  *
4543  * @param cls Closure (unused).
4544  * @param key Port.
4545  * @param value Client structure.
4546  *
4547  * @return GNUNET_OK, keep iterating.
4548  */
4549 static int
4550 client_release_ports (void *cls,
4551                       uint32_t key,
4552                       void *value)
4553 {
4554   int res;
4555
4556   res = GNUNET_CONTAINER_multihashmap32_remove (ports, key, value);
4557   if (GNUNET_YES != res)
4558   {
4559     GNUNET_break (0);
4560     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
4561                 "Port %u by client %p was not registered.\n",
4562                 key, value);
4563   }
4564   return GNUNET_OK;
4565 }
4566
4567
4568 /**
4569  * Timeout function due to lack of keepalive/traffic from the owner.
4570  * Destroys connection if called.
4571  *
4572  * @param cls Closure (connection to destroy).
4573  * @param tc TaskContext.
4574  */
4575 static void
4576 connection_fwd_timeout (void *cls,
4577                         const struct GNUNET_SCHEDULER_TaskContext *tc)
4578 {
4579   struct MeshConnection *c = cls;
4580
4581   c->fwd_maintenance_task = GNUNET_SCHEDULER_NO_TASK;
4582   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
4583     return;
4584   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4585               "Connection %s[%X] FWD timed out. Destroying.\n",
4586               peer2s (c->t->peer),
4587               c->id);
4588
4589   if (connection_is_origin (c, GNUNET_YES)) /* If local, leave. */
4590     return;
4591
4592   connection_destroy (c);
4593 }
4594
4595
4596 /**
4597  * Timeout function due to lack of keepalive/traffic from the destination.
4598  * Destroys connection if called.
4599  *
4600  * @param cls Closure (connection to destroy).
4601  * @param tc TaskContext
4602  */
4603 static void
4604 connection_bck_timeout (void *cls,
4605                         const struct GNUNET_SCHEDULER_TaskContext *tc)
4606 {
4607   struct MeshConnection *c = cls;
4608
4609   c->bck_maintenance_task = GNUNET_SCHEDULER_NO_TASK;
4610   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
4611     return;
4612
4613   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4614               "Connection %s[%X] FWD timed out. Destroying.\n",
4615               peer2s (c->t->peer),
4616               c->id);
4617
4618   if (connection_is_origin (c, GNUNET_NO)) /* If local, leave. */
4619     return;
4620
4621   connection_destroy (c);
4622 }
4623
4624
4625 /**
4626  * Resets the connection timeout task, some other message has done the
4627  * task's job.
4628  * - For the first peer on the direction this means to send
4629  *   a keepalive or a path confirmation message (either create or ACK).
4630  * - For all other peers, this means to destroy the connection,
4631  *   due to lack of activity.
4632  * Starts the tiemout if no timeout was running (connection just created).
4633  *
4634  * @param c Connection whose timeout to reset.
4635  * @param fwd Is this forward?
4636  *
4637  * TODO use heap to improve efficiency of scheduler.
4638  */
4639 static void
4640 connection_reset_timeout (struct MeshConnection *c, int fwd)
4641 {
4642   GNUNET_SCHEDULER_TaskIdentifier *ti;
4643   GNUNET_SCHEDULER_Task f;
4644
4645   ti = fwd ? &c->fwd_maintenance_task : &c->bck_maintenance_task;
4646
4647   if (GNUNET_SCHEDULER_NO_TASK != *ti)
4648     GNUNET_SCHEDULER_cancel (*ti);
4649
4650   if (connection_is_origin (c, fwd)) /* Endpoint */
4651   {
4652     f  = fwd ? &connection_fwd_keepalive : &connection_bck_keepalive;
4653     *ti = GNUNET_SCHEDULER_add_delayed (refresh_connection_time, f, c);
4654   }
4655   else /* Relay */
4656   {
4657     struct GNUNET_TIME_Relative delay;
4658
4659     delay = GNUNET_TIME_relative_multiply (refresh_connection_time, 4);
4660     f  = fwd ? &connection_fwd_timeout : &connection_bck_timeout;
4661     *ti = GNUNET_SCHEDULER_add_delayed (delay, f, c);
4662   }
4663 }
4664
4665
4666 /**
4667  * Iterator to notify all connections of a broken link. Mark connections
4668  * to destroy after all traffic has been sent.
4669  *
4670  * @param cls Closure (peer disconnected).
4671  * @param key Current key code (tid).
4672  * @param value Value in the hash map (connection).
4673  *
4674  * @return GNUNET_YES if we should continue to iterate,
4675  *         GNUNET_NO if not.
4676  */
4677 static int
4678 connection_broken (void *cls,
4679                    const struct GNUNET_HashCode *key,
4680                    void *value)
4681 {
4682   struct MeshPeer *peer = cls;
4683   struct MeshConnection *c = value;
4684   struct GNUNET_MESH_ConnectionBroken msg;
4685   int fwd;
4686
4687   fwd = peer == connection_get_prev_hop (c);
4688   connection_cancel_queues (c, !fwd);
4689
4690   msg.header.size = htons (sizeof (struct GNUNET_MESH_ConnectionBroken));
4691   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_CONNECTION_BROKEN);
4692   msg.cid = c->id;
4693   msg.peer1 = my_full_id;
4694   msg.peer2 = *GNUNET_PEER_resolve2 (peer->id);
4695   send_prebuilt_message_connection (&msg.header, c, NULL, fwd);
4696   c->destroy = GNUNET_YES;
4697
4698   return GNUNET_YES;
4699 }
4700
4701 /******************************************************************************/
4702 /****************      MESH NETWORK HANDLER HELPERS     ***********************/
4703 /******************************************************************************/
4704
4705 /**
4706  * Free a transmission that was already queued with all resources
4707  * associated to the request.
4708  *
4709  * @param queue Queue handler to cancel.
4710  * @param clear_cls Is it necessary to free associated cls?
4711  */
4712 static void
4713 queue_destroy (struct MeshPeerQueue *queue, int clear_cls)
4714 {
4715   struct MeshPeer *peer;
4716   struct MeshFlowControl *fc;
4717   int fwd;
4718
4719   fwd = queue->fwd;
4720   peer = queue->peer;
4721   GNUNET_assert (NULL != queue->c);
4722   fc = fwd ? &queue->c->fwd_fc : &queue->c->bck_fc;
4723
4724   if (GNUNET_YES == clear_cls)
4725   {
4726     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   queue destroy type %s\n",
4727                 GNUNET_MESH_DEBUG_M2S (queue->type));
4728     switch (queue->type)
4729     {
4730       case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_DESTROY:
4731       case GNUNET_MESSAGE_TYPE_MESH_TUNNEL_DESTROY:
4732         GNUNET_log (GNUNET_ERROR_TYPE_INFO, "destroying a DESTROY message\n");
4733         GNUNET_break (GNUNET_YES == queue->c->destroy);
4734         /* fall through */
4735       case GNUNET_MESSAGE_TYPE_MESH_FWD:
4736       case GNUNET_MESSAGE_TYPE_MESH_BCK:
4737       case GNUNET_MESSAGE_TYPE_MESH_ACK:
4738       case GNUNET_MESSAGE_TYPE_MESH_POLL:
4739       case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_ACK:
4740       case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_CREATE:
4741         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   prebuilt message\n");;
4742         GNUNET_free_non_null (queue->cls);
4743         break;
4744
4745       default:
4746         GNUNET_break (0);
4747         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "   type %s unknown!\n",
4748                     GNUNET_MESH_DEBUG_M2S (queue->type));
4749     }
4750
4751   }
4752   GNUNET_CONTAINER_DLL_remove (peer->queue_head, peer->queue_tail, queue);
4753
4754   if (queue->type != GNUNET_MESSAGE_TYPE_MESH_ACK &&
4755       queue->type != GNUNET_MESSAGE_TYPE_MESH_POLL)
4756   {
4757     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  Q_N- %p %u, \n", fc, fc->queue_n);
4758     fc->queue_n--;
4759     peer->queue_n--;
4760   }
4761   if (NULL != queue->c)
4762   {
4763     queue->c->pending_messages--;
4764     if (NULL != queue->c->t)
4765     {
4766       queue->c->t->pending_messages--;
4767     }
4768   }
4769
4770   GNUNET_free (queue);
4771 }
4772
4773
4774 static size_t
4775 queue_send (void *cls, size_t size, void *buf)
4776 {
4777   struct MeshPeer *peer = cls;
4778   struct MeshFlowControl *fc;
4779   struct MeshConnection *c;
4780   struct GNUNET_MessageHeader *msg;
4781   struct MeshPeerQueue *queue;
4782   struct MeshTunnel2 *t;
4783   struct MeshChannel *ch;
4784   const struct GNUNET_PeerIdentity *dst_id;
4785   size_t data_size;
4786   uint32_t pid;
4787   uint16_t type;
4788   int fwd;
4789
4790   peer->core_transmit = NULL;
4791   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* Queue send (max %u)\n", size);
4792
4793   if (NULL == buf || 0 == size)
4794   {
4795     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* Buffer size 0.\n");
4796     return 0;
4797   }
4798
4799   /* Initialize */
4800   queue = peer_get_first_message (peer);
4801   if (NULL == queue)
4802   {
4803     GNUNET_break (0); /* Core tmt_rdy should've been canceled */
4804     return 0;
4805   }
4806   c = queue->c;
4807   fwd = queue->fwd;
4808   fc = fwd ? &c->fwd_fc : &c->bck_fc;
4809
4810
4811   dst_id = GNUNET_PEER_resolve2 (peer->id);
4812   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "*   towards %s\n", GNUNET_i2s (dst_id));
4813   /* Check if buffer size is enough for the message */
4814   if (queue->size > size)
4815   {
4816       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "*   not enough room, reissue\n");
4817       peer->core_transmit =
4818           GNUNET_CORE_notify_transmit_ready (core_handle,
4819                                              GNUNET_NO,
4820                                              0,
4821                                              GNUNET_TIME_UNIT_FOREVER_REL,
4822                                              dst_id,
4823                                              queue->size,
4824                                              &queue_send,
4825                                              peer);
4826       return 0;
4827   }
4828   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "*   size %u ok\n", queue->size);
4829
4830   t = (NULL != c) ? c->t : NULL;
4831   type = 0;
4832
4833   /* Fill buf */
4834   switch (queue->type)
4835   {
4836     case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_DESTROY:
4837     case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_BROKEN:
4838     case GNUNET_MESSAGE_TYPE_MESH_FWD:
4839     case GNUNET_MESSAGE_TYPE_MESH_BCK:
4840     case GNUNET_MESSAGE_TYPE_MESH_ACK:
4841     case GNUNET_MESSAGE_TYPE_MESH_POLL:
4842       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4843                   "*   raw: %s\n",
4844                   GNUNET_MESH_DEBUG_M2S (queue->type));
4845       data_size = send_core_data_raw (queue->cls, size, buf);
4846       msg = (struct GNUNET_MessageHeader *) buf;
4847       type = ntohs (msg->type);
4848       break;
4849     case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_CREATE:
4850       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "*   path create\n");
4851       if (connection_is_origin (c, GNUNET_YES))
4852         data_size = send_core_connection_create (queue->c, size, buf);
4853       else
4854         data_size = send_core_data_raw (queue->cls, size, buf);
4855       break;
4856     case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_ACK:
4857       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "*   path ack\n");
4858       if (connection_is_origin (c, GNUNET_NO))
4859         data_size = send_core_connection_ack (queue->c, size, buf);
4860       else
4861         data_size = send_core_data_raw (queue->cls, size, buf);
4862       break;
4863     case GNUNET_MESSAGE_TYPE_MESH_DATA:
4864     case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_CREATE:
4865     case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_DESTROY:
4866       /* This should be encapsulted */
4867       GNUNET_break (0);
4868       break;
4869     default:
4870       GNUNET_break (0);
4871       GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "*   type unknown: %u\n",
4872                   queue->type);
4873       data_size = 0;
4874   }
4875
4876   if (0 < drop_percent &&
4877       GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 101) < drop_percent)
4878   {
4879     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
4880                 "Dropping message of type %s\n",
4881                 GNUNET_MESH_DEBUG_M2S (queue->type));
4882     data_size = 0;
4883   }
4884
4885   /* Free queue, but cls was freed by send_core_* */
4886   ch = queue->ch;
4887   queue_destroy (queue, GNUNET_NO);
4888
4889   /* Send ACK if needed, after accounting for sent ID in fc->queue_n */
4890   switch (type)
4891   {
4892     case GNUNET_MESSAGE_TYPE_MESH_FWD:
4893     case GNUNET_MESSAGE_TYPE_MESH_BCK:
4894       pid = ntohl ( ((struct GNUNET_MESH_Encrypted *) buf)->pid );
4895       fc->last_pid_sent = pid;
4896       send_ack (c, ch, fwd);
4897       break;
4898     default:
4899       break;
4900   }
4901
4902   /* If more data in queue, send next */
4903   queue = peer_get_first_message (peer);
4904   if (NULL != queue)
4905   {
4906     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "*   more data!\n");
4907     if (NULL == peer->core_transmit) {
4908       peer->core_transmit =
4909           GNUNET_CORE_notify_transmit_ready(core_handle,
4910                                             0,
4911                                             0,
4912                                             GNUNET_TIME_UNIT_FOREVER_REL,
4913                                             dst_id,
4914                                             queue->size,
4915                                             &queue_send,
4916                                             peer);
4917     }
4918     else
4919     {
4920       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4921                   "*   tmt rdy called somewhere else\n");
4922     }
4923     if (GNUNET_SCHEDULER_NO_TASK == fc->poll_task)
4924     {
4925       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "*   starting poll timeout\n");
4926       fc->poll_task =
4927           GNUNET_SCHEDULER_add_delayed (fc->poll_time, &connection_poll, fc);
4928     }
4929   }
4930   else
4931   {
4932     if (GNUNET_SCHEDULER_NO_TASK != fc->poll_task)
4933     {
4934       GNUNET_SCHEDULER_cancel (fc->poll_task);
4935       fc->poll_task = GNUNET_SCHEDULER_NO_TASK;
4936     }
4937   }
4938   if (NULL != c)
4939   {
4940     c->pending_messages--;
4941     if (GNUNET_YES == c->destroy && 0 == c->pending_messages)
4942     {
4943       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "*  destroying connection!\n");
4944       connection_destroy (c);
4945     }
4946   }
4947
4948   if (NULL != t)
4949   {
4950     t->pending_messages--;
4951     if (GNUNET_YES == t->destroy && 0 == t->pending_messages)
4952     {
4953 //       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "*  destroying tunnel!\n");
4954       tunnel_destroy (t);
4955     }
4956   }
4957   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "*  Return %d\n", data_size);
4958   return data_size;
4959 }
4960
4961
4962 static void
4963 queue_add (void *cls, uint16_t type, size_t size,
4964            struct MeshConnection *c,
4965            struct MeshChannel *ch,
4966            int fwd)
4967 {
4968   struct MeshPeerQueue *queue;
4969   struct MeshFlowControl *fc;
4970   struct MeshPeer *peer;
4971   int priority;
4972
4973   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4974               "queue add %s %s (%u) on c %p, ch %p\n",
4975               fwd ? "FWD" : "BCK",  GNUNET_MESH_DEBUG_M2S (type), size, c, ch);
4976   GNUNET_assert (NULL != c);
4977
4978   fc   = fwd ? &c->fwd_fc : &c->bck_fc;
4979   peer = fwd ? connection_get_next_hop (c) : connection_get_prev_hop (c);
4980
4981   if (NULL == fc)
4982   {
4983     GNUNET_break (0);
4984     return;
4985   }
4986
4987   priority = 0;
4988
4989   if (GNUNET_MESSAGE_TYPE_MESH_POLL == type ||
4990       GNUNET_MESSAGE_TYPE_MESH_ACK == type)
4991   {
4992     priority = 100;
4993   }
4994
4995   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "priority %d\n", priority);
4996   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "fc %p\n", fc);
4997   if (fc->queue_n >= fc->queue_max && 0 == priority)
4998   {
4999     GNUNET_STATISTICS_update (stats, "# messages dropped (buffer full)",
5000                               1, GNUNET_NO);
5001     GNUNET_break (0);
5002     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5003                 "queue full: %u/%u\n",
5004                 fc->queue_n, fc->queue_max);
5005     return; /* Drop this message */
5006   }
5007
5008   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "last pid %u\n", fc->last_pid_sent);
5009   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "     ack %u\n", fc->last_ack_recv);
5010   if (GMC_is_pid_bigger (fc->last_pid_sent + 1, fc->last_ack_recv) &&
5011       GNUNET_SCHEDULER_NO_TASK == fc->poll_task &&
5012       GNUNET_MESSAGE_TYPE_MESH_POLL != type)
5013   {
5014     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5015                 "no buffer space (%u > %u): starting poll\n",
5016                 fc->last_pid_sent + 1, fc->last_ack_recv);
5017     fc->poll_task = GNUNET_SCHEDULER_add_delayed (fc->poll_time,
5018                                                   &connection_poll,
5019                                                   fc);
5020   }
5021   queue = GNUNET_malloc (sizeof (struct MeshPeerQueue));
5022   queue->cls = cls;
5023   queue->type = type;
5024   queue->size = size;
5025   queue->peer = peer;
5026   queue->c = c;
5027   queue->ch = ch;
5028   queue->fwd = fwd;
5029   if (100 <= priority)
5030   {
5031     GNUNET_CONTAINER_DLL_insert (peer->queue_head, peer->queue_tail, queue);
5032   }
5033   else
5034   {
5035     GNUNET_CONTAINER_DLL_insert_tail (peer->queue_head, peer->queue_tail, queue);
5036     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  Q_N+ %p %u, \n", fc, fc->queue_n);
5037     fc->queue_n++;
5038     peer->queue_n++;
5039   }
5040
5041   if (NULL == peer->core_transmit)
5042   {
5043     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5044                 "calling core tmt rdy towards %s for %u bytes\n",
5045                 peer2s (peer), size);
5046     peer->core_transmit =
5047         GNUNET_CORE_notify_transmit_ready (core_handle,
5048                                            0,
5049                                            0,
5050                                            GNUNET_TIME_UNIT_FOREVER_REL,
5051                                            GNUNET_PEER_resolve2 (peer->id),
5052                                            size,
5053                                            &queue_send,
5054                                            peer);
5055   }
5056   else
5057   {
5058     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5059                 "core tmt rdy towards %s already called\n",
5060                 peer2s (peer));
5061
5062   }
5063   c->pending_messages++;
5064   c->t->pending_messages++;
5065 }
5066
5067
5068 /******************************************************************************/
5069 /********************      MESH NETWORK HANDLERS     **************************/
5070 /******************************************************************************/
5071
5072
5073 /**
5074  * Generic handler for mesh network payload traffic.
5075  *
5076  * @param t Tunnel on which we got this message.
5077  * @param message Unencryted data message.
5078  * @param fwd Is this FWD traffic? GNUNET_YES : GNUNET_NO;
5079  */
5080 static void
5081 handle_data (struct MeshTunnel2 *t, const struct GNUNET_MESH_Data *msg, int fwd)
5082 {
5083   struct MeshChannelReliability *rel;
5084   struct MeshChannel *ch;
5085   struct MeshClient *c;
5086   uint32_t mid;
5087   uint16_t type;
5088   size_t size;
5089
5090   /* Check size */
5091   size = ntohs (msg->header.size);
5092   if (size <
5093       sizeof (struct GNUNET_MESH_Data) +
5094       sizeof (struct GNUNET_MessageHeader))
5095   {
5096     GNUNET_break (0);
5097     return;
5098   }
5099   type = ntohs (msg->header.type);
5100   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "got a %s message\n",
5101               GNUNET_MESH_DEBUG_M2S (type));
5102   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " payload of type %s\n",
5103               GNUNET_MESH_DEBUG_M2S (ntohs (msg[1].header.type)));
5104
5105   /* Check channel */
5106   ch = channel_get (t, ntohl (msg->chid));
5107   if (NULL == ch)
5108   {
5109     GNUNET_STATISTICS_update (stats, "# data on unknown channel", 1, GNUNET_NO);
5110     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "WARNING channel unknown\n");
5111     return;
5112   }
5113
5114   /*  Initialize FWD/BCK data */
5115   c        = fwd ? ch->dest     : ch->root;
5116   rel      = fwd ? ch->dest_rel : ch->root_rel;
5117
5118   if (NULL == c)
5119   {
5120     GNUNET_break (0);
5121     return;
5122   }
5123
5124   tunnel_change_state (t, MESH_TUNNEL_READY);
5125
5126   GNUNET_STATISTICS_update (stats, "# data received", 1, GNUNET_NO);
5127
5128   mid = ntohl (msg->mid);
5129   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " mid %u\n", mid);
5130
5131   if (GNUNET_NO == ch->reliable ||
5132       ( !GMC_is_pid_bigger (rel->mid_recv, mid) &&
5133         GMC_is_pid_bigger (rel->mid_recv + 64, mid) ) )
5134   {
5135     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "!!! RECV %u\n", mid);
5136     if (GNUNET_YES == ch->reliable)
5137     {
5138       /* Is this the exact next expected messasge? */
5139       if (mid == rel->mid_recv)
5140       {
5141         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "as expected\n");
5142         rel->mid_recv++;
5143         channel_send_client_data (ch, msg, fwd);
5144       }
5145       else
5146       {
5147         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "save for later\n");
5148         channel_rel_add_buffered_data (msg, rel);
5149       }
5150     }
5151     else
5152     {
5153       /* Tunnel is unreliable: send to clients directly */
5154       /* FIXME: accept Out Of Order traffic */
5155       rel->mid_recv = mid + 1;
5156       channel_send_client_data (ch, msg, fwd);
5157     }
5158   }
5159   else
5160   {
5161     GNUNET_break_op (0);
5162     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5163                 " MID %u not expected (%u - %u), dropping!\n",
5164                 mid, rel->mid_recv, rel->mid_recv + 64);
5165   }
5166
5167   channel_send_data_ack (ch, fwd);
5168 }
5169
5170 /**
5171  * Handler for mesh network traffic end-to-end ACKs.
5172  *
5173  * @param t Tunnel on which we got this message.
5174  * @param message Data message.
5175  * @param fwd Is this a fwd ACK? (dest->orig)
5176  */
5177 static void
5178 handle_data_ack (struct MeshTunnel2 *t,
5179                  const struct GNUNET_MESH_DataACK *msg, int fwd)
5180 {
5181   struct MeshChannelReliability *rel;
5182   struct MeshReliableMessage *copy;
5183   struct MeshReliableMessage *next;
5184   struct MeshChannel *ch;
5185   uint32_t ack;
5186   uint16_t type;
5187   int work;
5188
5189   type = ntohs (msg->header.type);
5190   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got a %s message!\n",
5191               GNUNET_MESH_DEBUG_M2S (type));
5192   ch = channel_get (t, ntohl (msg->chid));
5193   if (NULL == ch)
5194   {
5195     GNUNET_STATISTICS_update (stats, "# ack on unknown channel", 1, GNUNET_NO);
5196     return;
5197   }
5198   ack = ntohl (msg->mid);
5199   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "!!! %s ACK %u\n",
5200               (GNUNET_YES == fwd) ? "FWD" : "BCK", ack);
5201
5202   if (GNUNET_YES == fwd)
5203   {
5204     rel = ch->root_rel;
5205   }
5206   else
5207   {
5208     rel = ch->dest_rel;
5209   }
5210   if (NULL == rel)
5211   {
5212     GNUNET_break (0);
5213     return;
5214   }
5215
5216   for (work = GNUNET_NO, copy = rel->head_sent; copy != NULL; copy = next)
5217   {
5218     if (GMC_is_pid_bigger (copy->mid, ack))
5219     {
5220       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "!!!  head %u, out!\n", copy->mid);
5221       channel_rel_free_sent (rel, msg);
5222       break;
5223     }
5224     work = GNUNET_YES;
5225     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "!!!  id %u\n", copy->mid);
5226     next = copy->next;
5227     rel_message_free (copy);
5228   }
5229   /* ACK client if needed */
5230 //   channel_send_ack (t, type, GNUNET_MESSAGE_TYPE_MESH_UNICAST_ACK == type);
5231
5232   /* If some message was free'd, update the retransmission delay*/
5233   if (GNUNET_YES == work)
5234   {
5235     if (GNUNET_SCHEDULER_NO_TASK != rel->retry_task)
5236     {
5237       GNUNET_SCHEDULER_cancel (rel->retry_task);
5238       if (NULL == rel->head_sent)
5239       {
5240         rel->retry_task = GNUNET_SCHEDULER_NO_TASK;
5241       }
5242       else
5243       {
5244         struct GNUNET_TIME_Absolute new_target;
5245         struct GNUNET_TIME_Relative delay;
5246
5247         delay = GNUNET_TIME_relative_multiply (rel->retry_timer,
5248                                                MESH_RETRANSMIT_MARGIN);
5249         new_target = GNUNET_TIME_absolute_add (rel->head_sent->timestamp,
5250                                                delay);
5251         delay = GNUNET_TIME_absolute_get_remaining (new_target);
5252         rel->retry_task =
5253             GNUNET_SCHEDULER_add_delayed (delay,
5254                                           &channel_retransmit_message,
5255                                           rel);
5256       }
5257     }
5258     else
5259       GNUNET_break (0);
5260   }
5261 }
5262
5263
5264 /**
5265  * Core handler for connection creation.
5266  *
5267  * @param cls Closure (unused).
5268  * @param peer Sender (neighbor).
5269  * @param message Message.
5270  *
5271  * @return GNUNET_OK to keep the connection open,
5272  *         GNUNET_SYSERR to close it (signal serious error)
5273  */
5274 static int
5275 handle_mesh_connection_create (void *cls,
5276                                const struct GNUNET_PeerIdentity *peer,
5277                                const struct GNUNET_MessageHeader *message)
5278 {
5279   struct GNUNET_MESH_ConnectionCreate *msg;
5280   struct GNUNET_PeerIdentity *id;
5281   struct GNUNET_HashCode *cid;
5282   struct MeshPeerPath *path;
5283   struct MeshPeer *dest_peer;
5284   struct MeshPeer *orig_peer;
5285   struct MeshConnection *c;
5286   unsigned int own_pos;
5287   uint16_t size;
5288   uint16_t i;
5289
5290   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\n\n");
5291   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received a connection create msg\n");
5292
5293   /* Check size */
5294   size = ntohs (message->size);
5295   if (size < sizeof (struct GNUNET_MESH_ConnectionCreate))
5296   {
5297     GNUNET_break_op (0);
5298     return GNUNET_OK;
5299   }
5300
5301   /* Calculate hops */
5302   size -= sizeof (struct GNUNET_MESH_ConnectionCreate);
5303   if (size % sizeof (struct GNUNET_PeerIdentity))
5304   {
5305     GNUNET_break_op (0);
5306     return GNUNET_OK;
5307   }
5308   size /= sizeof (struct GNUNET_PeerIdentity);
5309   if (1 > size)
5310   {
5311     GNUNET_break_op (0);
5312     return GNUNET_OK;
5313   }
5314   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "    path has %u hops.\n", size);
5315
5316   /* Get parameters */
5317   msg = (struct GNUNET_MESH_ConnectionCreate *) message;
5318   cid = &msg->cid;
5319   id = (struct GNUNET_PeerIdentity *) &msg[1];
5320   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5321               "    connection %s (%s).\n",
5322               GNUNET_h2s (cid), GNUNET_i2s (id));
5323
5324   /* Create connection */
5325   c = connection_get (cid);
5326   if (NULL == c)
5327   {
5328     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  Creating connection\n");
5329     c = connection_new (cid);
5330     if (NULL == c)
5331       return GNUNET_OK;
5332   }
5333   connection_reset_timeout (c, GNUNET_YES);
5334   tunnel_change_state (c->t,  MESH_TUNNEL_WAITING);
5335
5336   /* Remember peers */
5337   dest_peer = peer_get (&id[size - 1]);
5338   orig_peer = peer_get (&id[0]);
5339
5340   /* Create path */
5341   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  Creating path...\n");
5342   path = path_new (size);
5343   own_pos = 0;
5344   for (i = 0; i < size; i++)
5345   {
5346     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  ... adding %s\n",
5347                 GNUNET_i2s (&id[i]));
5348     path->peers[i] = GNUNET_PEER_intern (&id[i]);
5349     if (path->peers[i] == myid)
5350       own_pos = i;
5351   }
5352   if (own_pos == 0 && path->peers[own_pos] != myid)
5353   {
5354     /* create path: self not found in path through self */
5355     GNUNET_break_op (0);
5356     path_destroy (path);
5357     connection_destroy (c);
5358     return GNUNET_OK;
5359   }
5360   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  Own position: %u\n", own_pos);
5361   path_add_to_peers (path, GNUNET_NO);
5362   c->path = path_duplicate (path);
5363   c->own_pos = own_pos;
5364
5365   /* Is it a connection to us? */
5366   if (own_pos == size - 1)
5367   {
5368     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  It's for us!\n");
5369     peer_add_path_to_origin (orig_peer, path, GNUNET_YES);
5370
5371     if (NULL == orig_peer->tunnel)
5372       orig_peer->tunnel = tunnel_new ();
5373     tunnel_add_connection (orig_peer->tunnel, c);
5374
5375     send_connection_ack (c, GNUNET_NO);
5376
5377     /* Keep tunnel alive in direction dest->owner*/
5378     connection_reset_timeout (c, GNUNET_NO);
5379   }
5380   else
5381   {
5382     /* It's for somebody else! Retransmit. */
5383     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  Retransmitting.\n");
5384     peer_add_path (dest_peer, path_duplicate (path), GNUNET_NO);
5385     peer_add_path_to_origin (orig_peer, path, GNUNET_NO);
5386     send_prebuilt_message_connection (message, c, NULL, GNUNET_YES);
5387   }
5388   return GNUNET_OK;
5389 }
5390
5391
5392 /**
5393  * Core handler for path ACKs
5394  *
5395  * @param cls closure
5396  * @param message message
5397  * @param peer peer identity this notification is about
5398  *
5399  * @return GNUNET_OK to keep the connection open,
5400  *         GNUNET_SYSERR to close it (signal serious error)
5401  */
5402 static int
5403 handle_mesh_connection_ack (void *cls, const struct GNUNET_PeerIdentity *peer,
5404                             const struct GNUNET_MessageHeader *message)
5405 {
5406   struct GNUNET_MESH_ConnectionACK *msg;
5407   struct MeshPeerPath *p;
5408   struct MeshConnection *c;
5409
5410   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\n\n");
5411   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received a connection ACK msg\n");
5412   msg = (struct GNUNET_MESH_ConnectionACK *) message;
5413   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  on connection %s\n",
5414               GNUNET_h2s (&msg->cid));
5415   c = connection_get (&msg->cid);
5416   if (NULL == c)
5417   {
5418     GNUNET_STATISTICS_update (stats, "# control on unknown connection",
5419                               1, GNUNET_NO);
5420     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  don't know the connection!\n");
5421     return GNUNET_OK;
5422   }
5423
5424   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  via peer %s\n",
5425               GNUNET_i2s (peer));
5426
5427   /* Add path to peers? */
5428   p = c->path;
5429   if (NULL != p)
5430   {
5431     path_add_to_peers (p, GNUNET_YES);
5432   }
5433   else
5434   {
5435     GNUNET_break (0);
5436   }
5437   connection_change_state (c, MESH_CONNECTION_READY);
5438   connection_reset_timeout (c, GNUNET_NO);
5439   if (MESH_TUNNEL_READY != c->t->state)
5440     tunnel_change_state (c->t, MESH_TUNNEL_READY);
5441   tunnel_send_queued_data (c->t, GNUNET_YES);
5442
5443   /* Message for us? */
5444   if (connection_is_terminal (c, GNUNET_NO))
5445   {
5446     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  Connection ACK for us!\n");
5447     if (3 <= tunnel_count_connections (c->t) && NULL != c->t->peer->dhtget)
5448     {
5449       GNUNET_DHT_get_stop (c->t->peer->dhtget);
5450       c->t->peer->dhtget = NULL;
5451     }
5452     //connection_send_ack (c, GNUNET_NO); /* FIXME */
5453     return GNUNET_OK;
5454   }
5455
5456   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  not for us, retransmitting...\n");
5457   send_prebuilt_message_connection (message, c, NULL, GNUNET_NO);
5458   return GNUNET_OK;
5459 }
5460
5461
5462 /**
5463  * Core handler for notifications of broken paths
5464  *
5465  * @param cls Closure (unused).
5466  * @param peer Peer identity of sending neighbor.
5467  * @param message Message.
5468  *
5469  * @return GNUNET_OK to keep the connection open,
5470  *         GNUNET_SYSERR to close it (signal serious error)
5471  */
5472 static int
5473 handle_mesh_connection_broken (void *cls, const struct GNUNET_PeerIdentity *peer,
5474                                const struct GNUNET_MessageHeader *message)
5475 {
5476   struct GNUNET_MESH_ConnectionBroken *msg;
5477   struct MeshConnection *c;
5478
5479   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5480               "Received a CONNECTION BROKEN msg from %s\n", GNUNET_i2s (peer));
5481   msg = (struct GNUNET_MESH_ConnectionBroken *) message;
5482   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  regarding %s\n",
5483               GNUNET_i2s (&msg->peer1));
5484   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  regarding %s\n",
5485               GNUNET_i2s (&msg->peer2));
5486   c = connection_get (&msg->cid);
5487   if (NULL == c)
5488   {
5489     GNUNET_break_op (0);
5490     return GNUNET_OK;
5491   }
5492   tunnel_notify_connection_broken (c->t, GNUNET_PEER_search (&msg->peer1),
5493                                    GNUNET_PEER_search (&msg->peer2));
5494   return GNUNET_OK;
5495
5496 }
5497
5498
5499 /**
5500  * Core handler for tunnel destruction
5501  *
5502  * @param cls Closure (unused).
5503  * @param peer Peer identity of sending neighbor.
5504  * @param message Message.
5505  *
5506  * @return GNUNET_OK to keep the connection open,
5507  *         GNUNET_SYSERR to close it (signal serious error)
5508  */
5509 static int
5510 handle_mesh_connection_destroy (void *cls,
5511                                 const struct GNUNET_PeerIdentity *peer,
5512                                 const struct GNUNET_MessageHeader *message)
5513 {
5514   struct GNUNET_MESH_ConnectionDestroy *msg;
5515   struct MeshConnection *c;
5516   GNUNET_PEER_Id id;
5517   int fwd;
5518
5519   msg = (struct GNUNET_MESH_ConnectionDestroy *) message;
5520   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5521               "Got a CONNECTION DESTROY message from %s\n",
5522               GNUNET_i2s (peer));
5523   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5524               "  for connection %s\n",
5525               GNUNET_h2s (&msg->cid));
5526   c = connection_get (&msg->cid);
5527   if (NULL == c)
5528   {
5529     /* Probably already got the message from another path,
5530      * destroyed the tunnel and retransmitted to children.
5531      * Safe to ignore.
5532      */
5533     GNUNET_STATISTICS_update (stats, "# control on unknown tunnel",
5534                               1, GNUNET_NO);
5535     return GNUNET_OK;
5536   }
5537   id = GNUNET_PEER_search (peer);
5538   if (id == connection_get_prev_hop (c)->id)
5539     fwd = GNUNET_YES;
5540   else if (id == connection_get_next_hop (c)->id)
5541     fwd = GNUNET_NO;
5542   else
5543   {
5544     GNUNET_break_op (0);
5545     return GNUNET_OK;
5546   }
5547   send_prebuilt_message_connection (message, c, NULL, fwd);
5548   c->destroy = GNUNET_YES;
5549
5550   return GNUNET_OK;
5551 }
5552
5553
5554 /**
5555  * Handler for channel create messages.
5556  *
5557  * @param t Tunnel this channel is to be created in.
5558  * @param msg Message.
5559  * @param fwd Is this FWD traffic? GNUNET_YES : GNUNET_NO;
5560  */
5561 static void
5562 handle_channel_create (struct MeshTunnel2 *t,
5563                        struct GNUNET_MESH_ChannelCreate *msg,
5564                        int fwd)
5565 {
5566   MESH_ChannelNumber chid;
5567   struct MeshChannel *ch;
5568   struct MeshClient *c;
5569   uint32_t port;
5570
5571   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received Channel Create\n");
5572   /* Check message size */
5573   if (ntohs (msg->header.size) != sizeof (struct GNUNET_MESH_ChannelCreate))
5574   {
5575     GNUNET_break_op (0);
5576     return;
5577   }
5578
5579   /* Check if channel exists */
5580   chid = ntohl (msg->chid);
5581   ch = channel_get (t, chid);
5582   if (NULL != ch)
5583   {
5584     /* Probably a retransmission, safe to ignore */
5585     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   already exists...\n");
5586     if (NULL != ch->dest)
5587     {
5588       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   duplicate CC!!\n");
5589       channel_send_ack (ch, !fwd);
5590       return;
5591     }
5592   }
5593   else
5594   {
5595     /* Create channel */
5596     ch = channel_new (t, NULL, 0);
5597     channel_set_options (ch, ntohl (msg->opt));
5598   }
5599
5600   /* Find a destination client */
5601   port = ntohl (msg->port);
5602   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   port %u\n", port);
5603   c = GNUNET_CONTAINER_multihashmap32_get (ports, port);
5604   if (NULL == c)
5605   {
5606     /* TODO send reject */
5607     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  no client has port registered\n");
5608     /* TODO free ch */
5609     return;
5610   }
5611
5612   channel_add_client (ch, c);
5613   if (GNUNET_YES == ch->reliable)
5614     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "!!! Reliable\n");
5615
5616   send_local_channel_create (ch);
5617   channel_send_ack (ch, !fwd);
5618   send_local_ack (ch, !fwd);
5619 }
5620
5621
5622 /**
5623  * Handler for channel ack messages.
5624  *
5625  * @param t Tunnel this channel is to be created in.
5626  * @param msg Message.
5627  * @param fwd Is this FWD traffic? GNUNET_YES : GNUNET_NO;
5628  */
5629 static void
5630 handle_channel_ack (struct MeshTunnel2 *t,
5631                     struct GNUNET_MESH_ChannelManage *msg,
5632                     int fwd)
5633 {
5634   MESH_ChannelNumber chid;
5635   struct MeshChannel *ch;
5636
5637   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received Channel ACK\n");
5638   /* Check message size */
5639   if (ntohs (msg->header.size) != sizeof (struct GNUNET_MESH_ChannelManage))
5640   {
5641     GNUNET_break_op (0);
5642     return;
5643   }
5644
5645   /* Check if channel exists */
5646   chid = ntohl (msg->chid);
5647   ch = channel_get (t, chid);
5648   if (NULL == ch)
5649   {
5650     GNUNET_break_op (0);
5651     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   channel %u unknown!!\n", chid);
5652     return;
5653   }
5654
5655   channel_confirm (ch, !fwd);
5656 }
5657
5658
5659 /**
5660  * Handler for channel destroy messages.
5661  *
5662  * @param t Tunnel this channel is to be destroyed of.
5663  * @param msg Message.
5664  * @param fwd Is this FWD traffic? GNUNET_YES : GNUNET_NO;
5665  */
5666 static void
5667 handle_channel_destroy (struct MeshTunnel2 *t,
5668                         struct GNUNET_MESH_ChannelManage *msg,
5669                         int fwd)
5670 {
5671   MESH_ChannelNumber chid;
5672   struct MeshChannel *ch;
5673
5674   /* Check message size */
5675   if (ntohs (msg->header.size) != sizeof (struct GNUNET_MESH_ChannelManage))
5676   {
5677     GNUNET_break_op (0);
5678     return;
5679   }
5680
5681   /* Check if channel exists */
5682   chid = ntohl (msg->chid);
5683   ch = channel_get (t, chid);
5684   if (NULL == ch)
5685   {
5686     /* Probably a retransmission, safe to ignore */
5687     return;
5688   }
5689
5690   send_local_channel_destroy (ch, fwd);
5691   channel_destroy (ch);
5692 }
5693
5694
5695 static void
5696 handle_decrypted (struct MeshTunnel2 *t,
5697                   const struct GNUNET_MessageHeader *msgh,
5698                   int fwd)
5699 {
5700   switch (ntohs (msgh->type))
5701   {
5702     case GNUNET_MESSAGE_TYPE_MESH_DATA:
5703       /* Don't send hop ACK, wait for client to ACK */
5704       handle_data (t, (struct GNUNET_MESH_Data *) msgh, fwd);
5705       break;
5706
5707     case GNUNET_MESSAGE_TYPE_MESH_DATA_ACK:
5708       handle_data_ack (t, (struct GNUNET_MESH_DataACK *) msgh, fwd);
5709       break;
5710
5711     case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_CREATE:
5712       handle_channel_create (t,
5713                              (struct GNUNET_MESH_ChannelCreate *) msgh,
5714                              fwd);
5715       break;
5716
5717     case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_ACK:
5718       handle_channel_ack (t,
5719                           (struct GNUNET_MESH_ChannelManage *) msgh,
5720                           fwd);
5721       break;
5722
5723     case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_DESTROY:
5724       handle_channel_destroy (t,
5725                               (struct GNUNET_MESH_ChannelManage *) msgh,
5726                               fwd);
5727       break;
5728
5729     default:
5730       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5731                   "end-to-end message not known (%u)\n",
5732                   ntohs (msgh->type));
5733   }
5734 }
5735
5736
5737 /**
5738  * Generic handler for mesh network encrypted traffic.
5739  *
5740  * @param peer Peer identity this notification is about.
5741  * @param message Encrypted message.
5742  * @param fwd Is this FWD traffic? GNUNET_YES : GNUNET_NO;
5743  *
5744  * @return GNUNET_OK to keep the connection open,
5745  *         GNUNET_SYSERR to close it (signal serious error)
5746  */
5747 static int
5748 handle_mesh_encrypted (const struct GNUNET_PeerIdentity *peer,
5749                        const struct GNUNET_MESH_Encrypted *msg,
5750                        int fwd)
5751 {
5752   struct MeshConnection *c;
5753   struct MeshTunnel2 *t;
5754   struct MeshPeer *neighbor;
5755   struct MeshFlowControl *fc;
5756   uint32_t pid;
5757   uint32_t ttl;
5758   uint16_t type;
5759   size_t size;
5760
5761   /* Check size */
5762   size = ntohs (msg->header.size);
5763   if (size <
5764       sizeof (struct GNUNET_MESH_Encrypted) +
5765       sizeof (struct GNUNET_MessageHeader))
5766   {
5767     GNUNET_break_op (0);
5768     return GNUNET_OK;
5769   }
5770   type = ntohs (msg->header.type);
5771   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\n\n");
5772   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "got a %s message from %s\n",
5773               GNUNET_MESH_DEBUG_M2S (type), GNUNET_i2s (peer));
5774
5775   /* Check connection */
5776   c = connection_get (&msg->cid);
5777   if (NULL == c)
5778   {
5779     GNUNET_STATISTICS_update (stats, "# unknown connection", 1, GNUNET_NO);
5780     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "WARNING connection unknown\n");
5781     return GNUNET_OK;
5782   }
5783   t = c->t;
5784   fc = fwd ? &c->fwd_fc : &c->bck_fc;
5785
5786   /* Check if origin is as expected */
5787   neighbor = connection_get_hop (c, fwd);
5788   if (peer_get (peer)->id != neighbor->id)
5789   {
5790     GNUNET_break_op (0);
5791     return GNUNET_OK;
5792   }
5793
5794   /* Check PID */
5795   pid = ntohl (msg->pid);
5796   if (GMC_is_pid_bigger (pid, fc->last_ack_sent))
5797   {
5798     GNUNET_STATISTICS_update (stats, "# unsolicited message", 1, GNUNET_NO);
5799     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5800                 "WARNING Received PID %u, (prev %u), ACK %u\n",
5801                 pid, fc->last_pid_recv, fc->last_ack_sent);
5802     return GNUNET_OK;
5803   }
5804   if (GNUNET_NO == GMC_is_pid_bigger (pid, fc->last_pid_recv))
5805   {
5806     GNUNET_STATISTICS_update (stats, "# duplicate PID", 1, GNUNET_NO);
5807     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5808                 " Pid %u not expected (%u+), dropping!\n",
5809                 pid, fc->last_pid_recv + 1);
5810     return GNUNET_OK;
5811   }
5812   if (MESH_CONNECTION_SENT == c->state)
5813     connection_change_state (c, MESH_CONNECTION_READY);
5814   connection_reset_timeout (c, fwd);
5815   fc->last_pid_recv = pid;
5816
5817   /* Is this message for us? */
5818   if (connection_is_terminal (c, fwd))
5819   {
5820     size_t dsize = size - sizeof (struct GNUNET_MESH_Encrypted);
5821     char cbuf[dsize];
5822     struct GNUNET_MessageHeader *msgh;
5823     unsigned int off;
5824
5825     /* TODO signature verification */
5826     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  message for us!\n");
5827     GNUNET_STATISTICS_update (stats, "# messages received", 1, GNUNET_NO);
5828
5829     fc->last_pid_recv = pid;
5830     tunnel_decrypt (t, cbuf, &msg[1], dsize, msg->iv, fwd);
5831     off = 0;
5832     while (off < dsize)
5833     {
5834       msgh = (struct GNUNET_MessageHeader *) &cbuf[off];
5835       handle_decrypted (t, msgh, fwd);
5836       off += ntohs (msgh->size);
5837     }
5838     send_ack (c, NULL, fwd);
5839     return GNUNET_OK;
5840   }
5841
5842   /* Message not for us: forward to next hop */
5843   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  not for us, retransmitting...\n");
5844   ttl = ntohl (msg->ttl);
5845   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   ttl: %u\n", ttl);
5846   if (ttl == 0)
5847   {
5848     GNUNET_STATISTICS_update (stats, "# TTL drops", 1, GNUNET_NO);
5849     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, " TTL is 0, DROPPING!\n");
5850     send_ack (c, NULL, fwd);
5851     return GNUNET_OK;
5852   }
5853   GNUNET_STATISTICS_update (stats, "# messages forwarded", 1, GNUNET_NO);
5854
5855   send_prebuilt_message_connection (&msg->header, c, NULL, fwd);
5856
5857   return GNUNET_OK;
5858 }
5859
5860
5861 /**
5862  * Core handler for mesh network traffic going orig->dest.
5863  *
5864  * @param cls Closure (unused).
5865  * @param message Message received.
5866  * @param peer Peer who sent the message.
5867  *
5868  * @return GNUNET_OK to keep the connection open,
5869  *         GNUNET_SYSERR to close it (signal serious error)
5870  */
5871 static int
5872 handle_mesh_fwd (void *cls, const struct GNUNET_PeerIdentity *peer,
5873                      const struct GNUNET_MessageHeader *message)
5874 {
5875   return handle_mesh_encrypted (peer,
5876                                 (struct GNUNET_MESH_Encrypted *)message,
5877                                 GNUNET_YES);
5878 }
5879
5880 /**
5881  * Core handler for mesh network traffic going dest->orig.
5882  *
5883  * @param cls Closure (unused).
5884  * @param message Message received.
5885  * @param peer Peer who sent the message.
5886  *
5887  * @return GNUNET_OK to keep the connection open,
5888  *         GNUNET_SYSERR to close it (signal serious error)
5889  */
5890 static int
5891 handle_mesh_bck (void *cls, const struct GNUNET_PeerIdentity *peer,
5892                      const struct GNUNET_MessageHeader *message)
5893 {
5894   return handle_mesh_encrypted (peer,
5895                                 (struct GNUNET_MESH_Encrypted *)message,
5896                                 GNUNET_NO);
5897 }
5898
5899
5900 /**
5901  * Core handler for mesh network traffic point-to-point acks.
5902  *
5903  * @param cls closure
5904  * @param message message
5905  * @param peer peer identity this notification is about
5906  *
5907  * @return GNUNET_OK to keep the connection open,
5908  *         GNUNET_SYSERR to close it (signal serious error)
5909  */
5910 static int
5911 handle_mesh_ack (void *cls, const struct GNUNET_PeerIdentity *peer,
5912                  const struct GNUNET_MessageHeader *message)
5913 {
5914   struct GNUNET_MESH_ACK *msg;
5915   struct MeshConnection *c;
5916   struct MeshFlowControl *fc;
5917   GNUNET_PEER_Id id;
5918   uint32_t ack;
5919
5920   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\n\n");
5921   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got an ACK packet from %s!\n",
5922               GNUNET_i2s (peer));
5923   msg = (struct GNUNET_MESH_ACK *) message;
5924
5925   c = connection_get (&msg->cid);
5926
5927   if (NULL == c)
5928   {
5929     GNUNET_STATISTICS_update (stats, "# ack on unknown connection", 1,
5930                               GNUNET_NO);
5931     return GNUNET_OK;
5932   }
5933
5934   /* Is this a forward or backward ACK? */
5935   id = GNUNET_PEER_search (peer);
5936   if (connection_get_next_hop (c)->id == id)
5937   {
5938     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  FWD ACK\n");
5939     fc = &c->fwd_fc;
5940   }
5941   else if (connection_get_prev_hop (c)->id == id)
5942   {
5943     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  BCK ACK\n");
5944     fc = &c->bck_fc;
5945   }
5946   else
5947   {
5948     GNUNET_break_op (0);
5949     return GNUNET_OK;
5950   }
5951
5952   ack = ntohl (msg->ack);
5953   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  ACK %u\n", ack);
5954
5955   /* Cancel polling if the ACK is bigger than before. */
5956   if (GNUNET_SCHEDULER_NO_TASK != fc->poll_task &&
5957       GMC_is_pid_bigger (ack, fc->last_ack_recv))
5958   {
5959     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  Cancel poll\n");
5960     GNUNET_SCHEDULER_cancel (fc->poll_task);
5961     fc->poll_task = GNUNET_SCHEDULER_NO_TASK;
5962     fc->poll_time = GNUNET_TIME_UNIT_SECONDS;
5963   }
5964
5965   fc->last_ack_recv = ack;
5966   connection_unlock_queue (c, fc == &c->fwd_fc);
5967
5968   return GNUNET_OK;
5969 }
5970
5971
5972 /**
5973  * Core handler for mesh network traffic point-to-point ack polls.
5974  *
5975  * @param cls closure
5976  * @param message message
5977  * @param peer peer identity this notification is about
5978  *
5979  * @return GNUNET_OK to keep the connection open,
5980  *         GNUNET_SYSERR to close it (signal serious error)
5981  */
5982 static int
5983 handle_mesh_poll (void *cls, const struct GNUNET_PeerIdentity *peer,
5984                   const struct GNUNET_MessageHeader *message)
5985 {
5986   struct GNUNET_MESH_Poll *msg;
5987   struct MeshConnection *c;
5988   struct MeshFlowControl *fc;
5989   GNUNET_PEER_Id id;
5990   uint32_t pid;
5991   int fwd;
5992
5993   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\n\n");
5994   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got a POLL packet from %s!\n",
5995               GNUNET_i2s (peer));
5996
5997   msg = (struct GNUNET_MESH_Poll *) message;
5998
5999   c = connection_get (&msg->cid);
6000
6001   if (NULL == c)
6002   {
6003     GNUNET_STATISTICS_update (stats, "# poll on unknown connection", 1,
6004                               GNUNET_NO);
6005     GNUNET_break_op (0);
6006     return GNUNET_OK;
6007   }
6008
6009   /* Is this a forward or backward ACK?
6010    * Note: a poll should never be needed in a loopback case,
6011    * since there is no possiblility of packet loss there, so
6012    * this way of discerining FWD/BCK should not be a problem.
6013    */
6014   id = GNUNET_PEER_search (peer);
6015   if (connection_get_next_hop (c)->id == id)
6016   {
6017     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  FWD ACK\n");
6018     fc = &c->fwd_fc;
6019   }
6020   else if (connection_get_prev_hop (c)->id == id)
6021   {
6022     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  BCK ACK\n");
6023     fc = &c->bck_fc;
6024   }
6025   else
6026   {
6027     GNUNET_break_op (0);
6028     return GNUNET_OK;
6029   }
6030
6031   pid = ntohl (msg->pid);
6032   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  PID %u, OLD %u\n",
6033               pid, fc->last_pid_recv);
6034   fc->last_pid_recv = pid;
6035   fwd = fc == &c->fwd_fc;
6036   send_ack (c, NULL, fwd);
6037
6038   return GNUNET_OK;
6039 }
6040
6041
6042 /**
6043  * Core handler for mesh keepalives.
6044  *
6045  * @param cls closure
6046  * @param message message
6047  * @param peer peer identity this notification is about
6048  * @return GNUNET_OK to keep the connection open,
6049  *         GNUNET_SYSERR to close it (signal serious error)
6050  *
6051  * TODO: Check who we got this from, to validate route.
6052  */
6053 static int
6054 handle_mesh_keepalive (void *cls, const struct GNUNET_PeerIdentity *peer,
6055                        const struct GNUNET_MessageHeader *message)
6056 {
6057   struct GNUNET_MESH_ConnectionKeepAlive *msg;
6058   struct MeshConnection *c;
6059   struct MeshPeer *neighbor;
6060   int fwd;
6061
6062   msg = (struct GNUNET_MESH_ConnectionKeepAlive *) message;
6063   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "got a keepalive packet from %s\n",
6064               GNUNET_i2s (peer));
6065
6066   c = connection_get (&msg->cid);
6067   if (NULL == c)
6068   {
6069     GNUNET_STATISTICS_update (stats, "# keepalive on unknown connection", 1,
6070                               GNUNET_NO);
6071     return GNUNET_OK;
6072   }
6073
6074   fwd = GNUNET_MESSAGE_TYPE_MESH_FWD_KEEPALIVE == ntohs (message->type) ?
6075         GNUNET_YES : GNUNET_NO;
6076
6077   /* Check if origin is as expected */
6078   neighbor = connection_get_hop (c, fwd);
6079   if (peer_get (peer)->id != neighbor->id)
6080   {
6081     GNUNET_break_op (0);
6082     return GNUNET_OK;
6083   }
6084
6085   connection_change_state (c, MESH_CONNECTION_READY);
6086   connection_reset_timeout (c, fwd);
6087
6088   if (connection_is_terminal (c, fwd))
6089     return GNUNET_OK;
6090
6091   GNUNET_STATISTICS_update (stats, "# keepalives forwarded", 1, GNUNET_NO);
6092   send_prebuilt_message_connection (message, c, NULL, fwd);
6093
6094   return GNUNET_OK;
6095 }
6096
6097
6098
6099 /**
6100  * Functions to handle messages from core
6101  */
6102 static struct GNUNET_CORE_MessageHandler core_handlers[] = {
6103   {&handle_mesh_connection_create, GNUNET_MESSAGE_TYPE_MESH_CONNECTION_CREATE,
6104     0},
6105   {&handle_mesh_connection_ack, GNUNET_MESSAGE_TYPE_MESH_CONNECTION_ACK,
6106     sizeof (struct GNUNET_MESH_ConnectionACK)},
6107   {&handle_mesh_connection_broken, GNUNET_MESSAGE_TYPE_MESH_CONNECTION_BROKEN,
6108     sizeof (struct GNUNET_MESH_ConnectionBroken)},
6109   {&handle_mesh_connection_destroy, GNUNET_MESSAGE_TYPE_MESH_CONNECTION_DESTROY,
6110     sizeof (struct GNUNET_MESH_ConnectionDestroy)},
6111   {&handle_mesh_keepalive, GNUNET_MESSAGE_TYPE_MESH_FWD_KEEPALIVE,
6112     sizeof (struct GNUNET_MESH_ConnectionKeepAlive)},
6113   {&handle_mesh_keepalive, GNUNET_MESSAGE_TYPE_MESH_BCK_KEEPALIVE,
6114     sizeof (struct GNUNET_MESH_ConnectionKeepAlive)},
6115   {&handle_mesh_ack, GNUNET_MESSAGE_TYPE_MESH_ACK,
6116     sizeof (struct GNUNET_MESH_ACK)},
6117   {&handle_mesh_poll, GNUNET_MESSAGE_TYPE_MESH_POLL,
6118     sizeof (struct GNUNET_MESH_Poll)},
6119   {&handle_mesh_fwd, GNUNET_MESSAGE_TYPE_MESH_FWD, 0},
6120   {&handle_mesh_bck, GNUNET_MESSAGE_TYPE_MESH_BCK, 0},
6121   {NULL, 0, 0}
6122 };
6123
6124
6125 /**
6126  * Function to process paths received for a new peer addition. The recorded
6127  * paths form the initial tunnel, which can be optimized later.
6128  * Called on each result obtained for the DHT search.
6129  *
6130  * @param cls closure
6131  * @param exp when will this value expire
6132  * @param key key of the result
6133  * @param get_path path of the get request
6134  * @param get_path_length lenght of get_path
6135  * @param put_path path of the put request
6136  * @param put_path_length length of the put_path
6137  * @param type type of the result
6138  * @param size number of bytes in data
6139  * @param data pointer to the result data
6140  */
6141 static void
6142 dht_get_id_handler (void *cls, struct GNUNET_TIME_Absolute exp,
6143                     const struct GNUNET_HashCode * key,
6144                     const struct GNUNET_PeerIdentity *get_path,
6145                     unsigned int get_path_length,
6146                     const struct GNUNET_PeerIdentity *put_path,
6147                     unsigned int put_path_length, enum GNUNET_BLOCK_Type type,
6148                     size_t size, const void *data)
6149 {
6150   struct MeshPeer *peer = cls;
6151   struct MeshPeerPath *p;
6152   struct MeshConnection *c;
6153   struct GNUNET_PeerIdentity pi;
6154   int i;
6155
6156   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got results from DHT!\n");
6157   GNUNET_PEER_resolve (peer->id, &pi);
6158   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  for %s\n", GNUNET_i2s (&pi));
6159
6160   p = path_build_from_dht (get_path, get_path_length,
6161                            put_path, put_path_length);
6162   path_add_to_peers (p, GNUNET_NO);
6163   path_destroy (p);
6164
6165   /* Count connections */
6166   for (c = peer->tunnel->connection_head, i = 0; NULL != c; c = c->next, i++);
6167
6168   /* If we already have 3 (or more (?!)) connections, it's enough */
6169   if (3 <= i)
6170     return;
6171
6172   if (peer->tunnel->state == MESH_TUNNEL_SEARCHING)
6173   {
6174     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " ... connect!\n");
6175     peer_connect (peer);
6176   }
6177   return;
6178 }
6179
6180
6181 /******************************************************************************/
6182 /*********************       MESH LOCAL HANDLES      **************************/
6183 /******************************************************************************/
6184
6185
6186 /**
6187  * Handler for client connection.
6188  *
6189  * @param cls Closure (unused).
6190  * @param client Client handler.
6191  */
6192 static void
6193 handle_local_client_connect (void *cls, struct GNUNET_SERVER_Client *client)
6194 {
6195   struct MeshClient *c;
6196
6197   if (NULL == client)
6198     return;
6199   c = GNUNET_malloc (sizeof (struct MeshClient));
6200   c->handle = client;
6201   c->id = next_client_id++; /* overflow not important: just for debug */
6202   GNUNET_SERVER_client_keep (client);
6203   GNUNET_SERVER_client_set_user_context (client, c);
6204   GNUNET_CONTAINER_DLL_insert (clients_head, clients_tail, c);
6205 }
6206
6207
6208 /**
6209  * Handler for client disconnection
6210  *
6211  * @param cls closure
6212  * @param client identification of the client; NULL
6213  *        for the last call when the server is destroyed
6214  */
6215 static void
6216 handle_local_client_disconnect (void *cls, struct GNUNET_SERVER_Client *client)
6217 {
6218   struct MeshClient *c;
6219
6220   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "client disconnected: %p\n", client);
6221   if (client == NULL)
6222   {
6223     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   (SERVER DOWN)\n");
6224     return;
6225   }
6226
6227   c = client_get (client);
6228   if (NULL != c)
6229   {
6230     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "matching client found (%u, %p)\n",
6231                 c->id, c);
6232     GNUNET_SERVER_client_drop (c->handle);
6233     c->shutting_down = GNUNET_YES;
6234     if (NULL != c->own_channels)
6235     {
6236       GNUNET_CONTAINER_multihashmap32_iterate (c->own_channels,
6237                                                &channel_destroy_iterator, c);
6238       GNUNET_CONTAINER_multihashmap32_destroy (c->own_channels);
6239     }
6240
6241     if (NULL != c->incoming_channels)
6242     {
6243       GNUNET_CONTAINER_multihashmap32_iterate (c->incoming_channels,
6244                                                &channel_destroy_iterator, c);
6245       GNUNET_CONTAINER_multihashmap32_destroy (c->incoming_channels);
6246     }
6247
6248     if (NULL != c->ports)
6249     {
6250       GNUNET_CONTAINER_multihashmap32_iterate (c->ports,
6251                                                &client_release_ports, c);
6252       GNUNET_CONTAINER_multihashmap32_destroy (c->ports);
6253     }
6254     GNUNET_CONTAINER_DLL_remove (clients_head, clients_tail, c);
6255     GNUNET_STATISTICS_update (stats, "# clients", -1, GNUNET_NO);
6256     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  client free (%p)\n", c);
6257     GNUNET_free (c);
6258   }
6259   else
6260   {
6261     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, " context NULL!\n");
6262   }
6263   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "done!\n");
6264   return;
6265 }
6266
6267
6268 /**
6269  * Handler for new clients
6270  *
6271  * @param cls closure
6272  * @param client identification of the client
6273  * @param message the actual message, which includes messages the client wants
6274  */
6275 static void
6276 handle_local_new_client (void *cls, struct GNUNET_SERVER_Client *client,
6277                          const struct GNUNET_MessageHeader *message)
6278 {
6279   struct GNUNET_MESH_ClientConnect *cc_msg;
6280   struct MeshClient *c;
6281   unsigned int size;
6282   uint32_t *p;
6283   unsigned int i;
6284
6285   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "new client connected %p\n", client);
6286
6287   /* Check data sanity */
6288   size = ntohs (message->size) - sizeof (struct GNUNET_MESH_ClientConnect);
6289   cc_msg = (struct GNUNET_MESH_ClientConnect *) message;
6290   if (0 != (size % sizeof (uint32_t)))
6291   {
6292     GNUNET_break (0);
6293     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
6294     return;
6295   }
6296   size /= sizeof (uint32_t);
6297
6298   /* Initialize new client structure */
6299   c = GNUNET_SERVER_client_get_user_context (client, struct MeshClient);
6300   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  client id %u\n", c->id);
6301   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  client has %u ports\n", size);
6302   if (size > 0)
6303   {
6304     uint32_t u32;
6305
6306     p = (uint32_t *) &cc_msg[1];
6307     c->ports = GNUNET_CONTAINER_multihashmap32_create (size);
6308     for (i = 0; i < size; i++)
6309     {
6310       u32 = ntohl (p[i]);
6311       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "    port: %u\n", u32);
6312
6313       /* store in client's hashmap */
6314       GNUNET_CONTAINER_multihashmap32_put (c->ports, u32, c,
6315                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
6316       /* store in global hashmap */
6317       /* FIXME only allow one client to have the port open,
6318        *       have a backup hashmap with waiting clients */
6319       GNUNET_CONTAINER_multihashmap32_put (ports, u32, c,
6320                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
6321     }
6322   }
6323
6324   c->own_channels = GNUNET_CONTAINER_multihashmap32_create (32);
6325   c->incoming_channels = GNUNET_CONTAINER_multihashmap32_create (32);
6326   GNUNET_SERVER_notification_context_add (nc, client);
6327   GNUNET_STATISTICS_update (stats, "# clients", 1, GNUNET_NO);
6328
6329   GNUNET_SERVER_receive_done (client, GNUNET_OK);
6330   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "new client processed\n");
6331 }
6332
6333
6334 /**
6335  * Handler for requests of new tunnels
6336  *
6337  * @param cls Closure.
6338  * @param client Identification of the client.
6339  * @param message The actual message.
6340  */
6341 static void
6342 handle_local_channel_create (void *cls, struct GNUNET_SERVER_Client *client,
6343                             const struct GNUNET_MessageHeader *message)
6344 {
6345   struct GNUNET_MESH_ChannelMessage *msg;
6346   struct MeshPeer *peer;
6347   struct MeshTunnel2 *t;
6348   struct MeshChannel *ch;
6349   struct MeshClient *c;
6350   MESH_ChannelNumber chid;
6351
6352   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "new channel requested\n");
6353
6354   /* Sanity check for client registration */
6355   if (NULL == (c = client_get (client)))
6356   {
6357     GNUNET_break (0);
6358     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
6359     return;
6360   }
6361   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  by client %u\n", c->id);
6362
6363   /* Message size sanity check */
6364   if (sizeof (struct GNUNET_MESH_ChannelMessage) != ntohs (message->size))
6365   {
6366     GNUNET_break (0);
6367     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
6368     return;
6369   }
6370
6371   msg = (struct GNUNET_MESH_ChannelMessage *) message;
6372   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  towards %s:%u\n",
6373               GNUNET_i2s (&msg->peer), ntohl (msg->port));
6374   chid = ntohl (msg->channel_id);
6375
6376   /* Sanity check for duplicate channel IDs */
6377   if (NULL != channel_get_by_local_id (c, chid))
6378   {
6379     GNUNET_break (0);
6380     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
6381     return;
6382   }
6383
6384   peer = peer_get (&msg->peer);
6385   if (NULL == peer->tunnel)
6386   {
6387     peer->tunnel = tunnel_new ();
6388     peer->tunnel->peer = peer;
6389   }
6390   t = peer->tunnel;
6391
6392   /* Create channel */
6393   ch = channel_new (t, c, chid);
6394   if (NULL == ch)
6395   {
6396     GNUNET_break (0);
6397     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
6398     return;
6399   }
6400   ch->port = ntohl (msg->port);
6401   channel_set_options (ch, ntohl (msg->opt));
6402
6403   /* In unreliable channels, we'll use the DLL to buffer data for the root */
6404   ch->root_rel = GNUNET_new (struct MeshChannelReliability);
6405   ch->root_rel->ch = ch;
6406   ch->root_rel->expected_delay = MESH_RETRANSMIT_TIME;
6407
6408   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "CREATED CHANNEL %s[%x]:%u (%x)\n",
6409               peer2s (t->peer), ch->gid, ch->port, ch->lid_root);
6410   peer_connect (peer);
6411
6412   /* Send create channel */
6413   {
6414     struct GNUNET_MESH_ChannelCreate msgcc;
6415
6416     msgcc.header.size = htons (sizeof (msgcc));
6417     msgcc.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_CHANNEL_CREATE);
6418     msgcc.chid = htonl (ch->gid);
6419     msgcc.port = msg->port;
6420     msgcc.opt = msg->opt;
6421
6422     tunnel_queue_data (t, ch, &msgcc.header, GNUNET_YES);
6423   }
6424
6425   GNUNET_SERVER_receive_done (client, GNUNET_OK);
6426   return;
6427 }
6428
6429
6430 /**
6431  * Handler for requests of deleting tunnels
6432  *
6433  * @param cls closure
6434  * @param client identification of the client
6435  * @param message the actual message
6436  */
6437 static void
6438 handle_local_channel_destroy (void *cls, struct GNUNET_SERVER_Client *client,
6439                              const struct GNUNET_MessageHeader *message)
6440 {
6441   struct GNUNET_MESH_ChannelMessage *msg;
6442   struct MeshClient *c;
6443   struct MeshChannel *ch;
6444   struct MeshTunnel2 *t;
6445   MESH_ChannelNumber chid;
6446
6447   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
6448               "Got a DESTROY CHANNEL from client!\n");
6449
6450   /* Sanity check for client registration */
6451   if (NULL == (c = client_get (client)))
6452   {
6453     GNUNET_break (0);
6454     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
6455     return;
6456   }
6457   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  by client %u\n", c->id);
6458
6459   /* Message sanity check */
6460   if (sizeof (struct GNUNET_MESH_ChannelMessage) != ntohs (message->size))
6461   {
6462     GNUNET_break (0);
6463     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
6464     return;
6465   }
6466
6467   msg = (struct GNUNET_MESH_ChannelMessage *) message;
6468
6469   /* Retrieve tunnel */
6470   chid = ntohl (msg->channel_id);
6471   ch = channel_get_by_local_id (c, chid);
6472   if (NULL == ch)
6473   {
6474     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "  channel %X not found\n", chid);
6475     GNUNET_break (0);
6476     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
6477     return;
6478   }
6479
6480   /* Cleanup after the tunnel */
6481   client_delete_channel (c, ch);
6482   if (c == ch->dest && GNUNET_MESH_LOCAL_CHANNEL_ID_SERV <= chid)
6483   {
6484     ch->dest = NULL;
6485   }
6486   else if (c == ch->root && GNUNET_MESH_LOCAL_CHANNEL_ID_SERV > chid)
6487   {
6488     ch->root = NULL;
6489   }
6490   else
6491   {
6492     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
6493                 "  channel %X client %p (%p, %p)\n",
6494                 chid, c, ch->root, ch->dest);
6495     GNUNET_break (0);
6496   }
6497
6498   t = ch->t;
6499   channel_destroy (ch);
6500   tunnel_destroy_if_empty (t);
6501
6502   GNUNET_SERVER_receive_done (client, GNUNET_OK);
6503   return;
6504 }
6505
6506
6507 /**
6508  * Handler for client traffic
6509  *
6510  * @param cls closure
6511  * @param client identification of the client
6512  * @param message the actual message
6513  */
6514 static void
6515 handle_local_data (void *cls, struct GNUNET_SERVER_Client *client,
6516                    const struct GNUNET_MessageHeader *message)
6517 {
6518   struct GNUNET_MESH_LocalData *msg;
6519   struct MeshClient *c;
6520   struct MeshChannel *ch;
6521   struct MeshChannelReliability *rel;
6522   MESH_ChannelNumber chid;
6523   size_t size;
6524   int fwd;
6525
6526   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
6527               "Got data from a client!\n");
6528
6529   /* Sanity check for client registration */
6530   if (NULL == (c = client_get (client)))
6531   {
6532     GNUNET_break (0);
6533     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
6534     return;
6535   }
6536   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  by client %u\n", c->id);
6537
6538   msg = (struct GNUNET_MESH_LocalData *) message;
6539
6540   /* Sanity check for message size */
6541   size = ntohs (message->size) - sizeof (struct GNUNET_MESH_LocalData);
6542   if (size < sizeof (struct GNUNET_MessageHeader))
6543   {
6544     GNUNET_break (0);
6545     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
6546     return;
6547   }
6548
6549   /* Channel exists? */
6550   chid = ntohl (msg->id);
6551   fwd = chid < GNUNET_MESH_LOCAL_CHANNEL_ID_SERV;
6552   ch = channel_get_by_local_id (c, chid);
6553   if (NULL == ch)
6554   {
6555     GNUNET_break (0);
6556     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
6557     return;
6558   }
6559
6560   /* Is the client in the channel? */
6561   if ( !( (fwd &&
6562            ch->root &&
6563            ch->root->handle == client)
6564          ||
6565           (!fwd &&
6566            ch->dest &&
6567            ch->dest->handle == client) ) )
6568   {
6569     GNUNET_break (0);
6570     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
6571     return;
6572   }
6573
6574   rel = fwd ? ch->root_rel : ch->dest_rel;
6575   rel->client_ready = GNUNET_NO;
6576
6577   /* Ok, everything is correct, send the message. */
6578   {
6579     struct GNUNET_MESH_Data *payload;
6580     uint16_t p2p_size = sizeof(struct GNUNET_MESH_Data) + size;
6581     unsigned char cbuf[p2p_size];
6582
6583     payload = (struct GNUNET_MESH_Data *) cbuf;
6584     payload->mid = htonl (rel->mid_send);
6585     rel->mid_send++;
6586     memcpy (&payload[1], &msg[1], size);
6587     payload->header.size = htons (p2p_size);
6588     payload->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_DATA);
6589     payload->chid = htonl (ch->gid);
6590     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  sending on channel...\n");
6591     send_prebuilt_message_channel (&payload->header, ch, fwd);
6592
6593     if (GNUNET_YES == ch->reliable)
6594       channel_save_copy (ch, &payload->header, fwd);
6595   }
6596   if (tunnel_get_buffer (ch->t, fwd) > 0)
6597     send_local_ack (ch, fwd);
6598   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "receive done OK\n");
6599   GNUNET_SERVER_receive_done (client, GNUNET_OK);
6600
6601   return;
6602 }
6603
6604
6605 /**
6606  * Handler for client's ACKs for payload traffic.
6607  *
6608  * @param cls Closure (unused).
6609  * @param client Identification of the client.
6610  * @param message The actual message.
6611  */
6612 static void
6613 handle_local_ack (void *cls, struct GNUNET_SERVER_Client *client,
6614                   const struct GNUNET_MessageHeader *message)
6615 {
6616   struct GNUNET_MESH_LocalAck *msg;
6617   struct MeshChannelReliability *rel;
6618   struct MeshChannel *ch;
6619   struct MeshClient *c;
6620   MESH_ChannelNumber chid;
6621   int fwd;
6622
6623   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got a local ACK\n");
6624
6625   /* Sanity check for client registration */
6626   if (NULL == (c = client_get (client)))
6627   {
6628     GNUNET_break (0);
6629     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
6630     return;
6631   }
6632   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  by client %u\n", c->id);
6633
6634   msg = (struct GNUNET_MESH_LocalAck *) message;
6635
6636   /* Channel exists? */
6637   chid = ntohl (msg->channel_id);
6638   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  on channel %X\n", chid);
6639   ch = channel_get_by_local_id (c, chid);
6640   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   -- ch %p\n", ch);
6641   if (NULL == ch)
6642   {
6643     GNUNET_break (0);
6644     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Channel %X unknown.\n", chid);
6645     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "  for client %u.\n", c->id);
6646     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
6647     return;
6648   }
6649
6650   /* If client is root, the ACK is going FWD, therefore this is "BCK". */
6651   /* If client is dest, the ACK is going BCK, therefore this is "FWD" */
6652   fwd = chid >= GNUNET_MESH_LOCAL_CHANNEL_ID_SERV;
6653   rel = fwd ? ch->dest_rel : ch->root_rel;
6654
6655   rel->client_ready = GNUNET_YES;
6656   channel_send_client_buffered_data (ch, c, fwd);
6657   send_ack (NULL, ch, fwd);
6658
6659   GNUNET_SERVER_receive_done (client, GNUNET_OK);
6660
6661   return;
6662 }
6663
6664
6665 /**
6666  * Iterator over all tunnels to send a monitoring client info about each tunnel.
6667  *
6668  * @param cls Closure (client handle).
6669  * @param key Key (hashed tunnel ID, unused).
6670  * @param value Tunnel info.
6671  *
6672  * @return GNUNET_YES, to keep iterating.
6673  */
6674 // static int
6675 // monitor_all_tunnels_iterator (void *cls,
6676 //                               const struct GNUNET_HashCode * key,
6677 //                               void *value)
6678 // {
6679 //   struct GNUNET_SERVER_Client *client = cls;
6680 //   struct MeshChannel *ch = value;
6681 //   struct GNUNET_MESH_LocalMonitor *msg;
6682 //
6683 //   msg = GNUNET_malloc (sizeof(struct GNUNET_MESH_LocalMonitor));
6684 //   msg->channel_id = htonl (ch->gid);
6685 //   msg->header.size = htons (sizeof (struct GNUNET_MESH_LocalMonitor));
6686 //   msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_INFO_TUNNELS);
6687 //
6688 //   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
6689 //               "*  sending info about tunnel %s\n",
6690 //               GNUNET_i2s (&msg->owner));
6691 //
6692 //   GNUNET_SERVER_notification_context_unicast (nc, client,
6693 //                                               &msg->header, GNUNET_NO);
6694 //   return GNUNET_YES;
6695 // }
6696
6697
6698 /**
6699  * Handler for client's MONITOR request.
6700  *
6701  * @param cls Closure (unused).
6702  * @param client Identification of the client.
6703  * @param message The actual message.
6704  */
6705 static void
6706 handle_local_get_tunnels (void *cls, struct GNUNET_SERVER_Client *client,
6707                           const struct GNUNET_MessageHeader *message)
6708 {
6709   struct MeshClient *c;
6710
6711   /* Sanity check for client registration */
6712   if (NULL == (c = client_get (client)))
6713   {
6714     GNUNET_break (0);
6715     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
6716     return;
6717   }
6718
6719   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
6720               "Received get tunnels request from client %u\n",
6721               c->id);
6722 //   GNUNET_CONTAINER_multihashmap_iterate (tunnels,
6723 //                                          monitor_all_tunnels_iterator,
6724 //                                          client);
6725   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
6726               "Get tunnels request from client %u completed\n",
6727               c->id);
6728   GNUNET_SERVER_receive_done (client, GNUNET_OK);
6729 }
6730
6731
6732 /**
6733  * Handler for client's MONITOR_TUNNEL request.
6734  *
6735  * @param cls Closure (unused).
6736  * @param client Identification of the client.
6737  * @param message The actual message.
6738  */
6739 static void
6740 handle_local_show_tunnel (void *cls, struct GNUNET_SERVER_Client *client,
6741                           const struct GNUNET_MessageHeader *message)
6742 {
6743   const struct GNUNET_MESH_LocalMonitor *msg;
6744   struct GNUNET_MESH_LocalMonitor *resp;
6745   struct MeshClient *c;
6746   struct MeshChannel *ch;
6747
6748   /* Sanity check for client registration */
6749   if (NULL == (c = client_get (client)))
6750   {
6751     GNUNET_break (0);
6752     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
6753     return;
6754   }
6755
6756   msg = (struct GNUNET_MESH_LocalMonitor *) message;
6757   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
6758               "Received tunnel info request from client %u for tunnel %s[%X]\n",
6759               c->id,
6760               &msg->owner,
6761               ntohl (msg->channel_id));
6762 //   ch = channel_get (&msg->owner, ntohl (msg->channel_id));
6763   ch = NULL; // FIXME
6764   if (NULL == ch)
6765   {
6766     /* We don't know the tunnel */
6767     struct GNUNET_MESH_LocalMonitor warn;
6768
6769     warn = *msg;
6770     GNUNET_SERVER_notification_context_unicast (nc, client,
6771                                                 &warn.header,
6772                                                 GNUNET_NO);
6773     GNUNET_SERVER_receive_done (client, GNUNET_OK);
6774     return;
6775   }
6776
6777   /* Initialize context */
6778   resp = GNUNET_malloc (sizeof (struct GNUNET_MESH_LocalMonitor));
6779   *resp = *msg;
6780   resp->header.size = htons (sizeof (struct GNUNET_MESH_LocalMonitor));
6781   GNUNET_SERVER_notification_context_unicast (nc, c->handle,
6782                                               &resp->header, GNUNET_NO);
6783   GNUNET_free (resp);
6784
6785   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
6786               "Monitor tunnel request from client %u completed\n",
6787               c->id);
6788   GNUNET_SERVER_receive_done (client, GNUNET_OK);
6789 }
6790
6791
6792 /**
6793  * Functions to handle messages from clients
6794  */
6795 static struct GNUNET_SERVER_MessageHandler client_handlers[] = {
6796   {&handle_local_new_client, NULL,
6797    GNUNET_MESSAGE_TYPE_MESH_LOCAL_CONNECT, 0},
6798   {&handle_local_channel_create, NULL,
6799    GNUNET_MESSAGE_TYPE_MESH_CHANNEL_CREATE,
6800    sizeof (struct GNUNET_MESH_ChannelMessage)},
6801   {&handle_local_channel_destroy, NULL,
6802    GNUNET_MESSAGE_TYPE_MESH_CHANNEL_DESTROY,
6803    sizeof (struct GNUNET_MESH_ChannelMessage)},
6804   {&handle_local_data, NULL,
6805    GNUNET_MESSAGE_TYPE_MESH_LOCAL_DATA, 0},
6806   {&handle_local_ack, NULL,
6807    GNUNET_MESSAGE_TYPE_MESH_LOCAL_ACK,
6808    sizeof (struct GNUNET_MESH_LocalAck)},
6809   {&handle_local_get_tunnels, NULL,
6810    GNUNET_MESSAGE_TYPE_MESH_LOCAL_INFO_TUNNELS,
6811    sizeof (struct GNUNET_MessageHeader)},
6812   {&handle_local_show_tunnel, NULL,
6813    GNUNET_MESSAGE_TYPE_MESH_LOCAL_INFO_TUNNEL,
6814      sizeof (struct GNUNET_MESH_LocalMonitor)},
6815   {NULL, NULL, 0, 0}
6816 };
6817
6818
6819 /**
6820  * Method called whenever a given peer connects.
6821  *
6822  * @param cls closure
6823  * @param peer peer identity this notification is about
6824  */
6825 static void
6826 core_connect (void *cls, const struct GNUNET_PeerIdentity *peer)
6827 {
6828   struct MeshPeer *pi;
6829   struct MeshPeerPath *path;
6830
6831   DEBUG_CONN ("Peer connected\n");
6832   DEBUG_CONN ("     %s\n", GNUNET_i2s (&my_full_id));
6833   pi = peer_get (peer);
6834   if (myid == pi->id)
6835   {
6836     DEBUG_CONN ("     (self)\n");
6837     path = path_new (1);
6838   }
6839   else
6840   {
6841     DEBUG_CONN ("     %s\n", GNUNET_i2s (peer));
6842     path = path_new (2);
6843     path->peers[1] = pi->id;
6844     GNUNET_PEER_change_rc (pi->id, 1);
6845     GNUNET_STATISTICS_update (stats, "# peers", 1, GNUNET_NO);
6846   }
6847   path->peers[0] = myid;
6848   GNUNET_PEER_change_rc (myid, 1);
6849   peer_add_path (pi, path, GNUNET_YES);
6850
6851   pi->connections = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_YES);
6852   return;
6853 }
6854
6855
6856 /**
6857  * Method called whenever a peer disconnects.
6858  *
6859  * @param cls closure
6860  * @param peer peer identity this notification is about
6861  */
6862 static void
6863 core_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
6864 {
6865   struct MeshPeer *pi;
6866
6867   DEBUG_CONN ("Peer disconnected\n");
6868   pi = GNUNET_CONTAINER_multihashmap_get (peers, &peer->hashPubKey);
6869   if (NULL == pi)
6870   {
6871     GNUNET_break (0);
6872     return;
6873   }
6874
6875   peer_remove_path (pi, myid, pi->id);
6876
6877   GNUNET_CONTAINER_multihashmap_iterate (pi->connections,
6878                                          connection_broken,
6879                                          pi);
6880   GNUNET_CONTAINER_multihashmap_destroy (pi->connections);
6881   pi->connections = NULL;
6882   if (myid == pi->id)
6883   {
6884     DEBUG_CONN ("     (self)\n");
6885   }
6886   GNUNET_STATISTICS_update (stats, "# peers", -1, GNUNET_NO);
6887
6888   return;
6889 }
6890
6891
6892 /**
6893  * Install server (service) handlers and start listening to clients.
6894  */
6895 static void
6896 server_init (void)
6897 {
6898   GNUNET_SERVER_add_handlers (server_handle, client_handlers);
6899   GNUNET_SERVER_connect_notify (server_handle,
6900                                 &handle_local_client_connect, NULL);
6901   GNUNET_SERVER_disconnect_notify (server_handle,
6902                                    &handle_local_client_disconnect, NULL);
6903   nc = GNUNET_SERVER_notification_context_create (server_handle, 1);
6904
6905   clients_head = NULL;
6906   clients_tail = NULL;
6907   next_client_id = 0;
6908   GNUNET_SERVER_resume (server_handle);
6909 }
6910
6911
6912 /**
6913  * To be called on core init/fail.
6914  *
6915  * @param cls Closure (config)
6916  * @param identity the public identity of this peer
6917  */
6918 static void
6919 core_init (void *cls,
6920            const struct GNUNET_PeerIdentity *identity)
6921 {
6922   const struct GNUNET_CONFIGURATION_Handle *c = cls;
6923   static int i = 0;
6924
6925   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Core init\n");
6926   if (0 != memcmp (identity, &my_full_id, sizeof (my_full_id)))
6927   {
6928     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Wrong CORE service\n"));
6929     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
6930                 " core id %s\n",
6931                 GNUNET_i2s (identity));
6932     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
6933                 " my id %s\n",
6934                 GNUNET_i2s (&my_full_id));
6935     GNUNET_CORE_disconnect (core_handle);
6936     core_handle = GNUNET_CORE_connect (c, /* Main configuration */
6937                                        NULL,      /* Closure passed to MESH functions */
6938                                        &core_init,        /* Call core_init once connected */
6939                                        &core_connect,     /* Handle connects */
6940                                        &core_disconnect,  /* remove peers on disconnects */
6941                                        NULL,      /* Don't notify about all incoming messages */
6942                                        GNUNET_NO, /* For header only in notification */
6943                                        NULL,      /* Don't notify about all outbound messages */
6944                                        GNUNET_NO, /* For header-only out notification */
6945                                        core_handlers);    /* Register these handlers */
6946     if (10 < i++)
6947       GNUNET_abort();
6948   }
6949   server_init ();
6950   return;
6951 }
6952
6953
6954 /******************************************************************************/
6955 /************************      MAIN FUNCTIONS      ****************************/
6956 /******************************************************************************/
6957
6958 /**
6959  * Iterator over tunnel hash map entries to destroy the tunnel during shutdown.
6960  *
6961  * @param cls closure
6962  * @param key current key code
6963  * @param value value in the hash map
6964  * @return GNUNET_YES if we should continue to iterate,
6965  *         GNUNET_NO if not.
6966  */
6967 static int
6968 shutdown_tunnel (void *cls, const struct GNUNET_HashCode * key, void *value)
6969 {
6970   struct MeshPeer *p = value;
6971   struct MeshTunnel2 *t = p->tunnel;
6972
6973   if (NULL != t)
6974     tunnel_destroy (t);
6975   return GNUNET_YES;
6976 }
6977
6978
6979 /**
6980  * Task run during shutdown.
6981  *
6982  * @param cls unused
6983  * @param tc unused
6984  */
6985 static void
6986 shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
6987 {
6988   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "shutting down\n");
6989
6990   if (core_handle != NULL)
6991   {
6992     GNUNET_CORE_disconnect (core_handle);
6993     core_handle = NULL;
6994   }
6995   GNUNET_CONTAINER_multihashmap_iterate (peers, &shutdown_tunnel, NULL);
6996   if (dht_handle != NULL)
6997   {
6998     GNUNET_DHT_disconnect (dht_handle);
6999     dht_handle = NULL;
7000   }
7001   if (nc != NULL)
7002   {
7003     GNUNET_SERVER_notification_context_destroy (nc);
7004     nc = NULL;
7005   }
7006   if (GNUNET_SCHEDULER_NO_TASK != announce_id_task)
7007   {
7008     GNUNET_SCHEDULER_cancel (announce_id_task);
7009     announce_id_task = GNUNET_SCHEDULER_NO_TASK;
7010   }
7011   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "shut down\n");
7012 }
7013
7014
7015 /**
7016  * Process mesh requests.
7017  *
7018  * @param cls closure
7019  * @param server the initialized server
7020  * @param c configuration to use
7021  */
7022 static void
7023 run (void *cls, struct GNUNET_SERVER_Handle *server,
7024      const struct GNUNET_CONFIGURATION_Handle *c)
7025 {
7026   char *keyfile;
7027   struct GNUNET_CRYPTO_EccPrivateKey *pk;
7028
7029   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "starting to run\n");
7030   server_handle = server;
7031   GNUNET_SERVER_suspend (server_handle);
7032
7033   if (GNUNET_OK !=
7034       GNUNET_CONFIGURATION_get_value_filename (c, "PEER", "PRIVATE_KEY",
7035                                                &keyfile))
7036   {
7037     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
7038                 _
7039                 ("%s service is lacking key configuration settings (%s).  Exiting.\n"),
7040                 "mesh", "peer/privatekey");
7041     GNUNET_SCHEDULER_shutdown ();
7042     return;
7043   }
7044
7045   if (GNUNET_OK !=
7046       GNUNET_CONFIGURATION_get_value_time (c, "MESH", "REFRESH_CONNECTION_TIME",
7047                                            &refresh_connection_time))
7048   {
7049     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
7050                 _
7051                 ("%s service is lacking key configuration settings (%s).  Exiting.\n"),
7052                 "mesh", "refresh path time");
7053     GNUNET_SCHEDULER_shutdown ();
7054     return;
7055   }
7056
7057   if (GNUNET_OK !=
7058       GNUNET_CONFIGURATION_get_value_time (c, "MESH", "ID_ANNOUNCE_TIME",
7059                                            &id_announce_time))
7060   {
7061     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
7062                 _
7063                 ("%s service is lacking key configuration settings (%s).  Exiting.\n"),
7064                 "mesh", "id announce time");
7065     GNUNET_SCHEDULER_shutdown ();
7066     return;
7067   }
7068
7069   if (GNUNET_OK !=
7070       GNUNET_CONFIGURATION_get_value_time (c, "MESH", "CONNECT_TIMEOUT",
7071                                            &connect_timeout))
7072   {
7073     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
7074                 _
7075                 ("%s service is lacking key configuration settings (%s).  Exiting.\n"),
7076                 "mesh", "connect timeout");
7077     GNUNET_SCHEDULER_shutdown ();
7078     return;
7079   }
7080
7081   if (GNUNET_OK !=
7082       GNUNET_CONFIGURATION_get_value_number (c, "MESH", "MAX_MSGS_QUEUE",
7083                                              &max_msgs_queue))
7084   {
7085     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
7086                 _
7087                 ("%s service is lacking key configuration settings (%s).  Exiting.\n"),
7088                 "mesh", "max msgs queue");
7089     GNUNET_SCHEDULER_shutdown ();
7090     return;
7091   }
7092
7093   if (GNUNET_OK !=
7094       GNUNET_CONFIGURATION_get_value_number (c, "MESH", "MAX_CONNECTIONS",
7095                                              &max_connections))
7096   {
7097     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
7098                 _
7099                 ("%s service is lacking key configuration settings (%s).  Exiting.\n"),
7100                 "mesh", "max tunnels");
7101     GNUNET_SCHEDULER_shutdown ();
7102     return;
7103   }
7104
7105   if (GNUNET_OK !=
7106       GNUNET_CONFIGURATION_get_value_number (c, "MESH", "DEFAULT_TTL",
7107                                              &default_ttl))
7108   {
7109     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
7110                 _
7111                 ("%s service is lacking key configuration settings (%s). Using default (%u).\n"),
7112                 "mesh", "default ttl", 64);
7113     default_ttl = 64;
7114   }
7115
7116   if (GNUNET_OK !=
7117       GNUNET_CONFIGURATION_get_value_number (c, "MESH", "MAX_PEERS",
7118                                              &max_peers))
7119   {
7120     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
7121                 _("%s service is lacking key configuration settings (%s). Using default (%u).\n"),
7122                 "mesh", "max peers", 1000);
7123     max_peers = 1000;
7124   }
7125
7126   if (GNUNET_OK !=
7127       GNUNET_CONFIGURATION_get_value_number (c, "MESH", "DROP_PERCENT",
7128                                              &drop_percent))
7129   {
7130     drop_percent = 0;
7131   }
7132   else
7133   {
7134     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
7135                 "Mesh is running with drop mode enabled. "
7136                 "This is NOT a good idea! "
7137                 "Remove the DROP_PERCENT option from your configuration.\n");
7138   }
7139
7140   if (GNUNET_OK !=
7141       GNUNET_CONFIGURATION_get_value_number (c, "MESH", "DHT_REPLICATION_LEVEL",
7142                                              &dht_replication_level))
7143   {
7144     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
7145                 _
7146                 ("%s service is lacking key configuration settings (%s). Using default (%u).\n"),
7147                 "mesh", "dht replication level", 3);
7148     dht_replication_level = 3;
7149   }
7150
7151   connections = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_YES);
7152   peers = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_NO);
7153   ports = GNUNET_CONTAINER_multihashmap32_create (32);
7154
7155   dht_handle = GNUNET_DHT_connect (c, 64);
7156   if (NULL == dht_handle)
7157   {
7158     GNUNET_break (0);
7159   }
7160   stats = GNUNET_STATISTICS_create ("mesh", c);
7161
7162   /* Scheduled the task to clean up when shutdown is called */
7163   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
7164                                 NULL);
7165   pk = GNUNET_CRYPTO_ecc_key_create_from_file (keyfile);
7166   GNUNET_free (keyfile);
7167   GNUNET_assert (NULL != pk);
7168   my_private_key = pk;
7169   GNUNET_CRYPTO_ecc_key_get_public (my_private_key, &my_public_key);
7170   GNUNET_CRYPTO_hash (&my_public_key, sizeof (my_public_key),
7171                       &my_full_id.hashPubKey);
7172   myid = GNUNET_PEER_intern (&my_full_id);
7173   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
7174               "Mesh for peer [%s] starting\n",
7175               GNUNET_i2s(&my_full_id));
7176
7177   core_handle = GNUNET_CORE_connect (c, /* Main configuration */
7178                                      NULL,      /* Closure passed to MESH functions */
7179                                      &core_init,        /* Call core_init once connected */
7180                                      &core_connect,     /* Handle connects */
7181                                      &core_disconnect,  /* remove peers on disconnects */
7182                                      NULL,      /* Don't notify about all incoming messages */
7183                                      GNUNET_NO, /* For header only in notification */
7184                                      NULL,      /* Don't notify about all outbound messages */
7185                                      GNUNET_NO, /* For header-only out notification */
7186                                      core_handlers);    /* Register these handlers */
7187   if (NULL == core_handle)
7188   {
7189     GNUNET_break (0);
7190     GNUNET_SCHEDULER_shutdown ();
7191     return;
7192   }
7193   announce_id_task = GNUNET_SCHEDULER_add_now (&announce_id, cls);
7194   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Mesh service running\n");
7195 }
7196
7197
7198 /**
7199  * The main function for the mesh service.
7200  *
7201  * @param argc number of arguments from the command line
7202  * @param argv command line arguments
7203  * @return 0 ok, 1 on error
7204  */
7205 int
7206 main (int argc, char *const *argv)
7207 {
7208   int ret;
7209   int r;
7210
7211   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "main()\n");
7212   r = GNUNET_SERVICE_run (argc, argv, "mesh", GNUNET_SERVICE_OPTION_NONE, &run,
7213                           NULL);
7214   ret = (GNUNET_OK == r) ? 0 : 1;
7215   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "main() END\n");
7216
7217   INTERVAL_SHOW;
7218
7219   return ret;
7220 }