src/mesh/gnunet-service-mesh_channel.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 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 #include "platform.h"
  23 #include "gnunet_util_lib.h"
  24
  25 #include "gnunet_statistics_service.h"
  26
  27 #include "mesh.h"
  28 #include "mesh_protocol.h"
  29
  30 #include "gnunet-service-mesh_channel.h"
  31 #include "gnunet-service-mesh_local.h"
  32 #include "gnunet-service-mesh_tunnel.h"
  33 #include "gnunet-service-mesh_peer.h"
  34
  35 #define LOG(level, ...) GNUNET_log_from(level,"mesh-chn",__VA_ARGS__)
  36
  37 #define MESH_RETRANSMIT_TIME    GNUNET_TIME_UNIT_SECONDS
  38 #define MESH_RETRANSMIT_MARGIN  4
  39
  40
  41 /**
  42  * All the states a connection can be in.
  43  */
  44 enum MeshChannelState
  45 {
  46   /**
  47    * Uninitialized status, should never appear in operation.
  48    */
  49   MESH_CHANNEL_NEW,
  50
  51   /**
  52    * Connection create message sent, waiting for ACK.
  53    */
  54   MESH_CHANNEL_SENT,
  55
  56   /**
  57    * Connection confirmed, ready to carry traffic.
  58    */
  59   MESH_CHANNEL_READY,
  60 };
  61
  62
  63
  64 /**
  65  * Info needed to retry a message in case it gets lost.
  66  */
  67 struct MeshReliableMessage
  68 {
  69     /**
  70      * Double linked list, FIFO style
  71      */
  72   struct MeshReliableMessage    *next;
  73   struct MeshReliableMessage    *prev;
  74
  75     /**
  76      * Type of message (payload, channel management).
  77      */
  78   int16_t type;
  79
  80     /**
  81      * Tunnel Reliability queue this message is in.
  82      */
  83   struct MeshChannelReliability  *rel;
  84
  85     /**
  86      * ID of the message (ACK needed to free)
  87      */
  88   uint32_t                      mid;
  89
  90   /**
  91    * Tunnel Queue.
  92    */
  93   struct MeshTunnel3Queue *q;
  94
  95     /**
  96      * When was this message issued (to calculate ACK delay)
  97      */
  98   struct GNUNET_TIME_Absolute   timestamp;
  99
 100   /* struct GNUNET_MESH_Data with payload */
 101 };
 102
 103
 104 /**
 105  * Info about the traffic state for a client in a channel.
 106  */
 107 struct MeshChannelReliability
 108 {
 109     /**
 110      * Channel this is about.
 111      */
 112   struct MeshChannel *ch;
 113
 114     /**
 115      * DLL of messages sent and not yet ACK'd.
 116      */
 117   struct MeshReliableMessage        *head_sent;
 118   struct MeshReliableMessage        *tail_sent;
 119
 120     /**
 121      * DLL of messages received out of order.
 122      */
 123   struct MeshReliableMessage        *head_recv;
 124   struct MeshReliableMessage        *tail_recv;
 125
 126     /**
 127      * Messages received.
 128      */
 129   unsigned int                      n_recv;
 130
 131     /**
 132      * Next MID to use for outgoing traffic.
 133      */
 134   uint32_t                          mid_send;
 135
 136     /**
 137      * Next MID expected for incoming traffic.
 138      */
 139   uint32_t                          mid_recv;
 140
 141     /**
 142      * Can we send data to the client?
 143      */
 144   int                               client_ready;
 145
 146   /**
 147    * Can the client send data to us?
 148    */
 149   int                               client_allowed;
 150
 151     /**
 152      * Task to resend/poll in case no ACK is received.
 153      */
 154   GNUNET_SCHEDULER_TaskIdentifier   retry_task;
 155
 156     /**
 157      * Counter for exponential backoff.
 158      */
 159   struct GNUNET_TIME_Relative       retry_timer;
 160
 161     /**
 162      * How long does it usually take to get an ACK.
 163      */
 164   struct GNUNET_TIME_Relative       expected_delay;
 165 };
 166
 167
 168 /**
 169  * Struct containing all information regarding a channel to a remote client.
 170  */
 171 struct MeshChannel
 172 {
 173     /**
 174      * Tunnel this channel is in.
 175      */
 176   struct MeshTunnel3 *t;
 177
 178     /**
 179      * Destination port of the channel.
 180      */
 181   uint32_t port;
 182
 183     /**
 184      * Global channel number ( < GNUNET_MESH_LOCAL_CHANNEL_ID_CLI)
 185      */
 186   MESH_ChannelNumber gid;
 187
 188     /**
 189      * Local tunnel number for root (owner) client.
 190      * ( >= GNUNET_MESH_LOCAL_CHANNEL_ID_CLI or 0 )
 191      */
 192   MESH_ChannelNumber lid_root;
 193
 194     /**
 195      * Local tunnel number for local destination clients (incoming number)
 196      * ( >= GNUNET_MESH_LOCAL_CHANNEL_ID_SERV or 0).
 197      */
 198   MESH_ChannelNumber lid_dest;
 199
 200     /**
 201      * Channel state.
 202      */
 203   enum MeshChannelState state;
 204
 205     /**
 206      * Is the tunnel bufferless (minimum latency)?
 207      */
 208   int nobuffer;
 209
 210     /**
 211      * Is the tunnel reliable?
 212      */
 213   int reliable;
 214
 215     /**
 216      * Last time the channel was used
 217      */
 218   struct GNUNET_TIME_Absolute timestamp;
 219
 220     /**
 221      * Client owner of the tunnel, if any
 222      */
 223   struct MeshClient *root;
 224
 225     /**
 226      * Client destination of the tunnel, if any.
 227      */
 228   struct MeshClient *dest;
 229
 230     /**
 231      * Flag to signal the destruction of the channel.
 232      * If this is set GNUNET_YES the channel will be destroyed
 233      * when the queue is empty.
 234      */
 235   int destroy;
 236
 237     /**
 238      * Total messages pending for this channel, payload or not.
 239      */
 240   unsigned int pending_messages;
 241
 242     /**
 243      * Reliability data.
 244      * Only present (non-NULL) at the owner of a tunnel.
 245      */
 246   struct MeshChannelReliability *root_rel;
 247
 248     /**
 249      * Reliability data.
 250      * Only present (non-NULL) at the destination of a tunnel.
 251      */
 252   struct MeshChannelReliability *dest_rel;
 253
 254 };
 255
 256
 257 /******************************************************************************/
 258 /*******************************   GLOBALS  ***********************************/
 259 /******************************************************************************/
 260
 261 /**
 262  * Global handle to the statistics service.
 263  */
 264 extern struct GNUNET_STATISTICS_Handle *stats;
 265
 266 /**
 267  * Local peer own ID (memory efficient handle).
 268  */
 269 extern GNUNET_PEER_Id myid;
 270
 271
 272 /******************************************************************************/
 273 /********************************   STATIC  ***********************************/
 274 /******************************************************************************/
 275
 276 /**
 277  * Destroy a reliable message after it has been acknowledged, either by
 278  * direct mid ACK or bitfield. Updates the appropriate data structures and
 279  * timers and frees all memory.
 280  *
 281  * @param copy Message that is no longer needed: remote peer got it.
 282  * @param update_time Is the timing information relevant?
 283  *                    If this message is ACK in a batch the timing information
 284  *                    is skewed by the retransmission, count only for the
 285  *                    retransmitted message.
 286  */
 287 static void
 288 rel_message_free (struct MeshReliableMessage *copy, int update_time);
 289
 290 /**
 291  * We have received a message out of order, or the client is not ready.
 292  * Buffer it until we receive an ACK from the client or the missing
 293  * message from the channel.
 294  *
 295  * @param msg Message to buffer (MUST be of type MESH_DATA).
 296  * @param rel Reliability data to the corresponding direction.
 297  */
 298 static void
 299 add_buffered_data (const struct GNUNET_MESH_Data *msg,
 300                    struct MeshChannelReliability *rel)
 301 {
 302   struct MeshReliableMessage *copy;
 303   struct MeshReliableMessage *prev;
 304   uint32_t mid;
 305   uint16_t size;
 306
 307   size = ntohs (msg->header.size);
 308   mid = ntohl (msg->mid);
 309
 310   LOG (GNUNET_ERROR_TYPE_DEBUG, "add_buffered_data %u\n", mid);
 311
 312   copy = GNUNET_malloc (sizeof (*copy) + size);
 313   copy->mid = mid;
 314   copy->rel = rel;
 315   copy->type = GNUNET_MESSAGE_TYPE_MESH_DATA;
 316   memcpy (&copy[1], msg, size);
 317
 318   rel->n_recv++;
 319
 320   // FIXME do something better than O(n), although n < 64...
 321   // FIXME start from the end (most messages are the latest ones)
 322   for (prev = rel->head_recv; NULL != prev; prev = prev->next)
 323   {
 324     LOG (GNUNET_ERROR_TYPE_DEBUG, " prev %u\n", prev->mid);
 325     if (GMC_is_pid_bigger (prev->mid, mid))
 326     {
 327       LOG (GNUNET_ERROR_TYPE_DEBUG, " bingo!\n");
 328       GNUNET_CONTAINER_DLL_insert_before (rel->head_recv, rel->tail_recv,
 329                                           prev, copy);
 330       return;
 331     }
 332   }
 333     LOG (GNUNET_ERROR_TYPE_DEBUG, " insert at tail!\n");
 334     GNUNET_CONTAINER_DLL_insert_tail (rel->head_recv, rel->tail_recv, copy);
 335     LOG (GNUNET_ERROR_TYPE_DEBUG, "add_buffered_data END\n");
 336 }
 337
 338 /**
 339  * Add a destination client to a channel, initializing all data structures
 340  * in the channel and the client.
 341  *
 342  * @param ch Channel to which add the destination.
 343  * @param c Client which to add to the channel.
 344  */
 345 static void
 346 add_destination (struct MeshChannel *ch, struct MeshClient *c)
 347 {
 348   if (NULL != ch->dest)
 349   {
 350     GNUNET_break (0);
 351     return;
 352   }
 353
 354   /* Assign local id as destination */
 355   ch->lid_dest = GML_get_next_chid (c);
 356
 357   /* Store in client's hashmap */
 358   GML_channel_add (c, ch->lid_dest, ch);
 359
 360   GNUNET_break (NULL == ch->dest_rel);
 361   ch->dest_rel = GNUNET_new (struct MeshChannelReliability);
 362   ch->dest_rel->ch = ch;
 363   ch->dest_rel->expected_delay = MESH_RETRANSMIT_TIME;
 364
 365   ch->dest = c;
 366 }
 367
 368
 369 /**
 370  * Send data to a client.
 371  *
 372  * If the client is ready, send directly, otherwise buffer while listening
 373  * for a local ACK.
 374  *
 375  * @param ch Channel
 376  * @param msg Message.
 377  * @param fwd Is this a fwd (root->dest) message?
 378  */
 379 static void
 380 send_client_data (struct MeshChannel *ch,
 381                   const struct GNUNET_MESH_Data *msg,
 382                   int fwd)
 383 {
 384   if (fwd)
 385   {
 386     if (ch->dest_rel->client_ready)
 387       GML_send_data (ch->dest, msg, ch->lid_dest);
 388     else
 389       add_buffered_data (msg, ch->dest_rel);
 390   }
 391   else
 392   {
 393     if (ch->root_rel->client_ready)
 394       GML_send_data (ch->root, msg, ch->lid_root);
 395     else
 396       add_buffered_data (msg, ch->root_rel);
 397   }
 398 }
 399
 400
 401 /**
 402  * Send a buffered message to the client, for in order delivery or
 403  * as result of client ACK.
 404  *
 405  * @param ch Channel on which to empty the message buffer.
 406  * @param c Client to send to.
 407  * @param fwd Is this to send FWD data?.
 408  */
 409 static void
 410 send_client_buffered_data (struct MeshChannel *ch,
 411                            struct MeshClient *c,
 412                            int fwd)
 413 {
 414   struct MeshReliableMessage *copy;
 415   struct MeshChannelReliability *rel;
 416
 417   LOG (GNUNET_ERROR_TYPE_DEBUG, "send_buffered_data\n");
 418   rel = fwd ? ch->dest_rel : ch->root_rel;
 419   if (GNUNET_NO == rel->client_ready)
 420   {
 421     LOG (GNUNET_ERROR_TYPE_DEBUG, "client not ready\n");
 422     return;
 423   }
 424
 425   copy = rel->head_recv;
 426   /* We never buffer channel management messages */
 427   if (NULL != copy)
 428   {
 429     if (copy->mid == rel->mid_recv || GNUNET_NO == ch->reliable)
 430     {
 431       struct GNUNET_MESH_Data *msg = (struct GNUNET_MESH_Data *) &copy[1];
 432
 433       LOG (GNUNET_ERROR_TYPE_DEBUG,
 434            " have %u! now expecting %u\n",
 435            copy->mid, rel->mid_recv + 1);
 436       send_client_data (ch, msg, fwd);
 437       rel->n_recv--;
 438       rel->mid_recv++;
 439       GNUNET_CONTAINER_DLL_remove (rel->head_recv, rel->tail_recv, copy);
 440       GNUNET_free (copy);
 441     }
 442     else
 443     {
 444       LOG (GNUNET_ERROR_TYPE_DEBUG,
 445            " reliable && don't have %u, next is %u\n",
 446            rel->mid_recv,
 447            copy->mid);
 448       return;
 449     }
 450   }
 451   LOG (GNUNET_ERROR_TYPE_DEBUG, "send_buffered_data END\n");
 452 }
 453
 454
 455 /**
 456  * Allow a client to send more data.
 457  *
 458  * In case the client was already allowed to send data, do nothing.
 459  *
 460  * @param ch Channel.
 461  * @param fwd Is this a FWD ACK? (FWD ACKs are sent to root)
 462  */
 463 static void
 464 send_client_ack (struct MeshChannel *ch, int fwd)
 465 {
 466   struct MeshChannelReliability *rel = fwd ? ch->root_rel : ch->dest_rel;
 467
 468   LOG (GNUNET_ERROR_TYPE_DEBUG,
 469        "  sending %s ack to client on channel %s\n",
 470        fwd ? "FWD" : "BCK", GMCH_2s (ch));
 471
 472   if (NULL == rel)
 473   {
 474     GNUNET_break (0);
 475     return;
 476   }
 477
 478   if (GNUNET_YES == rel->client_allowed)
 479   {
 480     LOG (GNUNET_ERROR_TYPE_DEBUG, "  already allowed\n");
 481     return;
 482   }
 483   rel->client_allowed = GNUNET_YES;
 484
 485   GML_send_ack (fwd ? ch->root : ch->dest, fwd ? ch->lid_root : ch->lid_dest);
 486 }
 487
 488
 489 /**
 490  * Notify the root that the destination rejected the channel.
 491  *
 492  * @param ch Rejected channel.
 493  */
 494 static void
 495 send_client_nack (struct MeshChannel *ch)
 496 {
 497   if (NULL == ch->root)
 498   {
 499     GNUNET_break (0);
 500     return;
 501   }
 502   GML_send_nack (ch->root, ch->lid_root);
 503 }
 504
 505
 506 /**
 507  * Destroy all reliable messages queued for a channel,
 508  * during a channel destruction.
 509  * Frees the reliability structure itself.
 510  *
 511  * @param rel Reliability data for a channel.
 512  */
 513 static void
 514 channel_rel_free_all (struct MeshChannelReliability *rel)
 515 {
 516   struct MeshReliableMessage *copy;
 517   struct MeshReliableMessage *next;
 518
 519   if (NULL == rel)
 520     return;
 521
 522   for (copy = rel->head_recv; NULL != copy; copy = next)
 523   {
 524     next = copy->next;
 525     GNUNET_CONTAINER_DLL_remove (rel->head_recv, rel->tail_recv, copy);
 526     GNUNET_free (copy);
 527   }
 528   for (copy = rel->head_sent; NULL != copy; copy = next)
 529   {
 530     next = copy->next;
 531     GNUNET_CONTAINER_DLL_remove (rel->head_sent, rel->tail_sent, copy);
 532     GNUNET_free (copy);
 533   }
 534   if (GNUNET_SCHEDULER_NO_TASK != rel->retry_task)
 535     GNUNET_SCHEDULER_cancel (rel->retry_task);
 536   GNUNET_free (rel);
 537 }
 538
 539
 540 /**
 541  * Mark future messages as ACK'd.
 542  *
 543  * @param rel Reliability data.
 544  * @param msg DataACK message with a bitfield of future ACK'd messages.
 545  */
 546 static void
 547 channel_rel_free_sent (struct MeshChannelReliability *rel,
 548                        const struct GNUNET_MESH_DataACK *msg)
 549 {
 550   struct MeshReliableMessage *copy;
 551   struct MeshReliableMessage *next;
 552   uint64_t bitfield;
 553   uint64_t mask;
 554   uint32_t mid;
 555   uint32_t target;
 556   unsigned int i;
 557
 558   bitfield = msg->futures;
 559   mid = ntohl (msg->mid);
 560   LOG (GNUNET_ERROR_TYPE_DEBUG,
 561               "!!! free_sent_reliable %u %llX\n",
 562               mid, bitfield);
 563   LOG (GNUNET_ERROR_TYPE_DEBUG,
 564               " rel %p, head %p\n",
 565               rel, rel->head_sent);
 566   for (i = 0, copy = rel->head_sent;
 567        i < 64 && NULL != copy && 0 != bitfield;
 568        i++)
 569   {
 570     LOG (GNUNET_ERROR_TYPE_DEBUG,
 571                 " trying bit %u (mid %u)\n",
 572                 i, mid + i + 1);
 573     mask = 0x1LL << i;
 574     if (0 == (bitfield & mask))
 575      continue;
 576
 577     LOG (GNUNET_ERROR_TYPE_DEBUG, " set!\n");
 578     /* Bit was set, clear the bit from the bitfield */
 579     bitfield &= ~mask;
 580
 581     /* The i-th bit was set. Do we have that copy? */
 582     /* Skip copies with mid < target */
 583     target = mid + i + 1;
 584     LOG (GNUNET_ERROR_TYPE_DEBUG, " target %u\n", target);
 585     while (NULL != copy && GMC_is_pid_bigger (target, copy->mid))
 586      copy = copy->next;
 587
 588     /* Did we run out of copies? (previously freed, it's ok) */
 589     if (NULL == copy)
 590     {
 591      LOG (GNUNET_ERROR_TYPE_DEBUG, "run out of copies...\n");
 592      return;
 593     }
 594
 595     /* Did we overshoot the target? (previously freed, it's ok) */
 596     if (GMC_is_pid_bigger (copy->mid, target))
 597     {
 598      LOG (GNUNET_ERROR_TYPE_DEBUG, " next copy %u\n", copy->mid);
 599      continue;
 600     }
 601
 602     /* Now copy->mid == target, free it */
 603     next = copy->next;
 604     rel_message_free (copy, GNUNET_YES);
 605     copy = next;
 606   }
 607   LOG (GNUNET_ERROR_TYPE_DEBUG, "free_sent_reliable END\n");
 608 }
 609
 610
 611 /**
 612  * We haven't received an ACK after a certain time: restransmit the message.
 613  *
 614  * @param cls Closure (MeshReliableMessage with the message to restransmit)
 615  * @param tc TaskContext.
 616  */
 617 static void
 618 channel_retransmit_message (void *cls,
 619                             const struct GNUNET_SCHEDULER_TaskContext *tc)
 620 {
 621   struct MeshChannelReliability *rel = cls;
 622   struct MeshReliableMessage *copy;
 623   struct MeshChannel *ch;
 624   struct GNUNET_MESH_Data *payload;
 625   int fwd;
 626
 627   rel->retry_task = GNUNET_SCHEDULER_NO_TASK;
 628   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
 629     return;
 630
 631   ch = rel->ch;
 632   copy = rel->head_sent;
 633   if (NULL == copy)
 634   {
 635     GNUNET_break (0);
 636     return;
 637   }
 638
 639   payload = (struct GNUNET_MESH_Data *) &copy[1];
 640   fwd = (rel == ch->root_rel);
 641
 642   /* Message not found in the queue that we are going to use. */
 643   LOG (GNUNET_ERROR_TYPE_DEBUG, "!!! RETRANSMIT %u\n", copy->mid);
 644
 645   GMCH_send_prebuilt_message (&payload->header, ch, fwd, GNUNET_YES);
 646   GNUNET_STATISTICS_update (stats, "# data retransmitted", 1, GNUNET_NO);
 647
 648   copy->timestamp = GNUNET_TIME_absolute_get();
 649   rel->retry_timer = GNUNET_TIME_STD_BACKOFF (rel->retry_timer);
 650   rel->retry_task = GNUNET_SCHEDULER_add_delayed (rel->retry_timer,
 651                                                   &channel_retransmit_message,
 652                                                   cls);
 653 }
 654
 655
 656 /**
 657  * Destroy a reliable message after it has been acknowledged, either by
 658  * direct mid ACK or bitfield. Updates the appropriate data structures and
 659  * timers and frees all memory.
 660  *
 661  * @param copy Message that is no longer needed: remote peer got it.
 662  * @param update_time Is the timing information relevant?
 663  *                    If this message is ACK in a batch the timing information
 664  *                    is skewed by the retransmission, count only for the
 665  *                    retransmitted message.
 666  */
 667 static void
 668 rel_message_free (struct MeshReliableMessage *copy, int update_time)
 669 {
 670   struct MeshChannelReliability *rel;
 671   struct GNUNET_TIME_Relative time;
 672
 673   rel = copy->rel;
 674   LOG (GNUNET_ERROR_TYPE_DEBUG, "!!! Freeing %u\n", copy->mid);
 675   if (update_time)
 676   {
 677     time = GNUNET_TIME_absolute_get_duration (copy->timestamp);
 678     rel->expected_delay.rel_value_us *= 7;
 679     rel->expected_delay.rel_value_us += time.rel_value_us;
 680     rel->expected_delay.rel_value_us /= 8;
 681     LOG (GNUNET_ERROR_TYPE_DEBUG, "!!!  took %s\n",
 682                 GNUNET_STRINGS_relative_time_to_string (time, GNUNET_NO));
 683     LOG (GNUNET_ERROR_TYPE_DEBUG, "!!!  new expected delay %s\n",
 684                 GNUNET_STRINGS_relative_time_to_string (rel->expected_delay,
 685                                                         GNUNET_NO));
 686     rel->retry_timer = rel->expected_delay;
 687   }
 688   else
 689   {
 690     LOG (GNUNET_ERROR_TYPE_DEBUG, "!!! batch free, ignoring timing\n");
 691   }
 692   GNUNET_CONTAINER_DLL_remove (rel->head_sent, rel->tail_sent, copy);
 693   GNUNET_free (copy);
 694 }
 695
 696
 697 /**
 698  * Confirm we got a channel create.
 699  *
 700  * @param ch The channel to confirm.
 701  * @param fwd Should we send a FWD ACK? (going dest->root)
 702  */
 703 static void
 704 channel_send_ack (struct MeshChannel *ch, int fwd)
 705 {
 706   struct GNUNET_MESH_ChannelManage msg;
 707
 708   msg.header.size = htons (sizeof (msg));
 709   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_CHANNEL_ACK);
 710   LOG (GNUNET_ERROR_TYPE_DEBUG,
 711               "  sending channel %s ack for channel %s\n",
 712               fwd ? "FWD" : "BCK", GMCH_2s (ch));
 713
 714   msg.chid = htonl (ch->gid);
 715   GMCH_send_prebuilt_message (&msg.header, ch, !fwd, GNUNET_NO);
 716 }
 717
 718
 719 /**
 720  * Notify that a channel create didn't succeed.
 721  *
 722  * @param ch The channel to reject.
 723  */
 724 static void
 725 channel_send_nack (struct MeshChannel *ch)
 726 {
 727   struct GNUNET_MESH_ChannelManage msg;
 728
 729   msg.header.size = htons (sizeof (msg));
 730   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_CHANNEL_NACK);
 731   LOG (GNUNET_ERROR_TYPE_DEBUG,
 732        "  sending channel NACK for channel %s\n",
 733        GMCH_2s (ch));
 734
 735   msg.chid = htonl (ch->gid);
 736   GMCH_send_prebuilt_message (&msg.header, ch, GNUNET_NO, GNUNET_NO);
 737 }
 738
 739
 740 /**
 741  * Channel was ACK'd by remote peer, mark as ready and cancel retransmission.
 742  *
 743  * @param ch Channel to mark as ready.
 744  * @param fwd Was the ACK message a FWD ACK? (dest->root, SYNACK)
 745  */
 746 static void
 747 channel_confirm (struct MeshChannel *ch, int fwd)
 748 {
 749   struct MeshChannelReliability *rel;
 750   struct MeshReliableMessage *copy;
 751   struct MeshReliableMessage *next;
 752
 753   LOG (GNUNET_ERROR_TYPE_DEBUG,
 754               "  channel confirm %s %s:%X\n",
 755               fwd ? "FWD" : "BCK", GMT_2s (ch->t), ch->gid);
 756   ch->state = MESH_CHANNEL_READY;
 757
 758   rel = fwd ? ch->root_rel : ch->dest_rel;
 759   rel->client_ready = GNUNET_YES;
 760   for (copy = rel->head_sent; NULL != copy; copy = next)
 761   {
 762     struct GNUNET_MessageHeader *msg;
 763
 764     next = copy->next;
 765     msg = (struct GNUNET_MessageHeader *) &copy[1];
 766     if (ntohs (msg->type) == GNUNET_MESSAGE_TYPE_MESH_CHANNEL_CREATE)
 767     {
 768       rel_message_free (copy, GNUNET_YES);
 769       /* TODO return? */
 770     }
 771   }
 772   send_client_ack (ch, fwd);
 773
 774   /* In case of a FWD ACK (SYNACK) send a BCK ACK (ACK). */
 775   if (fwd)
 776     channel_send_ack (ch, !fwd);
 777 }
 778
 779
 780 /**
 781  * Message has been sent: start retransmission timer.
 782  *
 783  * @param cls Closure (copy sent).
 784  * @param t Tunnel.
 785  * @param q Queue handler (no longer valid).
 786  * @param type Type of message.
 787  * @param size Size of the message.
 788  */
 789 static void
 790 message_sent (void *cls,
 791               struct MeshTunnel3 *t,
 792               struct MeshTunnel3Queue *q,
 793               uint16_t type, size_t size)
 794 {
 795   struct MeshReliableMessage *copy = cls;
 796   struct MeshChannelReliability *rel = copy->rel;
 797
 798   copy->timestamp = GNUNET_TIME_absolute_get ();
 799   if (GNUNET_SCHEDULER_NO_TASK == rel->retry_task)
 800   {
 801     rel->retry_timer =
 802         GNUNET_TIME_relative_multiply (rel->expected_delay,
 803                                        MESH_RETRANSMIT_MARGIN);
 804     rel->retry_task =
 805         GNUNET_SCHEDULER_add_delayed (rel->retry_timer,
 806                                       &channel_retransmit_message,
 807                                       rel);
 808   }
 809 }
 810
 811
 812 /**
 813  * Save a copy to retransmit in case it gets lost.
 814  *
 815  * Initializes all needed callbacks and timers.
 816  *
 817  * @param ch Channel this message goes on.
 818  * @param msg Message to copy.
 819  * @param fwd Is this fwd traffic?
 820  */
 821 static struct MeshReliableMessage *
 822 channel_save_copy (struct MeshChannel *ch,
 823                    const struct GNUNET_MessageHeader *msg,
 824                    int fwd)
 825 {
 826   struct MeshChannelReliability *rel;
 827   struct MeshReliableMessage *copy;
 828   uint32_t mid;
 829   uint16_t type;
 830   uint16_t size;
 831
 832   rel = fwd ? ch->root_rel : ch->dest_rel;
 833   mid = rel->mid_send - 1;
 834   type = ntohs (msg->type);
 835   size = ntohs (msg->size);
 836
 837   LOG (GNUNET_ERROR_TYPE_DEBUG, "!!! SAVE %u %s\n",
 838        mid, GNUNET_MESH_DEBUG_M2S (type));
 839   copy = GNUNET_malloc (sizeof (struct MeshReliableMessage) + size);
 840   copy->mid = mid;
 841   copy->rel = rel;
 842   copy->type = type;
 843   memcpy (&copy[1], msg, size);
 844   GNUNET_CONTAINER_DLL_insert_tail (rel->head_sent, rel->tail_sent, copy);
 845
 846   return copy;
 847 }
 848
 849
 850 /**
 851  * Create a new channel.
 852  *
 853  * @param t Tunnel this channel is in.
 854  * @param owner Client that owns the channel, NULL for foreign channels.
 855  * @param lid_root Local ID for root client.
 856  *
 857  * @return A new initialized channel. NULL on error.
 858  */
 859 static struct MeshChannel *
 860 channel_new (struct MeshTunnel3 *t,
 861              struct MeshClient *owner,
 862              MESH_ChannelNumber lid_root)
 863 {
 864   struct MeshChannel *ch;
 865
 866   ch = GNUNET_new (struct MeshChannel);
 867   ch->root = owner;
 868   ch->lid_root = lid_root;
 869   ch->t = t;
 870
 871   GNUNET_STATISTICS_update (stats, "# channels", 1, GNUNET_NO);
 872
 873   if (NULL != owner)
 874   {
 875     ch->gid = GMT_get_next_chid (t);
 876     GML_channel_add (owner, lid_root, ch);
 877   }
 878   GMT_add_channel (t, ch);
 879
 880   return ch;
 881 }
 882
 883
 884 /**
 885  * Set options in a channel, extracted from a bit flag field
 886  *
 887  * @param ch Channel to set options to.
 888  * @param options Bit array in host byte order.
 889  */
 890 static void
 891 channel_set_options (struct MeshChannel *ch, uint32_t options)
 892 {
 893   ch->nobuffer = (options & GNUNET_MESH_OPTION_NOBUFFER) != 0 ?
 894                  GNUNET_YES : GNUNET_NO;
 895   ch->reliable = (options & GNUNET_MESH_OPTION_RELIABLE) != 0 ?
 896                  GNUNET_YES : GNUNET_NO;
 897 }
 898
 899 static int
 900 is_loopback (const struct MeshChannel *ch)
 901 {
 902   if (NULL != ch->t)
 903     return GMT_is_loopback (ch->t);
 904
 905   return (NULL != ch->root && NULL != ch->dest);
 906 }
 907
 908
 909 /**
 910  * Handle a loopback message: call the appropriate handler for the message type.
 911  *
 912  * @param ch Channel this message is on.
 913  * @param msgh Message header.
 914  * @param fwd Is this FWD traffic?
 915  */
 916 void
 917 handle_loopback (struct MeshChannel *ch,
 918                  const struct GNUNET_MessageHeader *msgh,
 919                  int fwd)
 920 {
 921   uint16_t type;
 922
 923   type = ntohs (msgh->type);
 924   LOG (GNUNET_ERROR_TYPE_DEBUG,
 925        "Loopback %s %s message!\n",
 926        fwd ? "FWD" : "BCK", GNUNET_MESH_DEBUG_M2S (type));
 927
 928   switch (type)
 929   {
 930     case GNUNET_MESSAGE_TYPE_MESH_DATA:
 931       /* Don't send hop ACK, wait for client to ACK */
 932       GMCH_handle_data (ch, (struct GNUNET_MESH_Data *) msgh, fwd);
 933       break;
 934
 935     case GNUNET_MESSAGE_TYPE_MESH_DATA_ACK:
 936       GMCH_handle_data_ack (ch, (struct GNUNET_MESH_DataACK *) msgh, fwd);
 937       break;
 938
 939     case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_CREATE:
 940       GMCH_handle_create (ch->t,
 941                           (struct GNUNET_MESH_ChannelCreate *) msgh);
 942       break;
 943
 944     case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_ACK:
 945       GMCH_handle_ack (ch,
 946                        (struct GNUNET_MESH_ChannelManage *) msgh,
 947                        fwd);
 948       break;
 949
 950     case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_NACK:
 951       GMCH_handle_nack (ch);
 952       break;
 953
 954     case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_DESTROY:
 955       GMCH_handle_destroy (ch,
 956                            (struct GNUNET_MESH_ChannelManage *) msgh,
 957                            fwd);
 958       break;
 959
 960     default:
 961       GNUNET_break_op (0);
 962       LOG (GNUNET_ERROR_TYPE_DEBUG,
 963            "end-to-end message not known (%u)\n",
 964            ntohs (msgh->type));
 965   }
 966 }
 967
 968
 969
 970 /******************************************************************************/
 971 /********************************    API    ***********************************/
 972 /******************************************************************************/
 973
 974 /**
 975  * Destroy a channel and free all resources.
 976  *
 977  * @param ch Channel to destroy.
 978  */
 979 void
 980 GMCH_destroy (struct MeshChannel *ch)
 981 {
 982   struct MeshClient *c;
 983
 984   if (NULL == ch)
 985     return;
 986
 987   LOG (GNUNET_ERROR_TYPE_DEBUG, "destroying channel %s:%u\n",
 988               GMT_2s (ch->t), ch->gid);
 989   GMCH_debug (ch);
 990
 991   c = ch->root;
 992   if (NULL != c)
 993   {
 994     GML_channel_remove (c, ch->lid_root, ch);
 995   }
 996
 997   c = ch->dest;
 998   if (NULL != c)
 999   {
1000     GML_channel_remove (c, ch->lid_dest, ch);
1001   }
1002
1003   channel_rel_free_all (ch->root_rel);
1004   channel_rel_free_all (ch->dest_rel);
1005
1006   GMT_remove_channel (ch->t, ch);
1007   GNUNET_STATISTICS_update (stats, "# channels", -1, GNUNET_NO);
1008
1009   GNUNET_free (ch);
1010 }
1011
1012
1013 /**
1014  * Get channel ID.
1015  *
1016  * @param ch Channel.
1017  *
1018  * @return ID
1019  */
1020 MESH_ChannelNumber
1021 GMCH_get_id (const struct MeshChannel *ch)
1022 {
1023   return ch->gid;
1024 }
1025
1026
1027 /**
1028  * Get the channel tunnel.
1029  *
1030  * @param ch Channel to get the tunnel from.
1031  *
1032  * @return tunnel of the channel.
1033  */
1034 struct MeshTunnel3 *
1035 GMCH_get_tunnel (const struct MeshChannel *ch)
1036 {
1037   return ch->t;
1038 }
1039
1040
1041 /**
1042  * Get free buffer space towards the client on a specific channel.
1043  *
1044  * @param ch Channel.
1045  * @param fwd Is query about FWD traffic?
1046  *
1047  * @return Free buffer space [0 - 64]
1048  */
1049 unsigned int
1050 GMCH_get_buffer (struct MeshChannel *ch, int fwd)
1051 {
1052   struct MeshChannelReliability *rel;
1053
1054   rel = fwd ? ch->dest_rel : ch->root_rel;
1055
1056   /* If rel is NULL it means that the end is not yet created,
1057    * most probably is a loopback channel at the point of sending
1058    * the ChannelCreate to itself.
1059    */
1060   if (NULL == rel)
1061     return 64;
1062
1063   return (64 - rel->n_recv);
1064 }
1065
1066
1067 /**
1068  * Get flow control status of end point: is client allow to send?
1069  *
1070  * @param ch Channel.
1071  * @param fwd Is query about FWD traffic? (Request root status).
1072  *
1073  * @return #GNUNET_YES if client is allowed to send us data.
1074  */
1075 int
1076 GMCH_get_allowed (struct MeshChannel *ch, int fwd)
1077 {
1078   struct MeshChannelReliability *rel;
1079
1080   rel = fwd ? ch->root_rel : ch->dest_rel;
1081
1082   return rel->client_allowed;
1083 }
1084
1085
1086 /**
1087  * Is the root client for this channel on this peer?
1088  *
1089  * @param ch Channel.
1090  * @param fwd Is this for fwd traffic?
1091  *
1092  * @return #GNUNET_YES in case it is.
1093  */
1094 int
1095 GMCH_is_origin (struct MeshChannel *ch, int fwd)
1096 {
1097   struct MeshClient *c;
1098
1099   c = fwd ? ch->root : ch->dest;
1100   return NULL != c;
1101 }
1102
1103
1104 /**
1105  * Is the destination client for this channel on this peer?
1106  *
1107  * @param ch Channel.
1108  * @param fwd Is this for fwd traffic?
1109  *
1110  * @return #GNUNET_YES in case it is.
1111  */
1112 int
1113 GMCH_is_terminal (struct MeshChannel *ch, int fwd)
1114 {
1115   struct MeshClient *c;
1116
1117   c = fwd ? ch->dest : ch->root;
1118   return NULL != c;
1119 }
1120
1121
1122 /**
1123  * Notify the destination client that a new incoming channel was created.
1124  *
1125  * @param ch Channel that was created.
1126  */
1127 void
1128 GMCH_send_create (struct MeshChannel *ch)
1129 {
1130   uint32_t opt;
1131
1132   if (NULL == ch->dest)
1133     return;
1134
1135   opt = 0;
1136   opt |= GNUNET_YES == ch->reliable ? GNUNET_MESH_OPTION_RELIABLE : 0;
1137   opt |= GNUNET_YES == ch->nobuffer ? GNUNET_MESH_OPTION_NOBUFFER : 0;
1138   GML_send_channel_create (ch->dest, ch->lid_dest, ch->port, opt,
1139                            GMT_get_destination (ch->t));
1140
1141 }
1142
1143 /**
1144  * Notify a client that the channel is no longer valid.
1145  *
1146  * @param ch Channel that is destroyed.
1147  */
1148 void
1149 GMCH_send_destroy (struct MeshChannel *ch)
1150 {
1151   struct GNUNET_MESH_ChannelManage msg;
1152
1153   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_CHANNEL_DESTROY);
1154   msg.header.size = htons (sizeof (msg));
1155   msg.chid = htonl (ch->gid);
1156
1157   /* If root is not NULL, notify.
1158    * If it's NULL, check lid_root. When a local destroy comes in, root
1159    * is set to NULL but lid_root is left untouched. In this case, do nothing,
1160    * the client is the one who reuqested the channel to be destroyed.
1161    */
1162   if (NULL != ch->root)
1163     GML_send_channel_destroy (ch->root, ch->lid_root);
1164   else if (0 == ch->lid_root)
1165     GMCH_send_prebuilt_message (&msg.header, ch, GNUNET_NO, GNUNET_NO);
1166
1167   if (NULL != ch->dest)
1168     GML_send_channel_destroy (ch->dest, ch->lid_dest);
1169   else if (0 == ch->lid_dest)
1170     GMCH_send_prebuilt_message (&msg.header, ch, GNUNET_YES, GNUNET_NO);
1171 }
1172
1173
1174 /**
1175  * Send an end-to-end ACK message for the most recent in-sequence payload.
1176  *
1177  * If channel is not reliable, do nothing.
1178  *
1179  * @param ch Channel this is about.
1180  * @param fwd Is for FWD traffic? (ACK dest->owner)
1181  */
1182 void
1183 GMCH_send_data_ack (struct MeshChannel *ch, int fwd)
1184 {
1185   struct GNUNET_MESH_DataACK msg;
1186   struct MeshChannelReliability *rel;
1187   struct MeshReliableMessage *copy;
1188   unsigned int delta;
1189   uint64_t mask;
1190   uint32_t ack;
1191
1192   if (GNUNET_NO == ch->reliable)
1193   {
1194     return;
1195   }
1196   rel = fwd ? ch->dest_rel : ch->root_rel;
1197   ack = rel->mid_recv - 1;
1198   LOG (GNUNET_ERROR_TYPE_DEBUG,
1199               " !! Send DATA_ACK for %u\n",
1200               ack);
1201
1202   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_DATA_ACK);
1203   msg.header.size = htons (sizeof (msg));
1204   msg.chid = htonl (ch->gid);
1205   msg.futures = 0;
1206   for (copy = rel->head_recv; NULL != copy; copy = copy->next)
1207   {
1208     if (copy->type != GNUNET_MESSAGE_TYPE_MESH_DATA)
1209     {
1210       LOG (GNUNET_ERROR_TYPE_DEBUG,
1211            "!!  Type %s, expected DATA\n",
1212            GNUNET_MESH_DEBUG_M2S (copy->type));
1213       continue;
1214     }
1215     if (copy->mid == ack + 1)
1216     {
1217       ack++;
1218       continue;
1219     }
1220     delta = copy->mid - (ack + 1);
1221     if (63 < delta)
1222       break;
1223     mask = 0x1LL << delta;
1224     msg.futures |= mask;
1225     LOG (GNUNET_ERROR_TYPE_DEBUG,
1226          " !! setting bit for %u (delta %u) (%llX) -> %llX\n",
1227          copy->mid, delta, mask, msg.futures);
1228   }
1229   msg.mid = htonl (ack);
1230   LOG (GNUNET_ERROR_TYPE_DEBUG,
1231        "!!! ACK for %u, futures %llX\n",
1232        ack, msg.futures);
1233
1234   GMCH_send_prebuilt_message (&msg.header, ch, !fwd, GNUNET_NO);
1235   LOG (GNUNET_ERROR_TYPE_DEBUG, "send_data_ack END\n");
1236 }
1237
1238
1239 /**
1240  * Allow a client to send us more data, in case it was choked.
1241  *
1242  * @param ch Channel.
1243  * @param fwd Is this about FWD traffic? (Root client).
1244  */
1245 void
1246 GMCH_allow_client (struct MeshChannel *ch, int fwd)
1247 {
1248   struct MeshChannelReliability *rel;
1249   unsigned int buffer;
1250
1251   LOG (GNUNET_ERROR_TYPE_DEBUG, "GMCH allow\n");
1252
1253   if (MESH_CHANNEL_READY != ch->state)
1254   {
1255     LOG (GNUNET_ERROR_TYPE_DEBUG, " channel not ready yet!\n");
1256     return;
1257   }
1258
1259   if (GNUNET_YES == ch->reliable)
1260   {
1261     rel = fwd ? ch->root_rel : ch->dest_rel;
1262     if (NULL == rel)
1263     {
1264       GNUNET_break (0);
1265       return;
1266     }
1267     if (NULL != rel->head_sent && 64 <= rel->mid_send - rel->head_sent->mid)
1268     {
1269       LOG (GNUNET_ERROR_TYPE_DEBUG, " too big MID gap! Wait for ACK.\n");
1270       return;
1271     }
1272   }
1273
1274   if (is_loopback (ch))
1275     buffer = GMCH_get_buffer (ch, fwd);
1276   else
1277     buffer = GMT_get_connections_buffer (ch->t);
1278
1279   if (0 == buffer)
1280   {
1281     LOG (GNUNET_ERROR_TYPE_DEBUG, " no buffer space.\n");
1282     return;
1283   }
1284
1285   LOG (GNUNET_ERROR_TYPE_DEBUG, " buffer space %u, allowing\n", buffer);
1286   send_client_ack (ch, fwd);
1287 }
1288
1289
1290 /**
1291  * Log channel info.
1292  *
1293  * @param ch Channel.
1294  */
1295 void
1296 GMCH_debug (struct MeshChannel *ch)
1297 {
1298   if (NULL == ch)
1299   {
1300     LOG (GNUNET_ERROR_TYPE_DEBUG, "*** DEBUG NULL CHANNEL ***\n");
1301     return;
1302   }
1303   LOG (GNUNET_ERROR_TYPE_DEBUG, "Channel %s:%X (%p)\n",
1304               GMT_2s (ch->t), ch->gid, ch);
1305   LOG (GNUNET_ERROR_TYPE_DEBUG, "  root %p/%p\n",
1306               ch->root, ch->root_rel);
1307   if (NULL != ch->root)
1308   {
1309     LOG (GNUNET_ERROR_TYPE_DEBUG, "  cli %s\n", GML_2s (ch->root));
1310     LOG (GNUNET_ERROR_TYPE_DEBUG, "  ready %s\n",
1311                 ch->root_rel->client_ready ? "YES" : "NO");
1312     LOG (GNUNET_ERROR_TYPE_DEBUG, "  id %X\n", ch->lid_root);
1313   }
1314   LOG (GNUNET_ERROR_TYPE_DEBUG, "  dest %p/%p\n",
1315               ch->dest, ch->dest_rel);
1316   if (NULL != ch->dest)
1317   {
1318     LOG (GNUNET_ERROR_TYPE_DEBUG, "  cli %s\n", GML_2s (ch->dest));
1319     LOG (GNUNET_ERROR_TYPE_DEBUG, "  ready %s\n",
1320                 ch->dest_rel->client_ready ? "YES" : "NO");
1321     LOG (GNUNET_ERROR_TYPE_DEBUG, "  id %X\n", ch->lid_dest);
1322   }
1323 }
1324
1325
1326 /**
1327  * Handle an ACK given by a client.
1328  *
1329  * Mark client as ready and send him any buffered data we could have for him.
1330  *
1331  * @param ch Channel.
1332  * @param fwd Is this a "FWD ACK"? (FWD ACKs are sent by dest and go BCK)
1333  */
1334 void
1335 GMCH_handle_local_ack (struct MeshChannel *ch, int fwd)
1336 {
1337   struct MeshChannelReliability *rel;
1338   struct MeshClient *c;
1339
1340   rel = fwd ? ch->dest_rel : ch->root_rel;
1341   c   = fwd ? ch->dest     : ch->root;
1342
1343   rel->client_ready = GNUNET_YES;
1344   send_client_buffered_data (ch, c, fwd);
1345   if (is_loopback (ch))
1346   {
1347     unsigned int buffer;
1348
1349     buffer = GMCH_get_buffer (ch, fwd);
1350     if (0 < buffer)
1351       GMCH_allow_client (ch, fwd);
1352
1353     return;
1354   }
1355   GMT_send_connection_acks (ch->t);
1356 }
1357
1358
1359 /**
1360  * Handle data given by a client.
1361  *
1362  * Check whether the client is allowed to send in this tunnel, save if channel
1363  * is reliable and send an ACK to the client if there is still buffer space
1364  * in the tunnel.
1365  *
1366  * @param ch Channel.
1367  * @param c Client which sent the data.
1368  * @param message Message.
1369  * @param fwd Is this a FWD data?
1370  *
1371  * @return GNUNET_OK if everything goes well, GNUNET_SYSERR in case of en error.
1372  */
1373 int
1374 GMCH_handle_local_data (struct MeshChannel *ch,
1375                         struct MeshClient *c,
1376                         struct GNUNET_MessageHeader *message,
1377                         int fwd)
1378 {
1379   struct MeshChannelReliability *rel;
1380   struct GNUNET_MESH_Data *payload;
1381   size_t size = ntohs (message->size);
1382   uint16_t p2p_size = sizeof(struct GNUNET_MESH_Data) + size;
1383   unsigned char cbuf[p2p_size];
1384
1385   /* Is the client in the channel? */
1386   if ( !( (fwd &&
1387            ch->root == c)
1388          ||
1389           (!fwd &&
1390            ch->dest == c) ) )
1391   {
1392     GNUNET_break_op (0);
1393     return GNUNET_SYSERR;
1394   }
1395
1396   rel = fwd ? ch->root_rel : ch->dest_rel;
1397
1398   if (GNUNET_NO == rel->client_allowed)
1399   {
1400     GNUNET_break_op (0);
1401     return GNUNET_SYSERR;
1402   }
1403
1404   rel->client_allowed = GNUNET_NO;
1405
1406   /* Ok, everything is correct, send the message. */
1407   payload = (struct GNUNET_MESH_Data *) cbuf;
1408   payload->mid = htonl (rel->mid_send);
1409   rel->mid_send++;
1410   memcpy (&payload[1], message, size);
1411   payload->header.size = htons (p2p_size);
1412   payload->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_DATA);
1413   payload->chid = htonl (ch->gid);
1414   LOG (GNUNET_ERROR_TYPE_DEBUG, "  sending on channel...\n");
1415   GMCH_send_prebuilt_message (&payload->header, ch, fwd, GNUNET_NO);
1416
1417   if (is_loopback (ch))
1418   {
1419     if (GMCH_get_buffer (ch, fwd) > 0)
1420       send_client_ack (ch, fwd);
1421
1422     return GNUNET_OK;
1423   }
1424
1425   if (GMT_get_connections_buffer (ch->t) > 0)
1426   {
1427     send_client_ack (ch, fwd);
1428   }
1429
1430   return GNUNET_OK;
1431 }
1432
1433
1434 /**
1435  * Handle a channel destroy requested by a client.
1436  *
1437  * Destroy the channel and the tunnel in case this was the last channel.
1438  *
1439  * @param ch Channel.
1440  * @param c Client that requested the destruction (to avoid notifying him).
1441  * @param is_root Is the request coming from root?
1442  */
1443 void
1444 GMCH_handle_local_destroy (struct MeshChannel *ch,
1445                            struct MeshClient *c,
1446                            int is_root)
1447 {
1448   struct MeshTunnel3 *t;
1449
1450   /* Cleanup after the tunnel */
1451   if (GNUNET_NO == is_root && c == ch->dest)
1452   {
1453     LOG (GNUNET_ERROR_TYPE_DEBUG, " Client %s is destination.\n", GML_2s (c));
1454     GML_client_delete_channel (c, ch, ch->lid_dest);
1455     ch->dest = NULL;
1456   }
1457   if (GNUNET_YES == is_root && c == ch->root)
1458   {
1459     LOG (GNUNET_ERROR_TYPE_DEBUG, " Client %s is owner.\n", GML_2s (c));
1460     GML_client_delete_channel (c, ch, ch->lid_root);
1461     ch->root = NULL;
1462   }
1463
1464   t = ch->t;
1465   GMCH_send_destroy (ch);
1466   GMCH_destroy (ch);
1467   GMT_destroy_if_empty (t);
1468 }
1469
1470
1471 /**
1472  * Handle a channel create requested by a client.
1473  *
1474  * Create the channel and the tunnel in case this was the first0 channel.
1475  *
1476  * @param c Client that requested the creation (will be the root).
1477  * @param msg Create Channel message.
1478  *
1479  * @return GNUNET_OK if everything went fine, GNUNET_SYSERR otherwise.
1480  */
1481 int
1482 GMCH_handle_local_create (struct MeshClient *c,
1483                           struct GNUNET_MESH_ChannelMessage *msg)
1484 {
1485   struct MeshChannel *ch;
1486   struct MeshTunnel3 *t;
1487   struct MeshPeer *peer;
1488   MESH_ChannelNumber chid;
1489
1490   LOG (GNUNET_ERROR_TYPE_DEBUG, "  towards %s:%u\n",
1491               GNUNET_i2s (&msg->peer), ntohl (msg->port));
1492   chid = ntohl (msg->channel_id);
1493
1494   /* Sanity check for duplicate channel IDs */
1495   if (NULL != GML_channel_get (c, chid))
1496   {
1497     GNUNET_break (0);
1498     return GNUNET_SYSERR;
1499   }
1500
1501   peer = GMP_get (&msg->peer);
1502   GMP_add_tunnel (peer);
1503   t = GMP_get_tunnel (peer);
1504
1505   if (GMP_get_short_id (peer) == myid)
1506   {
1507     GMT_change_state (t, MESH_TUNNEL3_READY);
1508   }
1509   else
1510   {
1511     GMP_connect (peer);
1512   }
1513
1514   /* Create channel */
1515   ch = channel_new (t, c, chid);
1516   if (NULL == ch)
1517   {
1518     GNUNET_break (0);
1519     return GNUNET_SYSERR;
1520   }
1521   ch->port = ntohl (msg->port);
1522   channel_set_options (ch, ntohl (msg->opt));
1523
1524   /* In unreliable channels, we'll use the DLL to buffer BCK data */
1525   ch->root_rel = GNUNET_new (struct MeshChannelReliability);
1526   ch->root_rel->ch = ch;
1527   ch->root_rel->expected_delay = MESH_RETRANSMIT_TIME;
1528
1529   LOG (GNUNET_ERROR_TYPE_DEBUG, "CREATED CHANNEL %s\n", GMCH_2s (ch));
1530
1531   /* Send create channel */
1532   {
1533     struct GNUNET_MESH_ChannelCreate msgcc;
1534
1535     msgcc.header.size = htons (sizeof (msgcc));
1536     msgcc.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_CHANNEL_CREATE);
1537     msgcc.chid = htonl (ch->gid);
1538     msgcc.port = msg->port;
1539     msgcc.opt = msg->opt;
1540
1541     GMT_send_prebuilt_message (&msgcc.header, t, ch, GNUNET_YES, NULL, NULL);
1542   }
1543   return GNUNET_OK;
1544 }
1545
1546
1547 /**
1548  * Handler for mesh network payload traffic.
1549  *
1550  * @param ch Channel for the message.
1551  * @param msg Unencryted data message.
1552  * @param fwd Is this message fwd? This only is meaningful in loopback channels.
1553  *            #GNUNET_YES if message is FWD on the respective channel (loopback)
1554  *            #GNUNET_NO if message is BCK on the respective channel (loopback)
1555  *            #GNUNET_SYSERR if message on a one-ended channel (remote)
1556  */
1557 void
1558 GMCH_handle_data (struct MeshChannel *ch,
1559                   const struct GNUNET_MESH_Data *msg,
1560                   int fwd)
1561 {
1562   struct MeshChannelReliability *rel;
1563   struct MeshClient *c;
1564   uint32_t mid;
1565
1566   /* If this is a remote (non-loopback) channel, find 'fwd'. */
1567   if (GNUNET_SYSERR == fwd)
1568   {
1569     if (is_loopback (ch))
1570     {
1571       /* It is a loopback channel after all... */
1572       GNUNET_break (0);
1573       return;
1574     }
1575     fwd = (NULL != ch->dest) ? GNUNET_YES : GNUNET_NO;
1576   }
1577
1578   /*  Initialize FWD/BCK data */
1579   c   = fwd ? ch->dest     : ch->root;
1580   rel = fwd ? ch->dest_rel : ch->root_rel;
1581
1582   if (NULL == c)
1583   {
1584     GNUNET_break (0);
1585     return;
1586   }
1587
1588   GNUNET_STATISTICS_update (stats, "# data received", 1, GNUNET_NO);
1589
1590   mid = ntohl (msg->mid);
1591   LOG (GNUNET_ERROR_TYPE_DEBUG, "!! got mid %u\n", mid);
1592
1593   if (GNUNET_NO == ch->reliable ||
1594       ( !GMC_is_pid_bigger (rel->mid_recv, mid) &&
1595         GMC_is_pid_bigger (rel->mid_recv + 64, mid) ) )
1596   {
1597     LOG (GNUNET_ERROR_TYPE_DEBUG, "!!! RECV %u\n", mid);
1598     if (GNUNET_YES == ch->reliable)
1599     {
1600       /* Is this the exact next expected messasge? */
1601       if (mid == rel->mid_recv)
1602       {
1603         LOG (GNUNET_ERROR_TYPE_DEBUG, "as expected\n");
1604         rel->mid_recv++;
1605         send_client_data (ch, msg, fwd);
1606       }
1607       else
1608       {
1609         LOG (GNUNET_ERROR_TYPE_DEBUG, "save for later\n");
1610         add_buffered_data (msg, rel);
1611       }
1612     }
1613     else
1614     {
1615       /* Tunnel is unreliable: send to clients directly */
1616       /* FIXME: accept Out Of Order traffic */
1617       rel->mid_recv = mid + 1;
1618       send_client_data (ch, msg, fwd);
1619     }
1620   }
1621   else
1622   {
1623     GNUNET_break_op (0);
1624     LOG (GNUNET_ERROR_TYPE_DEBUG,
1625                 " MID %u not expected (%u - %u), dropping!\n",
1626                 mid, rel->mid_recv, rel->mid_recv + 63);
1627   }
1628
1629   GMCH_send_data_ack (ch, fwd);
1630 }
1631
1632
1633 /**
1634  * Handler for mesh network traffic end-to-end ACKs.
1635  *
1636  * @param ch Channel on which we got this message.
1637  * @param msg Data message.
1638  * @param fwd Is this message fwd? This only is meaningful in loopback channels.
1639  *            #GNUNET_YES if message is FWD on the respective channel (loopback)
1640  *            #GNUNET_NO if message is BCK on the respective channel (loopback)
1641  *            #GNUNET_SYSERR if message on a one-ended channel (remote)
1642  */
1643 void
1644 GMCH_handle_data_ack (struct MeshChannel *ch,
1645                       const struct GNUNET_MESH_DataACK *msg,
1646                       int fwd)
1647 {
1648   struct MeshChannelReliability *rel;
1649   struct MeshReliableMessage *copy;
1650   struct MeshReliableMessage *next;
1651   uint32_t ack;
1652   int work;
1653
1654   /* If this is a remote (non-loopback) channel, find 'fwd'. */
1655   if (GNUNET_SYSERR == fwd)
1656   {
1657     if (is_loopback (ch))
1658     {
1659       /* It is a loopback channel after all... */
1660       GNUNET_break (0);
1661       return;
1662     }
1663     /* Inverted: if message came 'FWD' is a 'BCK ACK'. */
1664     fwd = (NULL != ch->dest) ? GNUNET_NO : GNUNET_YES;
1665   }
1666
1667   ack = ntohl (msg->mid);
1668   LOG (GNUNET_ERROR_TYPE_DEBUG, "!!! %s ACK %u\n",
1669        (GNUNET_YES == fwd) ? "FWD" : "BCK", ack);
1670
1671   if (GNUNET_YES == fwd)
1672   {
1673     rel = ch->root_rel;
1674   }
1675   else
1676   {
1677     rel = ch->dest_rel;
1678   }
1679   if (NULL == rel)
1680   {
1681     GNUNET_break_op (0);
1682     return;
1683   }
1684
1685   /* Free ACK'd copies: no need to retransmit those anymore */
1686   for (work = GNUNET_NO, copy = rel->head_sent; copy != NULL; copy = next)
1687   {
1688     if (GMC_is_pid_bigger (copy->mid, ack))
1689     {
1690       LOG (GNUNET_ERROR_TYPE_DEBUG, "!!!  head %u, out!\n", copy->mid);
1691       channel_rel_free_sent (rel, msg);
1692       break;
1693     }
1694     work = GNUNET_YES;
1695     LOG (GNUNET_ERROR_TYPE_DEBUG, " !!  id %u\n", copy->mid);
1696     next = copy->next;
1697     rel_message_free (copy, GNUNET_YES);
1698   }
1699
1700   /* ACK client if needed */
1701   GMCH_allow_client (ch, fwd);
1702
1703   /* If some message was free'd, update the retransmission delay */
1704   if (GNUNET_YES == work)
1705   {
1706     if (GNUNET_SCHEDULER_NO_TASK != rel->retry_task)
1707     {
1708       GNUNET_SCHEDULER_cancel (rel->retry_task);
1709       if (NULL == rel->head_sent)
1710       {
1711         rel->retry_task = GNUNET_SCHEDULER_NO_TASK;
1712       }
1713       else
1714       {
1715         struct GNUNET_TIME_Absolute new_target;
1716         struct GNUNET_TIME_Relative delay;
1717
1718         delay = GNUNET_TIME_relative_multiply (rel->retry_timer,
1719                                                MESH_RETRANSMIT_MARGIN);
1720         new_target = GNUNET_TIME_absolute_add (rel->head_sent->timestamp,
1721                                                delay);
1722         delay = GNUNET_TIME_absolute_get_remaining (new_target);
1723         rel->retry_task =
1724             GNUNET_SCHEDULER_add_delayed (delay,
1725                                           &channel_retransmit_message,
1726                                           rel);
1727       }
1728     }
1729     else
1730       GNUNET_break (0);
1731   }
1732 }
1733
1734
1735 /**
1736  * Handler for channel create messages.
1737  *
1738  * Does not have fwd parameter because it's always 'FWD': channel is incoming.
1739  *
1740  * @param t Tunnel this channel will be in.
1741  * @param msg Channel crate message.
1742  */
1743 struct MeshChannel *
1744 GMCH_handle_create (struct MeshTunnel3 *t,
1745                     const struct GNUNET_MESH_ChannelCreate *msg)
1746 {
1747   MESH_ChannelNumber chid;
1748   struct MeshChannel *ch;
1749   struct MeshClient *c;
1750
1751   chid = ntohl (msg->chid);
1752
1753   ch = GMT_get_channel (t, chid);
1754   if (NULL == ch)
1755   {
1756     /* Create channel */
1757     ch = channel_new (t, NULL, 0);
1758     ch->gid = chid;
1759   }
1760   channel_set_options (ch, ntohl (msg->opt));
1761
1762   /* Find a destination client */
1763   ch->port = ntohl (msg->port);
1764   LOG (GNUNET_ERROR_TYPE_DEBUG, "   port %u\n", ch->port);
1765   c = GML_client_get_by_port (ch->port);
1766   if (NULL == c)
1767   {
1768     /* TODO send reject */
1769     LOG (GNUNET_ERROR_TYPE_DEBUG, "  no client has port registered\n");
1770     if (is_loopback (ch))
1771     {
1772       LOG (GNUNET_ERROR_TYPE_DEBUG, "  loopback: destroy on handler\n");
1773       channel_send_nack (ch);
1774     }
1775     else
1776     {
1777       LOG (GNUNET_ERROR_TYPE_DEBUG, "  not loopback: destroy now\n");
1778       channel_send_nack (ch);
1779       GMCH_destroy (ch);
1780     }
1781     return NULL;
1782   }
1783   else
1784   {
1785     LOG (GNUNET_ERROR_TYPE_DEBUG, "  client %p has port registered\n", c);
1786   }
1787
1788   add_destination (ch, c);
1789   if (GNUNET_YES == ch->reliable)
1790     LOG (GNUNET_ERROR_TYPE_DEBUG, "!!! Reliable\n");
1791   else
1792     LOG (GNUNET_ERROR_TYPE_DEBUG, "!!! Not Reliable\n");
1793
1794   GMCH_send_create (ch);
1795   channel_send_ack (ch, GNUNET_YES);
1796
1797   return ch;
1798 }
1799
1800
1801 /**
1802  * Handler for channel NACK messages.
1803  *
1804  * NACK messages always go dest -> root, no need for 'fwd' or 'msg' parameter.
1805  *
1806  * @param ch Channel.
1807  */
1808 void
1809 GMCH_handle_nack (struct MeshChannel *ch)
1810 {
1811   send_client_nack (ch);
1812   GMCH_destroy (ch);
1813 }
1814
1815
1816 /**
1817  * Handler for channel ack messages.
1818  *
1819  * @param ch Channel.
1820  * @param msg Message.
1821  * @param fwd Is this message fwd? This only is meaningful in loopback channels.
1822  *            #GNUNET_YES if message is FWD on the respective channel (loopback)
1823  *            #GNUNET_NO if message is BCK on the respective channel (loopback)
1824  *            #GNUNET_SYSERR if message on a one-ended channel (remote)
1825  */
1826 void
1827 GMCH_handle_ack (struct MeshChannel *ch,
1828                  const struct GNUNET_MESH_ChannelManage *msg,
1829                  int fwd)
1830 {
1831   /* If this is a remote (non-loopback) channel, find 'fwd'. */
1832   if (GNUNET_SYSERR == fwd)
1833   {
1834     if (is_loopback (ch))
1835     {
1836       /* It is a loopback channel after all... */
1837       GNUNET_break (0);
1838       return;
1839     }
1840     fwd = (NULL != ch->dest) ? GNUNET_YES : GNUNET_NO;
1841   }
1842
1843   channel_confirm (ch, !fwd);
1844 }
1845
1846
1847 /**
1848  * Handler for channel destroy messages.
1849  *
1850  * @param ch Channel to be destroyed of.
1851  * @param msg Message.
1852  * @param fwd Is this message fwd? This only is meaningful in loopback channels.
1853  *            #GNUNET_YES if message is FWD on the respective channel (loopback)
1854  *            #GNUNET_NO if message is BCK on the respective channel (loopback)
1855  *            #GNUNET_SYSERR if message on a one-ended channel (remote)
1856  */
1857 void
1858 GMCH_handle_destroy (struct MeshChannel *ch,
1859                      const struct GNUNET_MESH_ChannelManage *msg,
1860                      int fwd)
1861 {
1862   struct MeshTunnel3 *t;
1863
1864   /* If this is a remote (non-loopback) channel, find 'fwd'. */
1865   if (GNUNET_SYSERR == fwd)
1866   {
1867     if (is_loopback (ch))
1868     {
1869       /* It is a loopback channel after all... */
1870       GNUNET_break (0);
1871       return;
1872     }
1873     fwd = (NULL != ch->dest) ? GNUNET_YES : GNUNET_NO;
1874   }
1875
1876   GMCH_debug (ch);
1877   if ( (fwd && NULL == ch->dest) || (!fwd && NULL == ch->root) )
1878   {
1879     /* Not for us (don't destroy twice a half-open loopback channel) */
1880     return;
1881   }
1882
1883   t = ch->t;
1884   GMCH_send_destroy (ch);
1885   GMCH_destroy (ch);
1886   GMT_destroy_if_empty (t);
1887 }
1888
1889
1890 /**
1891  * Sends an already built message on a channel.
1892  *
1893  * If the channel is on a loopback tunnel, notifies the appropriate destination
1894  * client locally.
1895  *
1896  * On a normal channel passes the message to the tunnel for encryption and
1897  * sending on a connection.
1898  *
1899  * This function DOES NOT save the message for retransmission.
1900  *
1901  * @param message Message to send. Function makes a copy of it.
1902  * @param ch Channel on which this message is transmitted.
1903  * @param fwd Is this a fwd message?
1904  * @param retransmission Is this a retransmission? (Don't save a copy)
1905  */
1906 void
1907 GMCH_send_prebuilt_message (const struct GNUNET_MessageHeader *message,
1908                             struct MeshChannel *ch, int fwd,
1909                             int retransmission)
1910 {
1911   LOG (GNUNET_ERROR_TYPE_DEBUG, "GMCH Send %s %s on channel %s\n",
1912        fwd ? "FWD" : "BCK", GNUNET_MESH_DEBUG_M2S (ntohs (message->type)),
1913        GMCH_2s (ch));
1914
1915   if (GMT_is_loopback (ch->t))
1916   {
1917     handle_loopback (ch, message, fwd);
1918     return;
1919   }
1920
1921   if (GNUNET_YES == ch->reliable && GNUNET_NO == retransmission
1922       && ntohs (message->type) == GNUNET_MESSAGE_TYPE_MESH_DATA)
1923   {
1924     struct MeshReliableMessage *copy;
1925
1926     copy = channel_save_copy (ch, message, fwd);
1927     copy->q = GMT_send_prebuilt_message (message, ch->t, ch, fwd,
1928                                          &message_sent, copy);
1929   }
1930   else
1931     GMT_send_prebuilt_message (message, ch->t, ch, fwd, NULL, NULL);
1932 }
1933
1934
1935 /**
1936  * Get the static string for identification of the channel.
1937  *
1938  * @param ch Channel.
1939  *
1940  * @return Static string with the channel IDs.
1941  */
1942 const char *
1943 GMCH_2s (const struct MeshChannel *ch)
1944 {
1945   static char buf[64];
1946
1947   if (NULL == ch)
1948     return "(NULL Channel)";
1949
1950   sprintf (buf, "%s:%u gid:%X (%X / %X)",
1951            GMT_2s (ch->t), ch->port, ch->gid, ch->lid_root, ch->lid_dest);
1952
1953   return buf;
1954 }