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