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  * Destroy a channel and free all resources.
 852  *
 853  * @param ch Channel to destroy.
 854  */
 855 static void
 856 channel_destroy (struct MeshChannel *ch)
 857 {
 858   struct MeshClient *c;
 859
 860   if (NULL == ch)
 861     return;
 862
 863   LOG (GNUNET_ERROR_TYPE_DEBUG, "destroying channel %s:%u\n",
 864               GMT_2s (ch->t), ch->gid);
 865   GMCH_debug (ch);
 866
 867   c = ch->root;
 868   if (NULL != c)
 869   {
 870     GML_channel_remove (c, ch->lid_root, ch);
 871   }
 872
 873   c = ch->dest;
 874   if (NULL != c)
 875   {
 876     GML_channel_remove (c, ch->lid_dest, ch);
 877   }
 878
 879   channel_rel_free_all (ch->root_rel);
 880   channel_rel_free_all (ch->dest_rel);
 881
 882   GMT_remove_channel (ch->t, ch);
 883   GNUNET_STATISTICS_update (stats, "# channels", -1, GNUNET_NO);
 884
 885   GNUNET_free (ch);
 886 }
 887
 888
 889 /**
 890  * Create a new channel.
 891  *
 892  * @param t Tunnel this channel is in.
 893  * @param owner Client that owns the channel, NULL for foreign channels.
 894  * @param lid_root Local ID for root client.
 895  *
 896  * @return A new initialized channel. NULL on error.
 897  */
 898 static struct MeshChannel *
 899 channel_new (struct MeshTunnel3 *t,
 900              struct MeshClient *owner,
 901              MESH_ChannelNumber lid_root)
 902 {
 903   struct MeshChannel *ch;
 904
 905   ch = GNUNET_new (struct MeshChannel);
 906   ch->root = owner;
 907   ch->lid_root = lid_root;
 908   ch->t = t;
 909
 910   GNUNET_STATISTICS_update (stats, "# channels", 1, GNUNET_NO);
 911
 912   if (NULL != owner)
 913   {
 914     ch->gid = GMT_get_next_chid (t);
 915     GML_channel_add (owner, lid_root, ch);
 916   }
 917   GMT_add_channel (t, ch);
 918
 919   return ch;
 920 }
 921
 922
 923 /**
 924  * Set options in a channel, extracted from a bit flag field
 925  *
 926  * @param ch Channel to set options to.
 927  * @param options Bit array in host byte order.
 928  */
 929 static void
 930 channel_set_options (struct MeshChannel *ch, uint32_t options)
 931 {
 932   ch->nobuffer = (options & GNUNET_MESH_OPTION_NOBUFFER) != 0 ?
 933                  GNUNET_YES : GNUNET_NO;
 934   ch->reliable = (options & GNUNET_MESH_OPTION_RELIABLE) != 0 ?
 935                  GNUNET_YES : GNUNET_NO;
 936 }
 937
 938 static int
 939 is_loopback (const struct MeshChannel *ch)
 940 {
 941   if (NULL != ch->t)
 942     return GMT_is_loopback (ch->t);
 943
 944   return (NULL != ch->root && NULL != ch->dest);
 945 }
 946
 947
 948 /**
 949  * Handle a loopback message: call the appropriate handler for the message type.
 950  *
 951  * @param ch Channel this message is on.
 952  * @param msgh Message header.
 953  * @param fwd Is this FWD traffic?
 954  */
 955 void
 956 handle_loopback (struct MeshChannel *ch,
 957                  const struct GNUNET_MessageHeader *msgh,
 958                  int fwd)
 959 {
 960   uint16_t type;
 961
 962   type = ntohs (msgh->type);
 963   LOG (GNUNET_ERROR_TYPE_DEBUG,
 964        "Loopback %s %s message!\n",
 965        fwd ? "FWD" : "BCK", GNUNET_MESH_DEBUG_M2S (type));
 966
 967   switch (type)
 968   {
 969     case GNUNET_MESSAGE_TYPE_MESH_DATA:
 970       /* Don't send hop ACK, wait for client to ACK */
 971       GMCH_handle_data (ch, (struct GNUNET_MESH_Data *) msgh, fwd);
 972       break;
 973
 974     case GNUNET_MESSAGE_TYPE_MESH_DATA_ACK:
 975       GMCH_handle_data_ack (ch, (struct GNUNET_MESH_DataACK *) msgh, fwd);
 976       break;
 977
 978     case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_CREATE:
 979       GMCH_handle_create (ch->t,
 980                           (struct GNUNET_MESH_ChannelCreate *) msgh);
 981       break;
 982
 983     case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_ACK:
 984       GMCH_handle_ack (ch,
 985                        (struct GNUNET_MESH_ChannelManage *) msgh,
 986                        fwd);
 987       break;
 988
 989     case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_NACK:
 990       GMCH_handle_nack (ch);
 991       break;
 992
 993     case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_DESTROY:
 994       GMCH_handle_destroy (ch,
 995                            (struct GNUNET_MESH_ChannelManage *) msgh,
 996                            fwd);
 997       break;
 998
 999     default:
1000       GNUNET_break_op (0);
1001       LOG (GNUNET_ERROR_TYPE_DEBUG,
1002            "end-to-end message not known (%u)\n",
1003            ntohs (msgh->type));
1004   }
1005 }
1006
1007
1008
1009 /******************************************************************************/
1010 /********************************    API    ***********************************/
1011 /******************************************************************************/
1012
1013
1014 /**
1015  * Get channel ID.
1016  *
1017  * @param ch Channel.
1018  *
1019  * @return ID
1020  */
1021 MESH_ChannelNumber
1022 GMCH_get_id (const struct MeshChannel *ch)
1023 {
1024   return ch->gid;
1025 }
1026
1027
1028 /**
1029  * Get the channel tunnel.
1030  *
1031  * @param ch Channel to get the tunnel from.
1032  *
1033  * @return tunnel of the channel.
1034  */
1035 struct MeshTunnel3 *
1036 GMCH_get_tunnel (const struct MeshChannel *ch)
1037 {
1038   return ch->t;
1039 }
1040
1041
1042 /**
1043  * Get free buffer space towards the client on a specific channel.
1044  *
1045  * @param ch Channel.
1046  * @param fwd Is query about FWD traffic?
1047  *
1048  * @return Free buffer space [0 - 64]
1049  */
1050 unsigned int
1051 GMCH_get_buffer (struct MeshChannel *ch, int fwd)
1052 {
1053   struct MeshChannelReliability *rel;
1054
1055   rel = fwd ? ch->dest_rel : ch->root_rel;
1056
1057   /* If rel is NULL it means that the end is not yet created,
1058    * most probably is a loopback channel at the point of sending
1059    * the ChannelCreate to itself.
1060    */
1061   if (NULL == rel)
1062     return 64;
1063
1064   return (64 - rel->n_recv);
1065 }
1066
1067
1068 /**
1069  * Get flow control status of end point: is client allow to send?
1070  *
1071  * @param ch Channel.
1072  * @param fwd Is query about FWD traffic? (Request root status).
1073  *
1074  * @return #GNUNET_YES if client is allowed to send us data.
1075  */
1076 int
1077 GMCH_get_allowed (struct MeshChannel *ch, int fwd)
1078 {
1079   struct MeshChannelReliability *rel;
1080
1081   rel = fwd ? ch->root_rel : ch->dest_rel;
1082
1083   return rel->client_allowed;
1084 }
1085
1086
1087 /**
1088  * Is the root client for this channel on this peer?
1089  *
1090  * @param ch Channel.
1091  * @param fwd Is this for fwd traffic?
1092  *
1093  * @return #GNUNET_YES in case it is.
1094  */
1095 int
1096 GMCH_is_origin (struct MeshChannel *ch, int fwd)
1097 {
1098   struct MeshClient *c;
1099
1100   c = fwd ? ch->root : ch->dest;
1101   return NULL != c;
1102 }
1103
1104
1105 /**
1106  * Is the destination client for this channel on this peer?
1107  *
1108  * @param ch Channel.
1109  * @param fwd Is this for fwd traffic?
1110  *
1111  * @return #GNUNET_YES in case it is.
1112  */
1113 int
1114 GMCH_is_terminal (struct MeshChannel *ch, int fwd)
1115 {
1116   struct MeshClient *c;
1117
1118   c = fwd ? ch->dest : ch->root;
1119   return NULL != c;
1120 }
1121
1122
1123 /**
1124  * Notify the destination client that a new incoming channel was created.
1125  *
1126  * @param ch Channel that was created.
1127  */
1128 void
1129 GMCH_send_create (struct MeshChannel *ch)
1130 {
1131   uint32_t opt;
1132
1133   if (NULL == ch->dest)
1134     return;
1135
1136   opt = 0;
1137   opt |= GNUNET_YES == ch->reliable ? GNUNET_MESH_OPTION_RELIABLE : 0;
1138   opt |= GNUNET_YES == ch->nobuffer ? GNUNET_MESH_OPTION_NOBUFFER : 0;
1139   GML_send_channel_create (ch->dest, ch->lid_dest, ch->port, opt,
1140                            GMT_get_destination (ch->t));
1141
1142 }
1143
1144 /**
1145  * Notify a client that the channel is no longer valid.
1146  *
1147  * @param ch Channel that is destroyed.
1148  */
1149 void
1150 GMCH_send_destroy (struct MeshChannel *ch)
1151 {
1152   struct GNUNET_MESH_ChannelManage msg;
1153
1154   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_CHANNEL_DESTROY);
1155   msg.header.size = htons (sizeof (msg));
1156   msg.chid = htonl (ch->gid);
1157
1158   /* If root is not NULL, notify.
1159    * If it's NULL, check lid_root. When a local destroy comes in, root
1160    * is set to NULL but lid_root is left untouched. In this case, do nothing,
1161    * the client is the one who reuqested the channel to be destroyed.
1162    */
1163   if (NULL != ch->root)
1164     GML_send_channel_destroy (ch->root, ch->lid_root);
1165   else if (0 == ch->lid_root)
1166     GMCH_send_prebuilt_message (&msg.header, ch, GNUNET_NO, GNUNET_NO);
1167
1168   if (NULL != ch->dest)
1169     GML_send_channel_destroy (ch->dest, ch->lid_dest);
1170   else if (0 == ch->lid_dest)
1171     GMCH_send_prebuilt_message (&msg.header, ch, GNUNET_YES, GNUNET_NO);
1172 }
1173
1174
1175 /**
1176  * Send an end-to-end ACK message for the most recent in-sequence payload.
1177  *
1178  * If channel is not reliable, do nothing.
1179  *
1180  * @param ch Channel this is about.
1181  * @param fwd Is for FWD traffic? (ACK dest->owner)
1182  */
1183 void
1184 GMCH_send_data_ack (struct MeshChannel *ch, int fwd)
1185 {
1186   struct GNUNET_MESH_DataACK msg;
1187   struct MeshChannelReliability *rel;
1188   struct MeshReliableMessage *copy;
1189   unsigned int delta;
1190   uint64_t mask;
1191   uint32_t ack;
1192
1193   if (GNUNET_NO == ch->reliable)
1194   {
1195     return;
1196   }
1197   rel = fwd ? ch->dest_rel : ch->root_rel;
1198   ack = rel->mid_recv - 1;
1199   LOG (GNUNET_ERROR_TYPE_DEBUG,
1200               " !! Send DATA_ACK for %u\n",
1201               ack);
1202
1203   msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_DATA_ACK);
1204   msg.header.size = htons (sizeof (msg));
1205   msg.chid = htonl (ch->gid);
1206   msg.futures = 0;
1207   for (copy = rel->head_recv; NULL != copy; copy = copy->next)
1208   {
1209     if (copy->type != GNUNET_MESSAGE_TYPE_MESH_DATA)
1210     {
1211       LOG (GNUNET_ERROR_TYPE_DEBUG,
1212            "!!  Type %s, expected DATA\n",
1213            GNUNET_MESH_DEBUG_M2S (copy->type));
1214       continue;
1215     }
1216     if (copy->mid == ack + 1)
1217     {
1218       ack++;
1219       continue;
1220     }
1221     delta = copy->mid - (ack + 1);
1222     if (63 < delta)
1223       break;
1224     mask = 0x1LL << delta;
1225     msg.futures |= mask;
1226     LOG (GNUNET_ERROR_TYPE_DEBUG,
1227          " !! setting bit for %u (delta %u) (%llX) -> %llX\n",
1228          copy->mid, delta, mask, msg.futures);
1229   }
1230   msg.mid = htonl (ack);
1231   LOG (GNUNET_ERROR_TYPE_DEBUG,
1232        "!!! ACK for %u, futures %llX\n",
1233        ack, msg.futures);
1234
1235   GMCH_send_prebuilt_message (&msg.header, ch, !fwd, GNUNET_NO);
1236   LOG (GNUNET_ERROR_TYPE_DEBUG, "send_data_ack END\n");
1237 }
1238
1239
1240 /**
1241  * Allow a client to send us more data, in case it was choked.
1242  *
1243  * @param ch Channel.
1244  * @param fwd Is this about FWD traffic? (Root client).
1245  */
1246 void
1247 GMCH_allow_client (struct MeshChannel *ch, int fwd)
1248 {
1249   struct MeshChannelReliability *rel;
1250   unsigned int buffer;
1251
1252   LOG (GNUNET_ERROR_TYPE_DEBUG, "GMCH allow\n");
1253
1254   if (MESH_CHANNEL_READY != ch->state)
1255   {
1256     LOG (GNUNET_ERROR_TYPE_DEBUG, " channel not ready yet!\n");
1257     return;
1258   }
1259
1260   if (GNUNET_YES == ch->reliable)
1261   {
1262     rel = fwd ? ch->root_rel : ch->dest_rel;
1263     if (NULL == rel)
1264     {
1265       GNUNET_break (0);
1266       return;
1267     }
1268     if (NULL != rel->head_sent && 64 <= rel->mid_send - rel->head_sent->mid)
1269     {
1270       LOG (GNUNET_ERROR_TYPE_DEBUG, " too big MID gap! Wait for ACK.\n");
1271       return;
1272     }
1273   }
1274
1275   if (is_loopback (ch))
1276     buffer = GMCH_get_buffer (ch, fwd);
1277   else
1278     buffer = GMT_get_connections_buffer (ch->t);
1279
1280   if (0 == buffer)
1281   {
1282     LOG (GNUNET_ERROR_TYPE_DEBUG, " no buffer space.\n");
1283     return;
1284   }
1285
1286   LOG (GNUNET_ERROR_TYPE_DEBUG, " buffer space %u, allowing\n", buffer);
1287   send_client_ack (ch, fwd);
1288 }
1289
1290
1291 /**
1292  * Log channel info.
1293  *
1294  * @param ch Channel.
1295  */
1296 void
1297 GMCH_debug (struct MeshChannel *ch)
1298 {
1299   if (NULL == ch)
1300   {
1301     LOG (GNUNET_ERROR_TYPE_DEBUG, "*** DEBUG NULL CHANNEL ***\n");
1302     return;
1303   }
1304   LOG (GNUNET_ERROR_TYPE_DEBUG, "Channel %s:%X (%p)\n",
1305               GMT_2s (ch->t), ch->gid, ch);
1306   LOG (GNUNET_ERROR_TYPE_DEBUG, "  root %p/%p\n",
1307               ch->root, ch->root_rel);
1308   if (NULL != ch->root)
1309   {
1310     LOG (GNUNET_ERROR_TYPE_DEBUG, "  cli %s\n", GML_2s (ch->root));
1311     LOG (GNUNET_ERROR_TYPE_DEBUG, "  ready %s\n",
1312                 ch->root_rel->client_ready ? "YES" : "NO");
1313     LOG (GNUNET_ERROR_TYPE_DEBUG, "  id %X\n", ch->lid_root);
1314   }
1315   LOG (GNUNET_ERROR_TYPE_DEBUG, "  dest %p/%p\n",
1316               ch->dest, ch->dest_rel);
1317   if (NULL != ch->dest)
1318   {
1319     LOG (GNUNET_ERROR_TYPE_DEBUG, "  cli %s\n", GML_2s (ch->dest));
1320     LOG (GNUNET_ERROR_TYPE_DEBUG, "  ready %s\n",
1321                 ch->dest_rel->client_ready ? "YES" : "NO");
1322     LOG (GNUNET_ERROR_TYPE_DEBUG, "  id %X\n", ch->lid_dest);
1323   }
1324 }
1325
1326
1327 /**
1328  * Handle an ACK given by a client.
1329  *
1330  * Mark client as ready and send him any buffered data we could have for him.
1331  *
1332  * @param ch Channel.
1333  * @param fwd Is this a "FWD ACK"? (FWD ACKs are sent by dest and go BCK)
1334  */
1335 void
1336 GMCH_handle_local_ack (struct MeshChannel *ch, int fwd)
1337 {
1338   struct MeshChannelReliability *rel;
1339   struct MeshClient *c;
1340
1341   rel = fwd ? ch->dest_rel : ch->root_rel;
1342   c   = fwd ? ch->dest     : ch->root;
1343
1344   rel->client_ready = GNUNET_YES;
1345   send_client_buffered_data (ch, c, fwd);
1346   if (is_loopback (ch))
1347   {
1348     unsigned int buffer;
1349
1350     buffer = GMCH_get_buffer (ch, fwd);
1351     if (0 < buffer)
1352       GMCH_allow_client (ch, fwd);
1353
1354     return;
1355   }
1356   GMT_send_connection_acks (ch->t);
1357 }
1358
1359
1360 /**
1361  * Handle data given by a client.
1362  *
1363  * Check whether the client is allowed to send in this tunnel, save if channel
1364  * is reliable and send an ACK to the client if there is still buffer space
1365  * in the tunnel.
1366  *
1367  * @param ch Channel.
1368  * @param c Client which sent the data.
1369  * @param message Message.
1370  * @param fwd Is this a FWD data?
1371  *
1372  * @return GNUNET_OK if everything goes well, GNUNET_SYSERR in case of en error.
1373  */
1374 int
1375 GMCH_handle_local_data (struct MeshChannel *ch,
1376                         struct MeshClient *c,
1377                         struct GNUNET_MessageHeader *message,
1378                         int fwd)
1379 {
1380   struct MeshChannelReliability *rel;
1381   struct GNUNET_MESH_Data *payload;
1382   size_t size = ntohs (message->size);
1383   uint16_t p2p_size = sizeof(struct GNUNET_MESH_Data) + size;
1384   unsigned char cbuf[p2p_size];
1385
1386   /* Is the client in the channel? */
1387   if ( !( (fwd &&
1388            ch->root == c)
1389          ||
1390           (!fwd &&
1391            ch->dest == c) ) )
1392   {
1393     GNUNET_break_op (0);
1394     return GNUNET_SYSERR;
1395   }
1396
1397   rel = fwd ? ch->root_rel : ch->dest_rel;
1398
1399   if (GNUNET_NO == rel->client_allowed)
1400   {
1401     GNUNET_break_op (0);
1402     return GNUNET_SYSERR;
1403   }
1404
1405   rel->client_allowed = GNUNET_NO;
1406
1407   /* Ok, everything is correct, send the message. */
1408   payload = (struct GNUNET_MESH_Data *) cbuf;
1409   payload->mid = htonl (rel->mid_send);
1410   rel->mid_send++;
1411   memcpy (&payload[1], message, size);
1412   payload->header.size = htons (p2p_size);
1413   payload->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_DATA);
1414   payload->chid = htonl (ch->gid);
1415   LOG (GNUNET_ERROR_TYPE_DEBUG, "  sending on channel...\n");
1416   GMCH_send_prebuilt_message (&payload->header, ch, fwd, GNUNET_NO);
1417
1418   if (is_loopback (ch))
1419   {
1420     if (GMCH_get_buffer (ch, fwd) > 0)
1421       send_client_ack (ch, fwd);
1422
1423     return GNUNET_OK;
1424   }
1425
1426   if (GMT_get_connections_buffer (ch->t) > 0)
1427   {
1428     send_client_ack (ch, fwd);
1429   }
1430
1431   return GNUNET_OK;
1432 }
1433
1434
1435 /**
1436  * Handle a channel destroy requested by a client.
1437  *
1438  * Destroy the channel and the tunnel in case this was the last channel.
1439  *
1440  * @param ch Channel.
1441  * @param c Client that requested the destruction (to avoid notifying him).
1442  */
1443 void
1444 GMCH_handle_local_destroy (struct MeshChannel *ch,
1445                            struct MeshClient *c)
1446 {
1447   struct MeshTunnel3 *t;
1448
1449   /* Cleanup after the tunnel */
1450   if (c == ch->dest)
1451   {
1452     LOG (GNUNET_ERROR_TYPE_DEBUG, " Client %s is destination.\n", GML_2s (c));
1453     GML_client_delete_channel (c, ch, ch->lid_dest);
1454     ch->dest = NULL;
1455   }
1456   if (c == ch->root)
1457   {
1458     LOG (GNUNET_ERROR_TYPE_DEBUG, " Client %s is owner.\n", GML_2s (c));
1459     GML_client_delete_channel (c, ch, ch->lid_root);
1460     ch->root = NULL;
1461   }
1462
1463   t = ch->t;
1464   GMCH_send_destroy (ch);
1465   channel_destroy (ch);
1466   GMT_destroy_if_empty (t);
1467 }
1468
1469
1470 /**
1471  * Handle a channel create requested by a client.
1472  *
1473  * Create the channel and the tunnel in case this was the first0 channel.
1474  *
1475  * @param c Client that requested the creation (will be the root).
1476  * @param msg Create Channel message.
1477  *
1478  * @return GNUNET_OK if everything went fine, GNUNET_SYSERR otherwise.
1479  */
1480 int
1481 GMCH_handle_local_create (struct MeshClient *c,
1482                           struct GNUNET_MESH_ChannelMessage *msg)
1483 {
1484   struct MeshChannel *ch;
1485   struct MeshTunnel3 *t;
1486   struct MeshPeer *peer;
1487   MESH_ChannelNumber chid;
1488
1489   LOG (GNUNET_ERROR_TYPE_DEBUG, "  towards %s:%u\n",
1490               GNUNET_i2s (&msg->peer), ntohl (msg->port));
1491   chid = ntohl (msg->channel_id);
1492
1493   /* Sanity check for duplicate channel IDs */
1494   if (NULL != GML_channel_get (c, chid))
1495   {
1496     GNUNET_break (0);
1497     return GNUNET_SYSERR;
1498   }
1499
1500   peer = GMP_get (&msg->peer);
1501   GMP_add_tunnel (peer);
1502   t = GMP_get_tunnel (peer);
1503
1504   if (GMP_get_short_id (peer) == myid)
1505   {
1506     GMT_change_state (t, MESH_TUNNEL3_READY);
1507   }
1508   else
1509   {
1510     GMP_connect (peer);
1511   }
1512
1513   /* Create channel */
1514   ch = channel_new (t, c, chid);
1515   if (NULL == ch)
1516   {
1517     GNUNET_break (0);
1518     return GNUNET_SYSERR;
1519   }
1520   ch->port = ntohl (msg->port);
1521   channel_set_options (ch, ntohl (msg->opt));
1522
1523   /* In unreliable channels, we'll use the DLL to buffer BCK data */
1524   ch->root_rel = GNUNET_new (struct MeshChannelReliability);
1525   ch->root_rel->ch = ch;
1526   ch->root_rel->expected_delay = MESH_RETRANSMIT_TIME;
1527
1528   LOG (GNUNET_ERROR_TYPE_DEBUG, "CREATED CHANNEL %s\n", GMCH_2s (ch));
1529
1530   /* Send create channel */
1531   {
1532     struct GNUNET_MESH_ChannelCreate msgcc;
1533
1534     msgcc.header.size = htons (sizeof (msgcc));
1535     msgcc.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_CHANNEL_CREATE);
1536     msgcc.chid = htonl (ch->gid);
1537     msgcc.port = msg->port;
1538     msgcc.opt = msg->opt;
1539
1540     GMT_send_prebuilt_message (&msgcc.header, t, ch, GNUNET_YES, NULL, NULL);
1541   }
1542   return GNUNET_OK;
1543 }
1544
1545
1546 /**
1547  * Handler for mesh network payload traffic.
1548  *
1549  * @param ch Channel for the message.
1550  * @param msg Unencryted data message.
1551  * @param fwd Is this message fwd? This only is meaningful in loopback channels.
1552  *            #GNUNET_YES if message is FWD on the respective channel (loopback)
1553  *            #GNUNET_NO if message is BCK on the respective channel (loopback)
1554  *            #GNUNET_SYSERR if message on a one-ended channel (remote)
1555  */
1556 void
1557 GMCH_handle_data (struct MeshChannel *ch,
1558                   const struct GNUNET_MESH_Data *msg,
1559                   int fwd)
1560 {
1561   struct MeshChannelReliability *rel;
1562   struct MeshClient *c;
1563   uint32_t mid;
1564
1565   /* If this is a remote (non-loopback) channel, find 'fwd'. */
1566   if (GNUNET_SYSERR == fwd)
1567   {
1568     if (is_loopback (ch))
1569     {
1570       /* It is a loopback channel after all... */
1571       GNUNET_break (0);
1572       return;
1573     }
1574     fwd = (NULL != ch->dest) ? GNUNET_YES : GNUNET_NO;
1575   }
1576
1577   /*  Initialize FWD/BCK data */
1578   c   = fwd ? ch->dest     : ch->root;
1579   rel = fwd ? ch->dest_rel : ch->root_rel;
1580
1581   if (NULL == c)
1582   {
1583     GNUNET_break (0);
1584     return;
1585   }
1586
1587   GNUNET_STATISTICS_update (stats, "# data received", 1, GNUNET_NO);
1588
1589   mid = ntohl (msg->mid);
1590   LOG (GNUNET_ERROR_TYPE_DEBUG, "!! got mid %u\n", mid);
1591
1592   if (GNUNET_NO == ch->reliable ||
1593       ( !GMC_is_pid_bigger (rel->mid_recv, mid) &&
1594         GMC_is_pid_bigger (rel->mid_recv + 64, mid) ) )
1595   {
1596     LOG (GNUNET_ERROR_TYPE_DEBUG, "!!! RECV %u\n", mid);
1597     if (GNUNET_YES == ch->reliable)
1598     {
1599       /* Is this the exact next expected messasge? */
1600       if (mid == rel->mid_recv)
1601       {
1602         LOG (GNUNET_ERROR_TYPE_DEBUG, "as expected\n");
1603         rel->mid_recv++;
1604         send_client_data (ch, msg, fwd);
1605       }
1606       else
1607       {
1608         LOG (GNUNET_ERROR_TYPE_DEBUG, "save for later\n");
1609         add_buffered_data (msg, rel);
1610       }
1611     }
1612     else
1613     {
1614       /* Tunnel is unreliable: send to clients directly */
1615       /* FIXME: accept Out Of Order traffic */
1616       rel->mid_recv = mid + 1;
1617       send_client_data (ch, msg, fwd);
1618     }
1619   }
1620   else
1621   {
1622     GNUNET_break_op (0);
1623     LOG (GNUNET_ERROR_TYPE_DEBUG,
1624                 " MID %u not expected (%u - %u), dropping!\n",
1625                 mid, rel->mid_recv, rel->mid_recv + 63);
1626   }
1627
1628   GMCH_send_data_ack (ch, fwd);
1629 }
1630
1631
1632 /**
1633  * Handler for mesh network traffic end-to-end ACKs.
1634  *
1635  * @param ch Channel on which we got this message.
1636  * @param msg Data message.
1637  * @param fwd Is this message fwd? This only is meaningful in loopback channels.
1638  *            #GNUNET_YES if message is FWD on the respective channel (loopback)
1639  *            #GNUNET_NO if message is BCK on the respective channel (loopback)
1640  *            #GNUNET_SYSERR if message on a one-ended channel (remote)
1641  */
1642 void
1643 GMCH_handle_data_ack (struct MeshChannel *ch,
1644                       const struct GNUNET_MESH_DataACK *msg,
1645                       int fwd)
1646 {
1647   struct MeshChannelReliability *rel;
1648   struct MeshReliableMessage *copy;
1649   struct MeshReliableMessage *next;
1650   uint32_t ack;
1651   int work;
1652
1653   /* If this is a remote (non-loopback) channel, find 'fwd'. */
1654   if (GNUNET_SYSERR == fwd)
1655   {
1656     if (is_loopback (ch))
1657     {
1658       /* It is a loopback channel after all... */
1659       GNUNET_break (0);
1660       return;
1661     }
1662     /* Inverted: if message came 'FWD' is a 'BCK ACK'. */
1663     fwd = (NULL != ch->dest) ? GNUNET_NO : GNUNET_YES;
1664   }
1665
1666   ack = ntohl (msg->mid);
1667   LOG (GNUNET_ERROR_TYPE_DEBUG, "!!! %s ACK %u\n",
1668        (GNUNET_YES == fwd) ? "FWD" : "BCK", ack);
1669
1670   if (GNUNET_YES == fwd)
1671   {
1672     rel = ch->root_rel;
1673   }
1674   else
1675   {
1676     rel = ch->dest_rel;
1677   }
1678   if (NULL == rel)
1679   {
1680     GNUNET_break_op (0);
1681     return;
1682   }
1683
1684   /* Free ACK'd copies: no need to retransmit those anymore */
1685   for (work = GNUNET_NO, copy = rel->head_sent; copy != NULL; copy = next)
1686   {
1687     if (GMC_is_pid_bigger (copy->mid, ack))
1688     {
1689       LOG (GNUNET_ERROR_TYPE_DEBUG, "!!!  head %u, out!\n", copy->mid);
1690       channel_rel_free_sent (rel, msg);
1691       break;
1692     }
1693     work = GNUNET_YES;
1694     LOG (GNUNET_ERROR_TYPE_DEBUG, " !!  id %u\n", copy->mid);
1695     next = copy->next;
1696     rel_message_free (copy, GNUNET_YES);
1697   }
1698
1699   /* ACK client if needed */
1700   GMCH_allow_client (ch, fwd);
1701
1702   /* If some message was free'd, update the retransmission delay */
1703   if (GNUNET_YES == work)
1704   {
1705     if (GNUNET_SCHEDULER_NO_TASK != rel->retry_task)
1706     {
1707       GNUNET_SCHEDULER_cancel (rel->retry_task);
1708       if (NULL == rel->head_sent)
1709       {
1710         rel->retry_task = GNUNET_SCHEDULER_NO_TASK;
1711       }
1712       else
1713       {
1714         struct GNUNET_TIME_Absolute new_target;
1715         struct GNUNET_TIME_Relative delay;
1716
1717         delay = GNUNET_TIME_relative_multiply (rel->retry_timer,
1718                                                MESH_RETRANSMIT_MARGIN);
1719         new_target = GNUNET_TIME_absolute_add (rel->head_sent->timestamp,
1720                                                delay);
1721         delay = GNUNET_TIME_absolute_get_remaining (new_target);
1722         rel->retry_task =
1723             GNUNET_SCHEDULER_add_delayed (delay,
1724                                           &channel_retransmit_message,
1725                                           rel);
1726       }
1727     }
1728     else
1729       GNUNET_break (0);
1730   }
1731 }
1732
1733
1734 /**
1735  * Handler for channel create messages.
1736  *
1737  * Does not have fwd parameter because it's always 'FWD': channel is incoming.
1738  *
1739  * @param t Tunnel this channel will be in.
1740  * @param msg Channel crate message.
1741  */
1742 struct MeshChannel *
1743 GMCH_handle_create (struct MeshTunnel3 *t,
1744                     const struct GNUNET_MESH_ChannelCreate *msg)
1745 {
1746   MESH_ChannelNumber chid;
1747   struct MeshChannel *ch;
1748   struct MeshClient *c;
1749   uint32_t port;
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   port = ntohl (msg->port);
1764   LOG (GNUNET_ERROR_TYPE_DEBUG, "   port %u\n", port);
1765   c = GML_client_get_by_port (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       channel_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   channel_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   channel_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:%X (%X / %X)",
1951            GMT_2s (ch->t), ch->gid, ch->lid_root, ch->lid_dest);
1952
1953   return buf;
1954 }