src/cadet/gnunet-service-cadet_connection.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2001-2013 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file cadet/gnunet-service-cadet_connection.c
  23  * @brief GNUnet CADET service connection handling
  24  * @author Bartlomiej Polot
  25  */
  26
  27 #include "platform.h"
  28 #include "gnunet_util_lib.h"
  29
  30 #include "gnunet_statistics_service.h"
  31
  32 #include "cadet_path.h"
  33 #include "cadet_protocol.h"
  34 #include "cadet.h"
  35 #include "gnunet-service-cadet_connection.h"
  36 #include "gnunet-service-cadet_peer.h"
  37 #include "gnunet-service-cadet_tunnel.h"
  38
  39
  40 #define LOG(level, ...) GNUNET_log_from (level,"cadet-con",__VA_ARGS__)
  41 #define LOG2(level, ...) GNUNET_log_from_nocheck(level,"cadet-con",__VA_ARGS__)
  42
  43
  44 #define CADET_MAX_POLL_TIME      GNUNET_TIME_relative_multiply (\
  45                                   GNUNET_TIME_UNIT_MINUTES,\
  46                                   10)
  47 #define AVG_MSGS                32
  48
  49
  50 /******************************************************************************/
  51 /********************************   STRUCTS  **********************************/
  52 /******************************************************************************/
  53
  54 /**
  55  * Struct to encapsulate all the Flow Control information to a peer to which
  56  * we are directly connected (on a core level).
  57  */
  58 struct CadetFlowControl
  59 {
  60   /**
  61    * Connection this controls.
  62    */
  63   struct CadetConnection *c;
  64
  65   /**
  66    * How many messages are in the queue on this connection.
  67    */
  68   unsigned int queue_n;
  69
  70   /**
  71    * How many messages do we accept in the queue.
  72    */
  73   unsigned int queue_max;
  74
  75   /**
  76    * ID of the last packet sent towards the peer.
  77    */
  78   uint32_t last_pid_sent;
  79
  80   /**
  81    * ID of the last packet received from the peer.
  82    */
  83   uint32_t last_pid_recv;
  84
  85   /**
  86    * Last ACK sent to the peer (peer can't send more than this PID).
  87    */
  88   uint32_t last_ack_sent;
  89
  90   /**
  91    * Last ACK sent towards the origin (for traffic towards leaf node).
  92    */
  93   uint32_t last_ack_recv;
  94
  95   /**
  96    * Task to poll the peer in case of a lost ACK causes stall.
  97    */
  98   GNUNET_SCHEDULER_TaskIdentifier poll_task;
  99
 100   /**
 101    * How frequently to poll for ACKs.
 102    */
 103   struct GNUNET_TIME_Relative poll_time;
 104
 105   /**
 106    * Queued poll message, to cancel if not necessary anymore (got ACK).
 107    */
 108   struct CadetConnectionQueue *poll_msg;
 109
 110   /**
 111    * Queued poll message, to cancel if not necessary anymore (got ACK).
 112    */
 113   struct CadetConnectionQueue *ack_msg;
 114 };
 115
 116 /**
 117  * Keep a record of the last messages sent on this connection.
 118  */
 119 struct CadetConnectionPerformance
 120 {
 121   /**
 122    * Circular buffer for storing measurements.
 123    */
 124   double usecsperbyte[AVG_MSGS];
 125
 126   /**
 127    * Running average of @c usecsperbyte.
 128    */
 129   double avg;
 130
 131   /**
 132    * How many values of @c usecsperbyte are valid.
 133    */
 134   uint16_t size;
 135
 136   /**
 137    * Index of the next "free" position in @c usecsperbyte.
 138    */
 139   uint16_t idx;
 140 };
 141
 142
 143 /**
 144  * Struct containing all information regarding a connection to a peer.
 145  */
 146 struct CadetConnection
 147 {
 148   /**
 149    * Tunnel this connection is part of.
 150    */
 151   struct CadetTunnel *t;
 152
 153   /**
 154    * Flow control information for traffic fwd.
 155    */
 156   struct CadetFlowControl fwd_fc;
 157
 158   /**
 159    * Flow control information for traffic bck.
 160    */
 161   struct CadetFlowControl bck_fc;
 162
 163   /**
 164    * Measure connection performance on the endpoint.
 165    */
 166   struct CadetConnectionPerformance *perf;
 167
 168   /**
 169    * ID of the connection.
 170    */
 171   struct GNUNET_CADET_Hash id;
 172
 173   /**
 174    * State of the connection.
 175    */
 176   enum CadetConnectionState state;
 177
 178   /**
 179    * Path being used for the tunnel. At the origin of the connection
 180    * it's a pointer to the destination's path pool, otherwise just a copy.
 181    */
 182   struct CadetPeerPath *path;
 183
 184   /**
 185    * Position of the local peer in the path.
 186    */
 187   unsigned int own_pos;
 188
 189   /**
 190    * Task to keep the used paths alive at the owner,
 191    * time tunnel out on all the other peers.
 192    */
 193   GNUNET_SCHEDULER_TaskIdentifier fwd_maintenance_task;
 194
 195   /**
 196    * Task to keep the used paths alive at the destination,
 197    * time tunnel out on all the other peers.
 198    */
 199   GNUNET_SCHEDULER_TaskIdentifier bck_maintenance_task;
 200
 201   /**
 202    * Queue handle for maintainance traffic. One handle for FWD and BCK since
 203    * one peer never needs to maintain both directions (no loopback connections).
 204    */
 205   struct CadetPeerQueue *maintenance_q;
 206
 207   /**
 208    * Counter to do exponential backoff when creating a connection (max 64).
 209    */
 210   unsigned short create_retry;
 211
 212   /**
 213    * Pending message count.
 214    */
 215   int pending_messages;
 216
 217   /**
 218    * Destroy flag: if true, destroy on last message.
 219    */
 220   int destroy;
 221 };
 222
 223 /**
 224  * Handle for messages queued but not yet sent.
 225  */
 226 struct CadetConnectionQueue
 227 {
 228   /**
 229    * Peer queue handle, to cancel if necessary.
 230    */
 231   struct CadetPeerQueue *q;
 232
 233   /**
 234    * Was this a forced message? (Do not account for it)
 235    */
 236   int forced;
 237
 238   /**
 239    * Continuation to call once sent.
 240    */
 241   GCC_sent cont;
 242
 243   /**
 244    * Closure for @c cont.
 245    */
 246   void *cont_cls;
 247 };
 248
 249 /******************************************************************************/
 250 /*******************************   GLOBALS  ***********************************/
 251 /******************************************************************************/
 252
 253 /**
 254  * Global handle to the statistics service.
 255  */
 256 extern struct GNUNET_STATISTICS_Handle *stats;
 257
 258 /**
 259  * Local peer own ID (memory efficient handle).
 260  */
 261 extern GNUNET_PEER_Id myid;
 262
 263 /**
 264  * Local peer own ID (full value).
 265  */
 266 extern struct GNUNET_PeerIdentity my_full_id;
 267
 268 /**
 269  * Connections known, indexed by cid (CadetConnection).
 270  */
 271 static struct GNUNET_CONTAINER_MultiHashMap *connections;
 272
 273 /**
 274  * How many connections are we willing to maintain.
 275  * Local connections are always allowed, even if there are more connections than max.
 276  */
 277 static unsigned long long max_connections;
 278
 279 /**
 280  * How many messages *in total* are we willing to queue, divide by number of
 281  * connections to get connection queue size.
 282  */
 283 static unsigned long long max_msgs_queue;
 284
 285 /**
 286  * How often to send path keepalives. Paths timeout after 4 missed.
 287  */
 288 static struct GNUNET_TIME_Relative refresh_connection_time;
 289
 290 /**
 291  * How often to send path create / ACKs.
 292  */
 293 static struct GNUNET_TIME_Relative create_connection_time;
 294
 295
 296 /******************************************************************************/
 297 /********************************   STATIC  ***********************************/
 298 /******************************************************************************/
 299
 300 #if 0 // avoid compiler warning for unused static function
 301 static void
 302 fc_debug (struct CadetFlowControl *fc)
 303 {
 304   LOG (GNUNET_ERROR_TYPE_DEBUG, "    IN: %u/%u\n",
 305               fc->last_pid_recv, fc->last_ack_sent);
 306   LOG (GNUNET_ERROR_TYPE_DEBUG, "    OUT: %u/%u\n",
 307               fc->last_pid_sent, fc->last_ack_recv);
 308   LOG (GNUNET_ERROR_TYPE_DEBUG, "    QUEUE: %u/%u\n",
 309               fc->queue_n, fc->queue_max);
 310 }
 311
 312 static void
 313 connection_debug (struct CadetConnection *c)
 314 {
 315   if (NULL == c)
 316   {
 317     LOG (GNUNET_ERROR_TYPE_DEBUG, "*** DEBUG NULL CONNECTION ***\n");
 318     return;
 319   }
 320   LOG (GNUNET_ERROR_TYPE_DEBUG, "Connection %s:%X\n",
 321               peer2s (c->t->peer), GCC_2s (c));
 322   LOG (GNUNET_ERROR_TYPE_DEBUG, "  state: %u, pending msgs: %u\n",
 323               c->state, c->pending_messages);
 324   LOG (GNUNET_ERROR_TYPE_DEBUG, "  FWD FC\n");
 325   fc_debug (&c->fwd_fc);
 326   LOG (GNUNET_ERROR_TYPE_DEBUG, "  BCK FC\n");
 327   fc_debug (&c->bck_fc);
 328 }
 329 #endif
 330
 331
 332 /**
 333  * Schedule next keepalive task, taking in consideration
 334  * the connection state and number of retries.
 335  *
 336  * @param c Connection for which to schedule the next keepalive.
 337  * @param fwd Direction for the next keepalive.
 338  */
 339 static void
 340 schedule_next_keepalive (struct CadetConnection *c, int fwd);
 341
 342
 343 /**
 344  * Resets the connection timeout task, some other message has done the
 345  * task's job.
 346  * - For the first peer on the direction this means to send
 347  *   a keepalive or a path confirmation message (either create or ACK).
 348  * - For all other peers, this means to destroy the connection,
 349  *   due to lack of activity.
 350  * Starts the timeout if no timeout was running (connection just created).
 351  *
 352  * @param c Connection whose timeout to reset.
 353  * @param fwd Is this forward?
 354  */
 355 static void
 356 connection_reset_timeout (struct CadetConnection *c, int fwd);
 357
 358
 359 /**
 360  * Get string description for tunnel state. Reentrant.
 361  *
 362  * @param s Tunnel state.
 363  *
 364  * @return String representation.
 365  */
 366 static const char *
 367 GCC_state2s (enum CadetConnectionState s)
 368 {
 369   switch (s)
 370   {
 371     case CADET_CONNECTION_NEW:
 372       return "CADET_CONNECTION_NEW";
 373     case CADET_CONNECTION_SENT:
 374       return "CADET_CONNECTION_SENT";
 375     case CADET_CONNECTION_ACK:
 376       return "CADET_CONNECTION_ACK";
 377     case CADET_CONNECTION_READY:
 378       return "CADET_CONNECTION_READY";
 379     case CADET_CONNECTION_DESTROYED:
 380       return "CADET_CONNECTION_DESTROYED";
 381     case CADET_CONNECTION_BROKEN:
 382       return "CADET_CONNECTION_BROKEN";
 383     default:
 384       GNUNET_break (0);
 385       LOG (GNUNET_ERROR_TYPE_ERROR, " conn state %u unknown!\n", s);
 386       return "CADET_CONNECTION_STATE_ERROR";
 387   }
 388 }
 389
 390
 391 /**
 392  * Initialize a Flow Control structure to the initial state.
 393  *
 394  * @param fc Flow Control structure to initialize.
 395  */
 396 static void
 397 fc_init (struct CadetFlowControl *fc)
 398 {
 399   fc->last_pid_sent = (uint32_t) -1; /* Next (expected) = 0 */
 400   fc->last_pid_recv = (uint32_t) -1;
 401   fc->last_ack_sent = (uint32_t) 0;
 402   fc->last_ack_recv = (uint32_t) 0;
 403   fc->poll_task = GNUNET_SCHEDULER_NO_TASK;
 404   fc->poll_time = GNUNET_TIME_UNIT_SECONDS;
 405   fc->queue_n = 0;
 406   fc->queue_max = (max_msgs_queue / max_connections) + 1;
 407 }
 408
 409
 410 /**
 411  * Find a connection.
 412  *
 413  * @param cid Connection ID.
 414  */
 415 static struct CadetConnection *
 416 connection_get (const struct GNUNET_CADET_Hash *cid)
 417 {
 418   return GNUNET_CONTAINER_multihashmap_get (connections, GC_h2hc (cid));
 419 }
 420
 421
 422 static void
 423 connection_change_state (struct CadetConnection* c,
 424                          enum CadetConnectionState state)
 425 {
 426   LOG (GNUNET_ERROR_TYPE_DEBUG,
 427        "Connection %s state %s -> %s\n",
 428        GCC_2s (c), GCC_state2s (c->state), GCC_state2s (state));
 429   if (CADET_CONNECTION_DESTROYED <= c->state) /* Destroyed or broken. */
 430   {
 431     LOG (GNUNET_ERROR_TYPE_DEBUG, "state not changing anymore\n");
 432     return;
 433   }
 434   c->state = state;
 435   if (CADET_CONNECTION_READY == state)
 436     c->create_retry = 1;
 437 }
 438
 439
 440 /**
 441  * Callback called when a queued ACK message is sent.
 442  *
 443  * @param cls Closure (FC).
 444  * @param c Connection this message was on.
 445  * @param q Queue handler this call invalidates.
 446  * @param type Type of message sent.
 447  * @param fwd Was this a FWD going message?
 448  * @param size Size of the message.
 449  */
 450 static void
 451 ack_sent (void *cls,
 452           struct CadetConnection *c,
 453           struct CadetConnectionQueue *q,
 454           uint16_t type, int fwd, size_t size)
 455 {
 456   struct CadetFlowControl *fc = cls;
 457
 458   fc->ack_msg = NULL;
 459 }
 460
 461
 462 /**
 463  * Send an ACK on the connection, informing the predecessor about
 464  * the available buffer space. Should not be called in case the peer
 465  * is origin (no predecessor) in the @c fwd direction.
 466  *
 467  * Note that for fwd ack, the FWD mean forward *traffic* (root->dest),
 468  * the ACK itself goes "back" (dest->root).
 469  *
 470  * @param c Connection on which to send the ACK.
 471  * @param buffer How much space free to advertise?
 472  * @param fwd Is this FWD ACK? (Going dest -> root)
 473  * @param force Don't optimize out.
 474  */
 475 static void
 476 send_ack (struct CadetConnection *c, unsigned int buffer, int fwd, int force)
 477 {
 478   struct CadetFlowControl *next_fc;
 479   struct CadetFlowControl *prev_fc;
 480   struct GNUNET_CADET_ACK msg;
 481   uint32_t ack;
 482   int delta;
 483
 484   /* If origin, there is no connection to send ACKs. Wrong function! */
 485   if (GCC_is_origin (c, fwd))
 486   {
 487     LOG (GNUNET_ERROR_TYPE_DEBUG, "connection %s is origin in %s\n",
 488          GCC_2s (c), GC_f2s (fwd));
 489     GNUNET_break (0);
 490     return;
 491   }
 492
 493   next_fc = fwd ? &c->fwd_fc : &c->bck_fc;
 494   prev_fc = fwd ? &c->bck_fc : &c->fwd_fc;
 495
 496   LOG (GNUNET_ERROR_TYPE_DEBUG, "connection send %s ack on %s\n",
 497        GC_f2s (fwd), GCC_2s (c));
 498
 499   /* Check if we need to transmit the ACK. */
 500   delta = prev_fc->last_ack_sent - prev_fc->last_pid_recv;
 501   if (3 < delta && buffer < delta && GNUNET_NO == force)
 502   {
 503     LOG (GNUNET_ERROR_TYPE_DEBUG, "Not sending ACK, buffer > 3\n");
 504     LOG (GNUNET_ERROR_TYPE_DEBUG,
 505          "  last pid recv: %u, last ack sent: %u\n",
 506          prev_fc->last_pid_recv, prev_fc->last_ack_sent);
 507     return;
 508   }
 509
 510   /* Ok, ACK might be necessary, what PID to ACK? */
 511   ack = prev_fc->last_pid_recv + buffer;
 512   LOG (GNUNET_ERROR_TYPE_DEBUG, " ACK %u\n", ack);
 513   LOG (GNUNET_ERROR_TYPE_DEBUG,
 514        " last pid %u, last ack %u, qmax %u, q %u\n",
 515        prev_fc->last_pid_recv, prev_fc->last_ack_sent,
 516        next_fc->queue_max, next_fc->queue_n);
 517   if (ack == prev_fc->last_ack_sent && GNUNET_NO == force)
 518   {
 519     LOG (GNUNET_ERROR_TYPE_DEBUG, "Not sending FWD ACK, not needed\n");
 520     return;
 521   }
 522
 523   /* Check if message is already in queue */
 524   if (NULL != prev_fc->ack_msg)
 525   {
 526     if (GC_is_pid_bigger (ack, prev_fc->last_ack_sent))
 527     {
 528       LOG (GNUNET_ERROR_TYPE_DEBUG, " canceling old ACK\n");
 529       GCC_cancel (prev_fc->ack_msg);
 530       /* GCC_cancel triggers ack_sent(), which clears fc->ack_msg */
 531     }
 532     else
 533     {
 534       LOG (GNUNET_ERROR_TYPE_DEBUG, " same ACK already in queue\n");
 535       return;
 536     }
 537   }
 538
 539   prev_fc->last_ack_sent = ack;
 540
 541   /* Build ACK message and send on connection */
 542   msg.header.size = htons (sizeof (msg));
 543   msg.header.type = htons (GNUNET_MESSAGE_TYPE_CADET_ACK);
 544   msg.ack = htonl (ack);
 545   msg.cid = c->id;
 546
 547   prev_fc->ack_msg = GCC_send_prebuilt_message (&msg.header, 0, ack, c,
 548                                                 !fwd, GNUNET_YES,
 549                                                 &ack_sent, prev_fc);
 550   GNUNET_assert (NULL != prev_fc->ack_msg);
 551 }
 552
 553
 554 /**
 555  * Callback called when a connection queued message is sent.
 556  *
 557  * Calculates the average time and connection packet tracking.
 558  *
 559  * @param cls Closure (ConnectionQueue Handle).
 560  * @param c Connection this message was on.
 561  * @param sent Was it really sent? (Could have been canceled)
 562  * @param type Type of message sent.
 563  * @param pid Packet ID, or 0 if not applicable (create, destroy, etc).
 564  * @param fwd Was this a FWD going message?
 565  * @param size Size of the message.
 566  * @param wait Time spent waiting for core (only the time for THIS message)
 567  *
 568  * @return #GNUNET_YES if connection was destroyed, #GNUNET_NO otherwise.
 569  */
 570 static int
 571 conn_message_sent (void *cls,
 572                    struct CadetConnection *c, int sent,
 573                    uint16_t type, uint32_t pid, int fwd, size_t size,
 574                    struct GNUNET_TIME_Relative wait)
 575 {
 576   struct CadetConnectionPerformance *p;
 577   struct CadetFlowControl *fc;
 578   struct CadetConnectionQueue *q = cls;
 579   double usecsperbyte;
 580   int forced;
 581
 582   LOG (GNUNET_ERROR_TYPE_DEBUG, "connection message_sent\n");
 583
 584   fc = fwd ? &c->fwd_fc : &c->bck_fc;
 585   LOG (GNUNET_ERROR_TYPE_DEBUG, " %ssent %s %s\n",
 586        sent ? "" : "not ", GC_f2s (fwd), GC_m2s (type));
 587   if (NULL != q)
 588   {
 589     forced = q->forced;
 590     if (NULL != q->cont)
 591     {
 592       LOG (GNUNET_ERROR_TYPE_DEBUG, " calling cont\n");
 593       q->cont (q->cont_cls, c, q, type, fwd, size);
 594     }
 595     GNUNET_free (q);
 596   }
 597   else if (type == GNUNET_MESSAGE_TYPE_CADET_ENCRYPTED)
 598   {
 599     /* If NULL == q and ENCRYPTED == type, message must have been ch_mngmnt */
 600     forced = GNUNET_YES;
 601   }
 602   else
 603   {
 604     forced = GNUNET_NO;
 605   }
 606   if (NULL == c)
 607   {
 608     if (type != GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN
 609         && type != GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY)
 610     {
 611       LOG (GNUNET_ERROR_TYPE_ERROR, "Message %s sent on NULL connection!\n",
 612            GC_m2s (type));
 613     }
 614     return GNUNET_NO;
 615   }
 616   LOG (GNUNET_ERROR_TYPE_DEBUG, " C_P- %p %u\n", c, c->pending_messages);
 617   c->pending_messages--;
 618   if (GNUNET_YES == c->destroy && 0 == c->pending_messages)
 619   {
 620     LOG (GNUNET_ERROR_TYPE_DEBUG, "!  destroying connection!\n");
 621     GCC_destroy (c);
 622     return GNUNET_YES;
 623   }
 624   /* Send ACK if needed, after accounting for sent ID in fc->queue_n */
 625   switch (type)
 626   {
 627     case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE:
 628     case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK:
 629       c->maintenance_q = NULL;
 630       /* Don't trigger a keepalive for sent ACKs, only SYN and SYNACKs */
 631       if (GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE == type || !fwd)
 632         schedule_next_keepalive (c, fwd);
 633       break;
 634
 635     case GNUNET_MESSAGE_TYPE_CADET_ENCRYPTED:
 636       if (GNUNET_YES == sent)
 637       {
 638         GNUNET_assert (NULL != q);
 639         fc->last_pid_sent = pid; // FIXME
 640         GCC_send_ack (c, fwd, GNUNET_NO);
 641         connection_reset_timeout (c, fwd);
 642       }
 643
 644       LOG (GNUNET_ERROR_TYPE_DEBUG, "!  Q_N- %p %u\n", fc, fc->queue_n);
 645       if (GNUNET_NO == forced)
 646       {
 647         fc->queue_n--;
 648         LOG (GNUNET_ERROR_TYPE_DEBUG,
 649             "!   accounting pid %u\n",
 650             fc->last_pid_sent);
 651       }
 652       else
 653       {
 654         LOG (GNUNET_ERROR_TYPE_DEBUG,
 655              "!   forced, Q_N not accounting pid %u\n",
 656              fc->last_pid_sent);
 657       }
 658       break;
 659
 660     case GNUNET_MESSAGE_TYPE_CADET_KX:
 661       if (GNUNET_YES == sent)
 662         connection_reset_timeout (c, fwd);
 663       break;
 664
 665     case GNUNET_MESSAGE_TYPE_CADET_POLL:
 666       fc->poll_msg = NULL;
 667       break;
 668
 669     case GNUNET_MESSAGE_TYPE_CADET_ACK:
 670       fc->ack_msg = NULL;
 671       break;
 672
 673     default:
 674       break;
 675   }
 676   LOG (GNUNET_ERROR_TYPE_DEBUG, "!  message sent!\n");
 677
 678   if (NULL == c->perf)
 679     return GNUNET_NO; /* Only endpoints are interested in timing. */
 680
 681   p = c->perf;
 682   usecsperbyte = ((double) wait.rel_value_us) / size;
 683   if (p->size == AVG_MSGS)
 684   {
 685     /* Array is full. Substract oldest value, add new one and store. */
 686     p->avg -= (p->usecsperbyte[p->idx] / AVG_MSGS);
 687     p->usecsperbyte[p->idx] = usecsperbyte;
 688     p->avg += (p->usecsperbyte[p->idx] / AVG_MSGS);
 689   }
 690   else
 691   {
 692     /* Array not yet full. Add current value to avg and store. */
 693     p->usecsperbyte[p->idx] = usecsperbyte;
 694     p->avg *= p->size;
 695     p->avg += p->usecsperbyte[p->idx];
 696     p->size++;
 697     p->avg /= p->size;
 698   }
 699   p->idx = (p->idx + 1) % AVG_MSGS;
 700   return GNUNET_NO;
 701 }
 702
 703
 704 /**
 705  * Get the previous hop in a connection
 706  *
 707  * @param c Connection.
 708  *
 709  * @return Previous peer in the connection.
 710  */
 711 static struct CadetPeer *
 712 get_prev_hop (const struct CadetConnection *c)
 713 {
 714   GNUNET_PEER_Id id;
 715
 716   LOG (GNUNET_ERROR_TYPE_DEBUG, " get prev hop %s [%u/%u]\n",
 717        GCC_2s (c), c->own_pos, c->path->length);
 718   if (0 == c->own_pos || c->path->length < 2)
 719     id = c->path->peers[0];
 720   else
 721     id = c->path->peers[c->own_pos - 1];
 722
 723   LOG (GNUNET_ERROR_TYPE_DEBUG, "  ID: %s (%u)\n",
 724        GNUNET_i2s (GNUNET_PEER_resolve2 (id)), id);
 725
 726   return GCP_get_short (id);
 727 }
 728
 729
 730 /**
 731  * Get the next hop in a connection
 732  *
 733  * @param c Connection.
 734  *
 735  * @return Next peer in the connection.
 736  */
 737 static struct CadetPeer *
 738 get_next_hop (const struct CadetConnection *c)
 739 {
 740   GNUNET_PEER_Id id;
 741
 742   LOG (GNUNET_ERROR_TYPE_DEBUG, " get next hop %s [%u/%u]\n",
 743        GCC_2s (c), c->own_pos, c->path->length);
 744   if ((c->path->length - 1) == c->own_pos || c->path->length < 2)
 745     id = c->path->peers[c->path->length - 1];
 746   else
 747     id = c->path->peers[c->own_pos + 1];
 748
 749   LOG (GNUNET_ERROR_TYPE_DEBUG, "  ID: %s (%u)\n",
 750        GNUNET_i2s (GNUNET_PEER_resolve2 (id)), id);
 751
 752   return GCP_get_short (id);
 753 }
 754
 755
 756 /**
 757  * Get the hop in a connection.
 758  *
 759  * @param c Connection.
 760  * @param fwd Next hop?
 761  *
 762  * @return Next peer in the connection.
 763  */
 764 static struct CadetPeer *
 765 get_hop (struct CadetConnection *c, int fwd)
 766 {
 767   if (fwd)
 768     return get_next_hop (c);
 769   return get_prev_hop (c);
 770 }
 771
 772
 773 /**
 774  * Is traffic coming from this sender 'FWD' traffic?
 775  *
 776  * @param c Connection to check.
 777  * @param sender Peer identity of neighbor.
 778  *
 779  * @return #GNUNET_YES in case the sender is the 'prev' hop and therefore
 780  *         the traffic is 'FWD'.
 781  *         #GNUNET_NO for BCK.
 782  *         #GNUNET_SYSERR for errors.
 783  */
 784 static int
 785 is_fwd (const struct CadetConnection *c,
 786         const struct GNUNET_PeerIdentity *sender)
 787 {
 788   GNUNET_PEER_Id id;
 789
 790   id = GNUNET_PEER_search (sender);
 791   if (GCP_get_short_id (get_prev_hop (c)) == id)
 792     return GNUNET_YES;
 793
 794   if (GCP_get_short_id (get_next_hop (c)) == id)
 795     return GNUNET_NO;
 796
 797   GNUNET_break (0);
 798   return GNUNET_SYSERR;
 799 }
 800
 801
 802 /**
 803  * Sends a CONNECTION ACK message in reponse to a received CONNECTION_CREATE
 804  * or a first CONNECTION_ACK directed to us.
 805  *
 806  * @param connection Connection to confirm.
 807  * @param fwd Should we send it FWD? (root->dest)
 808  *            (First (~SYNACK) goes BCK, second (~ACK) goes FWD)
 809  */
 810 static void
 811 send_connection_ack (struct CadetConnection *connection, int fwd)
 812 {
 813   struct CadetTunnel *t;
 814
 815   t = connection->t;
 816   LOG (GNUNET_ERROR_TYPE_INFO, "===> {%14s ACK} on connection %s\n",
 817        GC_f2s (!fwd), GCC_2s (connection));
 818   GCP_queue_add (get_hop (connection, fwd), NULL,
 819                  GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK, 0, 0,
 820                  sizeof (struct GNUNET_CADET_ConnectionACK),
 821                  connection, fwd, &conn_message_sent, NULL);
 822   connection->pending_messages++;
 823   if (CADET_TUNNEL_NEW == GCT_get_cstate (t))
 824     GCT_change_cstate (t, CADET_TUNNEL_WAITING);
 825   if (CADET_CONNECTION_READY != connection->state)
 826     connection_change_state (connection, CADET_CONNECTION_SENT);
 827 }
 828
 829
 830 /**
 831  * Send a notification that a connection is broken.
 832  *
 833  * @param c Connection that is broken.
 834  * @param id1 Peer that has disconnected.
 835  * @param id2 Peer that has disconnected.
 836  * @param fwd Direction towards which to send it.
 837  */
 838 static void
 839 send_broken (struct CadetConnection *c,
 840              const struct GNUNET_PeerIdentity *id1,
 841              const struct GNUNET_PeerIdentity *id2,
 842              int fwd)
 843 {
 844   struct GNUNET_CADET_ConnectionBroken msg;
 845
 846   msg.header.size = htons (sizeof (struct GNUNET_CADET_ConnectionBroken));
 847   msg.header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN);
 848   msg.cid = c->id;
 849   msg.peer1 = *id1;
 850   msg.peer2 = *id2;
 851   GNUNET_assert (NULL == GCC_send_prebuilt_message (&msg.header, 0, 0, c, fwd,
 852                                                     GNUNET_YES, NULL, NULL));
 853 }
 854
 855
 856 /**
 857  * Send a notification that a connection is broken, when a connection
 858  * isn't even known to the local peer.
 859  *
 860  * @param connection_id Connection ID.
 861  * @param id1 Peer that has disconnected, probably local peer.
 862  * @param id2 Peer that has disconnected can be NULL if unknown.
 863  * @param peer Peer to notify (neighbor who sent the connection).
 864  */
 865 static void
 866 send_broken_unknown (const struct GNUNET_CADET_Hash *connection_id,
 867                      const struct GNUNET_PeerIdentity *id1,
 868                      const struct GNUNET_PeerIdentity *id2,
 869                      const struct GNUNET_PeerIdentity *peer_id)
 870 {
 871   struct GNUNET_CADET_ConnectionBroken *msg;
 872   struct CadetPeer *neighbor;
 873
 874   LOG (GNUNET_ERROR_TYPE_INFO, "===> BROKEN on unknown connection %s\n",
 875        GNUNET_h2s (GC_h2hc (connection_id)));
 876
 877   msg = GNUNET_new (struct GNUNET_CADET_ConnectionBroken);
 878   msg->header.size = htons (sizeof (struct GNUNET_CADET_ConnectionBroken));
 879   msg->header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN);
 880   msg->cid = *connection_id;
 881   msg->peer1 = *id1;
 882   if (NULL != id2)
 883     msg->peer2 = *id2;
 884   else
 885     memset (&msg->peer2, 0, sizeof (msg->peer2));
 886   neighbor = GCP_get (peer_id);
 887   GCP_queue_add (neighbor, msg, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN,
 888                  0, 2, sizeof (struct GNUNET_CADET_ConnectionBroken),
 889                  NULL, GNUNET_SYSERR, /* connection, fwd */
 890                  NULL, NULL); /* continuation */
 891 }
 892
 893
 894 /**
 895  * Send keepalive packets for a connection.
 896  *
 897  * @param c Connection to keep alive..
 898  * @param fwd Is this a FWD keepalive? (owner -> dest).
 899  */
 900 static void
 901 send_connection_keepalive (struct CadetConnection *c, int fwd)
 902 {
 903   struct GNUNET_MessageHeader msg;
 904   struct CadetFlowControl *fc;
 905
 906   LOG (GNUNET_ERROR_TYPE_INFO, "keepalive %s for connection %s\n",
 907        GC_f2s (fwd), GCC_2s (c));
 908
 909   fc = fwd ? &c->fwd_fc : &c->bck_fc;
 910   if (0 < fc->queue_n)
 911   {
 912     LOG (GNUNET_ERROR_TYPE_INFO, "not sending keepalive, traffic in queue\n");
 913     return;
 914   }
 915
 916   GNUNET_STATISTICS_update (stats, "# keepalives sent", 1, GNUNET_NO);
 917
 918   GNUNET_assert (NULL != c->t);
 919   msg.size = htons (sizeof (msg));
 920   msg.type = htons (GNUNET_MESSAGE_TYPE_CADET_KEEPALIVE);
 921
 922   GNUNET_assert (NULL ==
 923                  GCT_send_prebuilt_message (&msg, c->t, c,
 924                                             GNUNET_NO, NULL, NULL));
 925 }
 926
 927
 928 /**
 929  * Send CONNECTION_{CREATE/ACK} packets for a connection.
 930  *
 931  * @param c Connection for which to send the message.
 932  * @param fwd If #GNUNET_YES, send CREATE, otherwise send ACK.
 933  */
 934 static void
 935 connection_recreate (struct CadetConnection *c, int fwd)
 936 {
 937   LOG (GNUNET_ERROR_TYPE_DEBUG, "sending connection recreate\n");
 938   if (fwd)
 939     GCC_send_create (c);
 940   else
 941     send_connection_ack (c, GNUNET_NO);
 942 }
 943
 944
 945 /**
 946  * Generic connection timer management.
 947  * Depending on the role of the peer in the connection will send the
 948  * appropriate message (build or keepalive)
 949  *
 950  * @param c Conncetion to maintain.
 951  * @param fwd Is FWD?
 952  */
 953 static void
 954 connection_maintain (struct CadetConnection *c, int fwd)
 955 {
 956   if (GNUNET_NO != c->destroy)
 957   {
 958     LOG (GNUNET_ERROR_TYPE_INFO, "not sending keepalive, being destroyed\n");
 959     return;
 960   }
 961
 962   if (NULL == c->t)
 963   {
 964     GNUNET_break (0);
 965     GCC_debug (c, GNUNET_ERROR_TYPE_ERROR);
 966     return;
 967   }
 968
 969   if (CADET_TUNNEL_SEARCHING == GCT_get_cstate (c->t))
 970   {
 971     /* If status is SEARCHING, why is there a connection? Should be WAITING */
 972     GNUNET_break (0);
 973     GCT_debug (c->t, GNUNET_ERROR_TYPE_ERROR);
 974     LOG (GNUNET_ERROR_TYPE_INFO, "not sending keepalive, tunnel SEARCHING\n");
 975     schedule_next_keepalive (c, fwd);
 976     return;
 977   }
 978   switch (c->state)
 979   {
 980     case CADET_CONNECTION_NEW:
 981       GNUNET_break (0);
 982       /* fall-through */
 983     case CADET_CONNECTION_SENT:
 984       connection_recreate (c, fwd);
 985       break;
 986     case CADET_CONNECTION_READY:
 987       send_connection_keepalive (c, fwd);
 988       break;
 989     default:
 990       break;
 991   }
 992 }
 993
 994
 995
 996 /**
 997  * Keep the connection alive.
 998  *
 999  * @param c Connection to keep alive.
1000  * @param fwd Direction.
1001  * @param shutdown Are we shutting down? (Don't send traffic)
1002  *                 Non-zero value for true, not necessarily GNUNET_YES.
1003  */
1004 static void
1005 connection_keepalive (struct CadetConnection *c, int fwd, int shutdown)
1006 {
1007   LOG (GNUNET_ERROR_TYPE_DEBUG, "%s keepalive for %s\n",
1008        GC_f2s (fwd), GCC_2s (c));
1009
1010   if (fwd)
1011     c->fwd_maintenance_task = GNUNET_SCHEDULER_NO_TASK;
1012   else
1013     c->bck_maintenance_task = GNUNET_SCHEDULER_NO_TASK;
1014
1015   if (GNUNET_NO != shutdown)
1016     return;
1017
1018   connection_maintain (c, fwd);
1019
1020   /* Next execution will be scheduled by message_sent or _maintain*/
1021 }
1022
1023
1024 /**
1025  * Keep the connection alive in the FWD direction.
1026  *
1027  * @param cls Closure (connection to keepalive).
1028  * @param tc TaskContext.
1029  */
1030 static void
1031 connection_fwd_keepalive (void *cls,
1032                           const struct GNUNET_SCHEDULER_TaskContext *tc)
1033 {
1034   connection_keepalive ((struct CadetConnection *) cls,
1035                         GNUNET_YES,
1036                         tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN);
1037 }
1038
1039
1040 /**
1041  * Keep the connection alive in the BCK direction.
1042  *
1043  * @param cls Closure (connection to keepalive).
1044  * @param tc TaskContext.
1045  */
1046 static void
1047 connection_bck_keepalive (void *cls,
1048                           const struct GNUNET_SCHEDULER_TaskContext *tc)
1049 {
1050   connection_keepalive ((struct CadetConnection *) cls,
1051                         GNUNET_NO,
1052                         tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN);
1053 }
1054
1055
1056 /**
1057  * Schedule next keepalive task, taking in consideration
1058  * the connection state and number of retries.
1059  *
1060  * If the peer is not the origin, do nothing.
1061  *
1062  * @param c Connection for which to schedule the next keepalive.
1063  * @param fwd Direction for the next keepalive.
1064  */
1065 static void
1066 schedule_next_keepalive (struct CadetConnection *c, int fwd)
1067 {
1068   struct GNUNET_TIME_Relative delay;
1069   GNUNET_SCHEDULER_TaskIdentifier *task_id;
1070   GNUNET_SCHEDULER_Task keepalive_task;
1071
1072   if (GNUNET_NO == GCC_is_origin (c, fwd))
1073     return;
1074
1075   /* Calculate delay to use, depending on the state of the connection */
1076   if (CADET_CONNECTION_READY == c->state)
1077   {
1078     delay = refresh_connection_time;
1079   }
1080   else
1081   {
1082     if (1 > c->create_retry)
1083       c->create_retry = 1;
1084     delay = GNUNET_TIME_relative_multiply (create_connection_time,
1085                                            c->create_retry);
1086     if (c->create_retry < 64)
1087       c->create_retry *= 2;
1088   }
1089
1090   /* Select direction-dependent parameters */
1091   if (GNUNET_YES == fwd)
1092   {
1093     task_id = &c->fwd_maintenance_task;
1094     keepalive_task = &connection_fwd_keepalive;
1095   }
1096   else
1097   {
1098     task_id = &c->bck_maintenance_task;
1099     keepalive_task = &connection_bck_keepalive;
1100   }
1101
1102   /* Check that no one scheduled it before us */
1103   if (GNUNET_SCHEDULER_NO_TASK != *task_id)
1104   {
1105     /* No need for a _break. It can happen for instance when sending a SYNACK
1106      * for a duplicate SYN: the first SYNACK scheduled the task. */
1107     GNUNET_SCHEDULER_cancel (*task_id);
1108   }
1109
1110   /* Schedule the task */
1111   *task_id = GNUNET_SCHEDULER_add_delayed (delay, keepalive_task, c);
1112   LOG (GNUNET_ERROR_TYPE_DEBUG, "next keepalive in %s\n",
1113        GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES));
1114 }
1115
1116
1117 /**
1118  * @brief Re-initiate traffic on this connection if necessary.
1119  *
1120  * Check if there is traffic queued towards this peer
1121  * and the core transmit handle is NULL (traffic was stalled).
1122  * If so, call core tmt rdy.
1123  *
1124  * @param c Connection on which initiate traffic.
1125  * @param fwd Is this about fwd traffic?
1126  */
1127 static void
1128 connection_unlock_queue (struct CadetConnection *c, int fwd)
1129 {
1130   struct CadetPeer *peer;
1131
1132   LOG (GNUNET_ERROR_TYPE_DEBUG, "connection_unlock_queue %s on %s\n",
1133        GC_f2s (fwd), GCC_2s (c));
1134
1135   if (GCC_is_terminal (c, fwd))
1136   {
1137     LOG (GNUNET_ERROR_TYPE_DEBUG, " is terminal, can unlock!\n");
1138     return;
1139   }
1140
1141   peer = get_hop (c, fwd);
1142   GCP_queue_unlock (peer, c);
1143 }
1144
1145
1146 /**
1147  * Cancel all transmissions that belong to a certain connection.
1148  *
1149  * If the connection is scheduled for destruction and no more messages are left,
1150  * the connection will be destroyed by the continuation call.
1151  *
1152  * @param c Connection which to cancel. Might be destroyed during this call.
1153  * @param fwd Cancel fwd traffic?
1154  */
1155 static void
1156 connection_cancel_queues (struct CadetConnection *c, int fwd)
1157 {
1158   struct CadetFlowControl *fc;
1159   struct CadetPeer *peer;
1160
1161   LOG (GNUNET_ERROR_TYPE_DEBUG,
1162        " *** Cancel %s queues for connection %s\n",
1163        GC_f2s (fwd), GCC_2s (c));
1164   if (NULL == c)
1165   {
1166     GNUNET_break (0);
1167     return;
1168   }
1169
1170   fc = fwd ? &c->fwd_fc : &c->bck_fc;
1171   if (GNUNET_SCHEDULER_NO_TASK != fc->poll_task)
1172   {
1173     GNUNET_SCHEDULER_cancel (fc->poll_task);
1174     fc->poll_task = GNUNET_SCHEDULER_NO_TASK;
1175     LOG (GNUNET_ERROR_TYPE_DEBUG, " *** Cancel POLL in ccq for fc %p\n", fc);
1176   }
1177   peer = get_hop (c, fwd);
1178   GCP_queue_cancel (peer, c);
1179 }
1180
1181
1182 /**
1183  * Function called if a connection has been stalled for a while,
1184  * possibly due to a missed ACK. Poll the neighbor about its ACK status.
1185  *
1186  * @param cls Closure (poll ctx).
1187  * @param tc TaskContext.
1188  */
1189 static void
1190 connection_poll (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
1191
1192
1193 /**
1194  * Callback called when a queued POLL message is sent.
1195  *
1196  * @param cls Closure (FC).
1197  * @param c Connection this message was on.
1198  * @param q Queue handler this call invalidates.
1199  * @param type Type of message sent.
1200  * @param fwd Was this a FWD going message?
1201  * @param size Size of the message.
1202  */
1203 static void
1204 poll_sent (void *cls,
1205            struct CadetConnection *c,
1206            struct CadetConnectionQueue *q,
1207            uint16_t type, int fwd, size_t size)
1208 {
1209   struct CadetFlowControl *fc = cls;
1210
1211   if (2 == c->destroy)
1212   {
1213     LOG (GNUNET_ERROR_TYPE_DEBUG, " *** POLL canceled on shutdown\n");
1214     return;
1215   }
1216   LOG (GNUNET_ERROR_TYPE_DEBUG, " *** POLL sent for , scheduling new one!\n");
1217   fc->poll_msg = NULL;
1218   fc->poll_time = GNUNET_TIME_STD_BACKOFF (fc->poll_time);
1219   fc->poll_task = GNUNET_SCHEDULER_add_delayed (fc->poll_time,
1220                                                 &connection_poll, fc);
1221   LOG (GNUNET_ERROR_TYPE_DEBUG, " task %u\n", fc->poll_task);
1222
1223 }
1224
1225 /**
1226  * Function called if a connection has been stalled for a while,
1227  * possibly due to a missed ACK. Poll the neighbor about its ACK status.
1228  *
1229  * @param cls Closure (poll ctx).
1230  * @param tc TaskContext.
1231  */
1232 static void
1233 connection_poll (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1234 {
1235   struct CadetFlowControl *fc = cls;
1236   struct GNUNET_CADET_Poll msg;
1237   struct CadetConnection *c;
1238
1239   fc->poll_task = GNUNET_SCHEDULER_NO_TASK;
1240   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
1241   {
1242     return;
1243   }
1244
1245   c = fc->c;
1246   LOG (GNUNET_ERROR_TYPE_DEBUG, " *** Polling connection %s %s\n",
1247        GCC_2s (c), fc == &c->fwd_fc ? "FWD" : "BCK");
1248
1249   msg.header.type = htons (GNUNET_MESSAGE_TYPE_CADET_POLL);
1250   msg.header.size = htons (sizeof (msg));
1251   msg.pid = htonl (fc->last_pid_sent);
1252   LOG (GNUNET_ERROR_TYPE_DEBUG, " *** last pid sent: %u!\n", fc->last_pid_sent);
1253   fc->poll_msg =
1254       GCC_send_prebuilt_message (&msg.header, 0, fc->last_pid_sent, c,
1255                                  fc == &c->fwd_fc, GNUNET_YES, &poll_sent, fc);
1256   GNUNET_assert (NULL != fc->poll_msg);
1257 }
1258
1259
1260 /**
1261  * Timeout function due to lack of keepalive/traffic from the owner.
1262  * Destroys connection if called.
1263  *
1264  * @param cls Closure (connection to destroy).
1265  * @param tc TaskContext.
1266  */
1267 static void
1268 connection_fwd_timeout (void *cls,
1269                         const struct GNUNET_SCHEDULER_TaskContext *tc)
1270 {
1271   struct CadetConnection *c = cls;
1272
1273   c->fwd_maintenance_task = GNUNET_SCHEDULER_NO_TASK;
1274   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
1275     return;
1276
1277   LOG (GNUNET_ERROR_TYPE_DEBUG, "Connection %s FWD timed out. Destroying.\n",
1278        GCC_2s (c));
1279   if (GCC_is_origin (c, GNUNET_YES)) /* If local, leave. */
1280   {
1281     GNUNET_break (0);
1282     return;
1283   }
1284
1285   GCC_destroy (c);
1286 }
1287
1288
1289 /**
1290  * Timeout function due to lack of keepalive/traffic from the destination.
1291  * Destroys connection if called.
1292  *
1293  * @param cls Closure (connection to destroy).
1294  * @param tc TaskContext
1295  */
1296 static void
1297 connection_bck_timeout (void *cls,
1298                         const struct GNUNET_SCHEDULER_TaskContext *tc)
1299 {
1300   struct CadetConnection *c = cls;
1301
1302   c->bck_maintenance_task = GNUNET_SCHEDULER_NO_TASK;
1303   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
1304     return;
1305
1306   LOG (GNUNET_ERROR_TYPE_DEBUG, "Connection %s BCK timed out. Destroying.\n",
1307        GCC_2s (c));
1308
1309   if (GCC_is_origin (c, GNUNET_NO)) /* If local, leave. */
1310   {
1311     GNUNET_break (0);
1312     return;
1313   }
1314
1315   GCC_destroy (c);
1316 }
1317
1318
1319 /**
1320  * Resets the connection timeout task, some other message has done the
1321  * task's job.
1322  * - For the first peer on the direction this means to send
1323  *   a keepalive or a path confirmation message (either create or ACK).
1324  * - For all other peers, this means to destroy the connection,
1325  *   due to lack of activity.
1326  * Starts the timeout if no timeout was running (connection just created).
1327  *
1328  * @param c Connection whose timeout to reset.
1329  * @param fwd Is this forward?
1330  *
1331  * TODO use heap to improve efficiency of scheduler.
1332  */
1333 static void
1334 connection_reset_timeout (struct CadetConnection *c, int fwd)
1335 {
1336   LOG (GNUNET_ERROR_TYPE_DEBUG, "Connection %s reset timeout\n", GC_f2s (fwd));
1337
1338   if (GCC_is_origin (c, fwd)) /* Startpoint */
1339   {
1340     schedule_next_keepalive (c, fwd);
1341   }
1342   else /* Relay, endpoint. */
1343   {
1344     struct GNUNET_TIME_Relative delay;
1345     GNUNET_SCHEDULER_TaskIdentifier *ti;
1346     GNUNET_SCHEDULER_Task f;
1347
1348     ti = fwd ? &c->fwd_maintenance_task : &c->bck_maintenance_task;
1349
1350     if (GNUNET_SCHEDULER_NO_TASK != *ti)
1351       GNUNET_SCHEDULER_cancel (*ti);
1352     delay = GNUNET_TIME_relative_multiply (refresh_connection_time, 4);
1353     f = fwd ? &connection_fwd_timeout : &connection_bck_timeout;
1354     *ti = GNUNET_SCHEDULER_add_delayed (delay, f, c);
1355   }
1356 }
1357
1358
1359 /**
1360  * Add the connection to the list of both neighbors.
1361  *
1362  * @param c Connection.
1363  *
1364  * @return #GNUNET_OK if everything went fine
1365  *         #GNUNET_SYSERR if the was an error and @c c is malformed.
1366  */
1367 static int
1368 register_neighbors (struct CadetConnection *c)
1369 {
1370   struct CadetPeer *next_peer;
1371   struct CadetPeer *prev_peer;
1372
1373   next_peer = get_next_hop (c);
1374   prev_peer = get_prev_hop (c);
1375
1376   LOG (GNUNET_ERROR_TYPE_DEBUG, "register neighbors for connection %s\n",
1377        GCC_2s (c));
1378   path_debug (c->path);
1379   LOG (GNUNET_ERROR_TYPE_DEBUG, "own pos %u\n", c->own_pos);
1380   LOG (GNUNET_ERROR_TYPE_DEBUG, "putting connection %s to next peer %p\n",
1381        GCC_2s (c), next_peer);
1382   LOG (GNUNET_ERROR_TYPE_DEBUG, "next peer %p %s\n", next_peer, GCP_2s (next_peer));
1383   LOG (GNUNET_ERROR_TYPE_DEBUG, "putting connection %s to prev peer %p\n",
1384        GCC_2s (c), prev_peer);
1385   LOG (GNUNET_ERROR_TYPE_DEBUG, "prev peer %p %s\n", prev_peer, GCP_2s (prev_peer));
1386
1387   if (GNUNET_NO == GCP_is_neighbor (next_peer)
1388       || GNUNET_NO == GCP_is_neighbor (prev_peer))
1389   {
1390     if (GCC_is_origin (c, GNUNET_YES))
1391       GNUNET_STATISTICS_update (stats, "# local bad paths", 1, GNUNET_NO);
1392     GNUNET_STATISTICS_update (stats, "# bad paths", 1, GNUNET_NO);
1393
1394     LOG (GNUNET_ERROR_TYPE_DEBUG, "  register neighbors failed\n");
1395     LOG (GNUNET_ERROR_TYPE_DEBUG, "  prev: %s, neighbor?: %d\n",
1396          GCP_2s (prev_peer), GCP_is_neighbor (prev_peer));
1397     LOG (GNUNET_ERROR_TYPE_DEBUG, "  next: %s, neighbor?: %d\n",
1398          GCP_2s (next_peer), GCP_is_neighbor (next_peer));
1399     return GNUNET_SYSERR;
1400   }
1401
1402   GCP_add_connection (next_peer, c);
1403   GCP_add_connection (prev_peer, c);
1404
1405   return GNUNET_OK;
1406 }
1407
1408
1409 /**
1410  * Remove the connection from the list of both neighbors.
1411  *
1412  * @param c Connection.
1413  */
1414 static void
1415 unregister_neighbors (struct CadetConnection *c)
1416 {
1417   struct CadetPeer *peer;
1418
1419   peer = get_next_hop (c);
1420   if (GNUNET_OK != GCP_remove_connection (peer, c))
1421   {
1422     GNUNET_assert (CADET_CONNECTION_NEW == c->state
1423                    || CADET_CONNECTION_DESTROYED <= c->state);
1424     LOG (GNUNET_ERROR_TYPE_DEBUG, "  cstate: %u\n", c->state);
1425     if (NULL != c->t) GCT_debug (c->t, GNUNET_ERROR_TYPE_DEBUG);
1426   }
1427
1428   peer = get_prev_hop (c);
1429   if (GNUNET_OK != GCP_remove_connection (peer, c))
1430   {
1431     GNUNET_assert (CADET_CONNECTION_NEW == c->state
1432                    || CADET_CONNECTION_DESTROYED <= c->state);
1433     LOG (GNUNET_ERROR_TYPE_DEBUG, "  cstate: %u\n", c->state);
1434     if (NULL != c->t) GCT_debug (c->t, GNUNET_ERROR_TYPE_DEBUG);
1435   }
1436 }
1437
1438
1439 /**
1440  * Bind the connection to the peer and the tunnel to that peer.
1441  *
1442  * If the peer has no tunnel, create one. Update tunnel and connection
1443  * data structres to reflect new status.
1444  *
1445  * @param c Connection.
1446  * @param peer Peer.
1447  */
1448 static void
1449 add_to_peer (struct CadetConnection *c, struct CadetPeer *peer)
1450 {
1451   GCP_add_tunnel (peer);
1452   c->t = GCP_get_tunnel (peer);
1453   GCT_add_connection (c->t, c);
1454 }
1455
1456
1457 /**
1458  * Builds a path from a PeerIdentity array.
1459  *
1460  * @param peers PeerIdentity array.
1461  * @param size Size of the @c peers array.
1462  * @param own_pos Output parameter: own position in the path.
1463  *
1464  * @return Fixed and shortened path.
1465  */
1466 static struct CadetPeerPath *
1467 build_path_from_peer_ids (struct GNUNET_PeerIdentity *peers,
1468                           unsigned int size,
1469                           unsigned int *own_pos)
1470 {
1471   struct CadetPeerPath *path;
1472   GNUNET_PEER_Id shortid;
1473   unsigned int i;
1474   unsigned int j;
1475   unsigned int offset;
1476
1477   /* Create path */
1478   LOG (GNUNET_ERROR_TYPE_DEBUG, "  Creating path...\n");
1479   path = path_new (size);
1480   *own_pos = 0;
1481   offset = 0;
1482   for (i = 0; i < size; i++)
1483   {
1484     LOG (GNUNET_ERROR_TYPE_DEBUG, "  - %u: taking %s\n",
1485          i, GNUNET_i2s (&peers[i]));
1486     shortid = GNUNET_PEER_intern (&peers[i]);
1487
1488     /* Check for loops / duplicates */
1489     for (j = 0; j < i - offset; j++)
1490     {
1491       if (path->peers[j] == shortid)
1492       {
1493         LOG (GNUNET_ERROR_TYPE_DEBUG, "    already exists at pos %u\n", j);
1494         offset = i - j;
1495         LOG (GNUNET_ERROR_TYPE_DEBUG, "    offset now %u\n", offset);
1496         GNUNET_PEER_change_rc (shortid, -1);
1497       }
1498     }
1499     LOG (GNUNET_ERROR_TYPE_DEBUG, "    storing at %u\n", i - offset);
1500     path->peers[i - offset] = shortid;
1501     if (path->peers[i - offset] == myid)
1502       *own_pos = i - offset;
1503   }
1504   path->length -= offset;
1505
1506   if (path->peers[*own_pos] != myid)
1507   {
1508     /* create path: self not found in path through self */
1509     GNUNET_break_op (0);
1510     path_destroy (path);
1511     return NULL;
1512   }
1513
1514   return path;
1515 }
1516
1517
1518 /**
1519  * Log receipt of message on stderr (INFO level).
1520  *
1521  * @param message Message received.
1522  * @param peer Peer who sent the message.
1523  * @param hash Connection ID.
1524  */
1525 static void
1526 log_message (const struct GNUNET_MessageHeader *message,
1527              const struct GNUNET_PeerIdentity *peer,
1528              const struct GNUNET_CADET_Hash *hash)
1529 {
1530   LOG (GNUNET_ERROR_TYPE_INFO, "<-- %s on connection %s from %s\n",
1531        GC_m2s (ntohs (message->type)), GNUNET_h2s (GC_h2hc (hash)),
1532        GNUNET_i2s (peer));
1533 }
1534
1535 /******************************************************************************/
1536 /********************************    API    ***********************************/
1537 /******************************************************************************/
1538
1539 /**
1540  * Core handler for connection creation.
1541  *
1542  * @param cls Closure (unused).
1543  * @param peer Sender (neighbor).
1544  * @param message Message.
1545  *
1546  * @return GNUNET_OK to keep the connection open,
1547  *         GNUNET_SYSERR to close it (signal serious error)
1548  */
1549 int
1550 GCC_handle_create (void *cls, const struct GNUNET_PeerIdentity *peer,
1551                    const struct GNUNET_MessageHeader *message)
1552 {
1553   struct GNUNET_CADET_ConnectionCreate *msg;
1554   struct GNUNET_PeerIdentity *id;
1555   struct GNUNET_CADET_Hash *cid;
1556   struct CadetPeerPath *path;
1557   struct CadetPeer *dest_peer;
1558   struct CadetPeer *orig_peer;
1559   struct CadetConnection *c;
1560   unsigned int own_pos;
1561   uint16_t size;
1562
1563   /* Check size */
1564   size = ntohs (message->size);
1565   if (size < sizeof (struct GNUNET_CADET_ConnectionCreate))
1566   {
1567     GNUNET_break_op (0);
1568     return GNUNET_OK;
1569   }
1570
1571   /* Calculate hops */
1572   size -= sizeof (struct GNUNET_CADET_ConnectionCreate);
1573   if (size % sizeof (struct GNUNET_PeerIdentity))
1574   {
1575     GNUNET_break_op (0);
1576     return GNUNET_OK;
1577   }
1578   size /= sizeof (struct GNUNET_PeerIdentity);
1579   if (1 > size)
1580   {
1581     GNUNET_break_op (0);
1582     return GNUNET_OK;
1583   }
1584   LOG (GNUNET_ERROR_TYPE_DEBUG, "    path has %u hops.\n", size);
1585
1586   /* Get parameters */
1587   msg = (struct GNUNET_CADET_ConnectionCreate *) message;
1588   cid = &msg->cid;
1589   log_message (message, peer, cid);
1590   id = (struct GNUNET_PeerIdentity *) &msg[1];
1591   LOG (GNUNET_ERROR_TYPE_DEBUG, "    origin: %s\n", GNUNET_i2s (id));
1592
1593   /* Create connection */
1594   c = connection_get (cid);
1595   if (NULL == c)
1596   {
1597     path = build_path_from_peer_ids ((struct GNUNET_PeerIdentity *) &msg[1],
1598                                      size, &own_pos);
1599     if (NULL == path)
1600       return GNUNET_OK;
1601     if (0 == own_pos)
1602     {
1603       GNUNET_break_op (0);
1604       path_destroy (path);
1605       return GNUNET_OK;
1606     }
1607     LOG (GNUNET_ERROR_TYPE_DEBUG, "  Own position: %u\n", own_pos);
1608     LOG (GNUNET_ERROR_TYPE_DEBUG, "  Creating connection\n");
1609     c = GCC_new (cid, NULL, path_duplicate (path), own_pos);
1610     if (NULL == c)
1611     {
1612       if (path->length - 1 == own_pos)
1613       {
1614         /* If we are destination, why did the creation fail? */
1615         GNUNET_break (0);
1616         return GNUNET_OK;
1617       }
1618       send_broken_unknown (cid, &my_full_id,
1619                            GNUNET_PEER_resolve2 (path->peers[own_pos + 1]),
1620                            peer);
1621       path_destroy (path);
1622       return GNUNET_OK;
1623     }
1624     GCP_add_path_to_all (path, GNUNET_NO);
1625     connection_reset_timeout (c, GNUNET_YES);
1626   }
1627   else
1628   {
1629     path = path_duplicate (c->path);
1630   }
1631   if (CADET_CONNECTION_NEW == c->state)
1632     connection_change_state (c, CADET_CONNECTION_SENT);
1633
1634   /* Remember peers */
1635   dest_peer = GCP_get (&id[size - 1]);
1636   orig_peer = GCP_get (&id[0]);
1637
1638   /* Is it a connection to us? */
1639   if (c->own_pos == path->length - 1)
1640   {
1641     LOG (GNUNET_ERROR_TYPE_DEBUG, "  It's for us!\n");
1642     GCP_add_path_to_origin (orig_peer, path_duplicate (path), GNUNET_YES);
1643
1644     add_to_peer (c, orig_peer);
1645     if (CADET_TUNNEL_NEW == GCT_get_cstate (c->t))
1646       GCT_change_cstate (c->t,  CADET_TUNNEL_WAITING);
1647
1648     send_connection_ack (c, GNUNET_NO);
1649     if (CADET_CONNECTION_SENT == c->state)
1650       connection_change_state (c, CADET_CONNECTION_ACK);
1651   }
1652   else
1653   {
1654     /* It's for somebody else! Retransmit. */
1655     LOG (GNUNET_ERROR_TYPE_DEBUG, "  Retransmitting.\n");
1656     GCP_add_path (dest_peer, path_duplicate (path), GNUNET_NO);
1657     GCP_add_path_to_origin (orig_peer, path_duplicate (path), GNUNET_NO);
1658     GNUNET_assert (NULL == GCC_send_prebuilt_message (message, 0, 0, c,
1659                                                       GNUNET_YES, GNUNET_YES,
1660                                                       NULL, NULL));
1661   }
1662   path_destroy (path);
1663   return GNUNET_OK;
1664 }
1665
1666
1667 /**
1668  * Core handler for path confirmations.
1669  *
1670  * @param cls closure
1671  * @param message message
1672  * @param peer peer identity this notification is about
1673  *
1674  * @return GNUNET_OK to keep the connection open,
1675  *         GNUNET_SYSERR to close it (signal serious error)
1676  */
1677 int
1678 GCC_handle_confirm (void *cls, const struct GNUNET_PeerIdentity *peer,
1679                     const struct GNUNET_MessageHeader *message)
1680 {
1681   struct GNUNET_CADET_ConnectionACK *msg;
1682   struct CadetConnection *c;
1683   struct CadetPeerPath *p;
1684   struct CadetPeer *pi;
1685   enum CadetConnectionState oldstate;
1686   int fwd;
1687
1688   msg = (struct GNUNET_CADET_ConnectionACK *) message;
1689   log_message (message, peer, &msg->cid);
1690   c = connection_get (&msg->cid);
1691   if (NULL == c)
1692   {
1693     GNUNET_STATISTICS_update (stats, "# control on unknown connection",
1694                               1, GNUNET_NO);
1695     LOG (GNUNET_ERROR_TYPE_DEBUG, "  don't know the connection!\n");
1696     send_broken_unknown (&msg->cid, &my_full_id, NULL, peer);
1697     return GNUNET_OK;
1698   }
1699
1700   if (GNUNET_NO != c->destroy)
1701   {
1702     LOG (GNUNET_ERROR_TYPE_DEBUG, "  connection being destroyed\n");
1703     return GNUNET_OK;
1704   }
1705
1706   oldstate = c->state;
1707   LOG (GNUNET_ERROR_TYPE_DEBUG, "  via peer %s\n", GNUNET_i2s (peer));
1708   pi = GCP_get (peer);
1709   if (get_next_hop (c) == pi)
1710   {
1711     LOG (GNUNET_ERROR_TYPE_DEBUG, "  SYNACK\n");
1712     fwd = GNUNET_NO;
1713     if (CADET_CONNECTION_SENT == oldstate)
1714       connection_change_state (c, CADET_CONNECTION_ACK);
1715   }
1716   else if (get_prev_hop (c) == pi)
1717   {
1718     LOG (GNUNET_ERROR_TYPE_DEBUG, "  FINAL ACK\n");
1719     fwd = GNUNET_YES;
1720     connection_change_state (c, CADET_CONNECTION_READY);
1721   }
1722   else
1723   {
1724     GNUNET_break_op (0);
1725     return GNUNET_OK;
1726   }
1727
1728   connection_reset_timeout (c, fwd);
1729
1730   /* Add path to peers? */
1731   p = c->path;
1732   if (NULL != p)
1733   {
1734     GCP_add_path_to_all (p, GNUNET_YES);
1735   }
1736   else
1737   {
1738     GNUNET_break (0);
1739   }
1740
1741   /* Message for us as creator? */
1742   if (GCC_is_origin (c, GNUNET_YES))
1743   {
1744     if (GNUNET_NO != fwd)
1745     {
1746       GNUNET_break_op (0);
1747       return GNUNET_OK;
1748     }
1749     LOG (GNUNET_ERROR_TYPE_DEBUG, "  Connection (SYN)ACK for us!\n");
1750
1751     /* If just created, cancel the short timeout and start a long one */
1752     if (CADET_CONNECTION_SENT == oldstate)
1753       connection_reset_timeout (c, GNUNET_YES);
1754
1755     /* Change connection state */
1756     connection_change_state (c, CADET_CONNECTION_READY);
1757     send_connection_ack (c, GNUNET_YES);
1758
1759     /* Change tunnel state, trigger KX */
1760     if (CADET_TUNNEL_WAITING == GCT_get_cstate (c->t))
1761       GCT_change_cstate (c->t, CADET_TUNNEL_READY);
1762
1763     return GNUNET_OK;
1764   }
1765
1766   /* Message for us as destination? */
1767   if (GCC_is_terminal (c, GNUNET_YES))
1768   {
1769     if (GNUNET_YES != fwd)
1770     {
1771       GNUNET_break_op (0);
1772       return GNUNET_OK;
1773     }
1774     LOG (GNUNET_ERROR_TYPE_DEBUG, "  Connection ACK for us!\n");
1775
1776     /* If just created, cancel the short timeout and start a long one */
1777     if (CADET_CONNECTION_ACK == oldstate)
1778       connection_reset_timeout (c, GNUNET_NO);
1779
1780     /* Change tunnel state */
1781     if (CADET_TUNNEL_WAITING == GCT_get_cstate (c->t))
1782       GCT_change_cstate (c->t, CADET_TUNNEL_READY);
1783
1784     return GNUNET_OK;
1785   }
1786
1787   LOG (GNUNET_ERROR_TYPE_DEBUG, "  not for us, retransmitting...\n");
1788   GNUNET_assert (NULL == GCC_send_prebuilt_message (message, 0, 0, c, fwd,
1789                                                     GNUNET_YES, NULL, NULL));
1790   return GNUNET_OK;
1791 }
1792
1793
1794 /**
1795  * Core handler for notifications of broken connections.
1796  *
1797  * @param cls Closure (unused).
1798  * @param id Peer identity of sending neighbor.
1799  * @param message Message.
1800  *
1801  * @return GNUNET_OK to keep the connection open,
1802  *         GNUNET_SYSERR to close it (signal serious error)
1803  */
1804 int
1805 GCC_handle_broken (void* cls,
1806                    const struct GNUNET_PeerIdentity* id,
1807                    const struct GNUNET_MessageHeader* message)
1808 {
1809   struct GNUNET_CADET_ConnectionBroken *msg;
1810   struct CadetConnection *c;
1811   struct CadetTunnel *t;
1812   int destroyed;
1813   int fwd;
1814
1815   msg = (struct GNUNET_CADET_ConnectionBroken *) message;
1816   log_message (message, id, &msg->cid);
1817   LOG (GNUNET_ERROR_TYPE_DEBUG, "  regarding %s\n",
1818               GNUNET_i2s (&msg->peer1));
1819   LOG (GNUNET_ERROR_TYPE_DEBUG, "  regarding %s\n",
1820               GNUNET_i2s (&msg->peer2));
1821   c = connection_get (&msg->cid);
1822   if (NULL == c)
1823   {
1824     LOG (GNUNET_ERROR_TYPE_DEBUG, "  duplicate CONNECTION_BROKEN\n");
1825     return GNUNET_OK;
1826   }
1827
1828   t = c->t;
1829   fwd = is_fwd (c, id);
1830   if (GCC_is_terminal (c, fwd))
1831   {
1832     struct GNUNET_MessageHeader *out_msg;
1833     struct CadetPeer *neighbor;
1834     struct CadetPeer *endpoint;
1835
1836     if (NULL == t)
1837     {
1838       /* A terminal connection should not have 't' set to NULL. */
1839       GNUNET_break (0);
1840       GCC_debug (c, GNUNET_ERROR_TYPE_ERROR);
1841       return GNUNET_OK;
1842     }
1843     neighbor = get_hop (c, !fwd);
1844     endpoint = GCP_get_short (c->path->peers[c->path->length - 1]);
1845     path_invalidate (c->path);
1846     GCP_notify_broken_link (endpoint, &msg->peer1, &msg->peer2);
1847     c->state = CADET_CONNECTION_BROKEN;
1848     GCT_remove_connection (t, c);
1849     c->t = NULL;
1850     destroyed = GNUNET_NO;
1851
1852     /* GCP_connection_pop could destroy the connection! */
1853     while (NULL != (out_msg = GCP_connection_pop (neighbor, c, &destroyed)))
1854     {
1855       GCT_resend_message (out_msg, t);
1856     }
1857     /* All pending messages should have been popped,
1858      * and the connection destroyed by the continuation.
1859      */
1860     if (GNUNET_YES != destroyed)
1861     {
1862       GNUNET_break (0);
1863       GCC_destroy (c);
1864     }
1865   }
1866   else
1867   {
1868     GNUNET_assert (NULL == GCC_send_prebuilt_message (message, 0, 0, c, fwd,
1869                                                       GNUNET_YES, NULL, NULL));
1870     c->destroy = GNUNET_YES;
1871     connection_cancel_queues (c, !fwd);
1872   }
1873
1874   return GNUNET_OK;
1875 }
1876
1877
1878 /**
1879  * Core handler for tunnel destruction
1880  *
1881  * @param cls Closure (unused).
1882  * @param peer Peer identity of sending neighbor.
1883  * @param message Message.
1884  *
1885  * @return GNUNET_OK to keep the connection open,
1886  *         GNUNET_SYSERR to close it (signal serious error)
1887  */
1888 int
1889 GCC_handle_destroy (void *cls, const struct GNUNET_PeerIdentity *peer,
1890                     const struct GNUNET_MessageHeader *message)
1891 {
1892   struct GNUNET_CADET_ConnectionDestroy *msg;
1893   struct CadetConnection *c;
1894   int fwd;
1895
1896   msg = (struct GNUNET_CADET_ConnectionDestroy *) message;
1897   log_message (message, peer, &msg->cid);
1898   c = connection_get (&msg->cid);
1899   if (NULL == c)
1900   {
1901     /* Probably already got the message from another path,
1902      * destroyed the tunnel and retransmitted to children.
1903      * Safe to ignore.
1904      */
1905     GNUNET_STATISTICS_update (stats, "# control on unknown connection",
1906                               1, GNUNET_NO);
1907     LOG (GNUNET_ERROR_TYPE_DEBUG, "  connection unknown: already destroyed?\n");
1908     return GNUNET_OK;
1909   }
1910   fwd = is_fwd (c, peer);
1911   if (GNUNET_SYSERR == fwd)
1912   {
1913     GNUNET_break_op (0); /* FIXME */
1914     return GNUNET_OK;
1915   }
1916   if (GNUNET_NO == GCC_is_terminal (c, fwd))
1917     GNUNET_assert (NULL == GCC_send_prebuilt_message (message, 0, 0, c, fwd,
1918                                                       GNUNET_YES, NULL, NULL));
1919   else if (0 == c->pending_messages)
1920   {
1921     LOG (GNUNET_ERROR_TYPE_DEBUG, "  directly destroying connection!\n");
1922     GCC_destroy (c);
1923     return GNUNET_OK;
1924   }
1925   c->destroy = GNUNET_YES;
1926   c->state = CADET_CONNECTION_DESTROYED;
1927   if (NULL != c->t)
1928   {
1929     GCT_remove_connection (c->t, c);
1930     c->t = NULL;
1931   }
1932
1933   return GNUNET_OK;
1934 }
1935
1936 /**
1937  * Generic handler for cadet network encrypted traffic.
1938  *
1939  * @param peer Peer identity this notification is about.
1940  * @param msg Encrypted message.
1941  *
1942  * @return GNUNET_OK to keep the connection open,
1943  *         GNUNET_SYSERR to close it (signal serious error)
1944  */
1945 static int
1946 handle_cadet_encrypted (const struct GNUNET_PeerIdentity *peer,
1947                        const struct GNUNET_CADET_Encrypted *msg)
1948 {
1949   struct CadetConnection *c;
1950   struct CadetPeer *neighbor;
1951   struct CadetFlowControl *fc;
1952   GNUNET_PEER_Id peer_id;
1953   uint32_t pid;
1954   uint32_t ttl;
1955   size_t size;
1956   int fwd;
1957
1958   log_message (&msg->header, peer, &msg->cid);
1959
1960   /* Check size */
1961   size = ntohs (msg->header.size);
1962   if (size <
1963       sizeof (struct GNUNET_CADET_Encrypted) +
1964       sizeof (struct GNUNET_MessageHeader))
1965   {
1966     GNUNET_break_op (0);
1967     return GNUNET_OK;
1968   }
1969
1970   /* Check connection */
1971   c = connection_get (&msg->cid);
1972   if (NULL == c)
1973   {
1974     GNUNET_STATISTICS_update (stats, "# unknown connection", 1, GNUNET_NO);
1975     LOG (GNUNET_ERROR_TYPE_DEBUG, "enc on unknown connection %s\n",
1976          GNUNET_h2s (GC_h2hc (&msg->cid)));
1977     send_broken_unknown (&msg->cid, &my_full_id, NULL, peer);
1978     return GNUNET_OK;
1979   }
1980
1981   LOG (GNUNET_ERROR_TYPE_DEBUG, "  connection %s\n", GCC_2s (c));
1982
1983   /* Check if origin is as expected */
1984   neighbor = get_prev_hop (c);
1985   peer_id = GNUNET_PEER_search (peer);
1986   if (peer_id == GCP_get_short_id (neighbor))
1987   {
1988     fwd = GNUNET_YES;
1989   }
1990   else
1991   {
1992     neighbor = get_next_hop (c);
1993     if (peer_id == GCP_get_short_id (neighbor))
1994     {
1995       fwd = GNUNET_NO;
1996     }
1997     else
1998     {
1999       /* Unexpected peer sending traffic on a connection. */
2000       GNUNET_break_op (0);
2001       return GNUNET_OK;
2002     }
2003   }
2004
2005   /* Check PID */
2006   fc = fwd ? &c->bck_fc : &c->fwd_fc;
2007   pid = ntohl (msg->pid);
2008   LOG (GNUNET_ERROR_TYPE_DEBUG, " PID %u (expected %u+)\n",
2009        pid, fc->last_pid_recv + 1);
2010   if (GC_is_pid_bigger (pid, fc->last_ack_sent))
2011   {
2012     GNUNET_STATISTICS_update (stats, "# unsolicited message", 1, GNUNET_NO);
2013     GNUNET_break_op (0);
2014     LOG (GNUNET_ERROR_TYPE_WARNING,
2015          "Received PID %u, (prev %u), ACK %u\n",
2016          pid, fc->last_pid_recv, fc->last_ack_sent);
2017     return GNUNET_OK;
2018   }
2019   if (GNUNET_NO == GC_is_pid_bigger (pid, fc->last_pid_recv))
2020   {
2021     GNUNET_STATISTICS_update (stats, "# duplicate PID", 1, GNUNET_NO);
2022     LOG (GNUNET_ERROR_TYPE_DEBUG,
2023                 " PID %u not expected (%u+), dropping!\n",
2024                 pid, fc->last_pid_recv + 1);
2025     return GNUNET_OK;
2026   }
2027   if (CADET_CONNECTION_SENT == c->state || CADET_CONNECTION_ACK == c->state)
2028     connection_change_state (c, CADET_CONNECTION_READY);
2029   connection_reset_timeout (c, fwd);
2030   fc->last_pid_recv = pid;
2031
2032   /* Is this message for us? */
2033   if (GCC_is_terminal (c, fwd))
2034   {
2035     LOG (GNUNET_ERROR_TYPE_DEBUG, "  message for us!\n");
2036     GNUNET_STATISTICS_update (stats, "# messages received", 1, GNUNET_NO);
2037
2038     if (NULL == c->t)
2039     {
2040       GNUNET_break (GNUNET_NO != c->destroy);
2041       return GNUNET_OK;
2042     }
2043     fc->last_pid_recv = pid;
2044     GCT_handle_encrypted (c->t, msg);
2045     GCC_send_ack (c, fwd, GNUNET_NO);
2046     return GNUNET_OK;
2047   }
2048
2049   /* Message not for us: forward to next hop */
2050   LOG (GNUNET_ERROR_TYPE_DEBUG, "  not for us, retransmitting...\n");
2051   ttl = ntohl (msg->ttl);
2052   LOG (GNUNET_ERROR_TYPE_DEBUG, "   ttl: %u\n", ttl);
2053   if (ttl == 0)
2054   {
2055     GNUNET_STATISTICS_update (stats, "# TTL drops", 1, GNUNET_NO);
2056     LOG (GNUNET_ERROR_TYPE_WARNING, " TTL is 0, DROPPING!\n");
2057     GCC_send_ack (c, fwd, GNUNET_NO);
2058     return GNUNET_OK;
2059   }
2060
2061   GNUNET_STATISTICS_update (stats, "# messages forwarded", 1, GNUNET_NO);
2062   GNUNET_assert (NULL == GCC_send_prebuilt_message (&msg->header, 0, 0, c, fwd,
2063                                                     GNUNET_NO, NULL, NULL));
2064
2065   return GNUNET_OK;
2066 }
2067
2068 /**
2069  * Generic handler for cadet network encrypted traffic.
2070  *
2071  * @param peer Peer identity this notification is about.
2072  * @param msg Encrypted message.
2073  *
2074  * @return GNUNET_OK to keep the connection open,
2075  *         GNUNET_SYSERR to close it (signal serious error)
2076  */
2077 static int
2078 handle_cadet_kx (const struct GNUNET_PeerIdentity *peer,
2079                 const struct GNUNET_CADET_KX *msg)
2080 {
2081   struct CadetConnection *c;
2082   struct CadetPeer *neighbor;
2083   GNUNET_PEER_Id peer_id;
2084   size_t size;
2085   int fwd;
2086
2087   log_message (&msg->header, peer, &msg->cid);
2088
2089   /* Check size */
2090   size = ntohs (msg->header.size);
2091   if (size <
2092       sizeof (struct GNUNET_CADET_KX) +
2093       sizeof (struct GNUNET_MessageHeader))
2094   {
2095     GNUNET_break_op (0);
2096     return GNUNET_OK;
2097   }
2098
2099   /* Check connection */
2100   c = connection_get (&msg->cid);
2101   if (NULL == c)
2102   {
2103     GNUNET_STATISTICS_update (stats, "# unknown connection", 1, GNUNET_NO);
2104     LOG (GNUNET_ERROR_TYPE_DEBUG, "kx on unknown connection %s\n",
2105          GNUNET_h2s (GC_h2hc (&msg->cid)));
2106     send_broken_unknown (&msg->cid, &my_full_id, NULL, peer);
2107     return GNUNET_OK;
2108   }
2109   LOG (GNUNET_ERROR_TYPE_DEBUG, " on connection %s\n", GCC_2s (c));
2110
2111   /* Check if origin is as expected */
2112   neighbor = get_prev_hop (c);
2113   peer_id = GNUNET_PEER_search (peer);
2114   if (peer_id == GCP_get_short_id (neighbor))
2115   {
2116     fwd = GNUNET_YES;
2117   }
2118   else
2119   {
2120     neighbor = get_next_hop (c);
2121     if (peer_id == GCP_get_short_id (neighbor))
2122     {
2123       fwd = GNUNET_NO;
2124     }
2125     else
2126     {
2127       /* Unexpected peer sending traffic on a connection. */
2128       GNUNET_break_op (0);
2129       return GNUNET_OK;
2130     }
2131   }
2132
2133   /* Count as connection confirmation. */
2134   if (CADET_CONNECTION_SENT == c->state || CADET_CONNECTION_ACK == c->state)
2135   {
2136     connection_change_state (c, CADET_CONNECTION_READY);
2137     if (NULL != c->t)
2138     {
2139       if (CADET_TUNNEL_WAITING == GCT_get_cstate (c->t))
2140         GCT_change_cstate (c->t, CADET_TUNNEL_READY);
2141     }
2142   }
2143   connection_reset_timeout (c, fwd);
2144
2145   /* Is this message for us? */
2146   if (GCC_is_terminal (c, fwd))
2147   {
2148     LOG (GNUNET_ERROR_TYPE_DEBUG, "  message for us!\n");
2149     GNUNET_STATISTICS_update (stats, "# messages received", 1, GNUNET_NO);
2150     if (NULL == c->t)
2151     {
2152       GNUNET_break (0);
2153       return GNUNET_OK;
2154     }
2155     GCT_handle_kx (c->t, &msg[1].header);
2156     return GNUNET_OK;
2157   }
2158
2159   /* Message not for us: forward to next hop */
2160   LOG (GNUNET_ERROR_TYPE_DEBUG, "  not for us, retransmitting...\n");
2161   GNUNET_STATISTICS_update (stats, "# messages forwarded", 1, GNUNET_NO);
2162   GNUNET_assert (NULL == GCC_send_prebuilt_message (&msg->header, 0, 0, c, fwd,
2163                                                     GNUNET_NO, NULL, NULL));
2164
2165   return GNUNET_OK;
2166 }
2167
2168
2169 /**
2170  * Core handler for encrypted cadet network traffic (channel mgmt, data).
2171  *
2172  * @param cls Closure (unused).
2173  * @param message Message received.
2174  * @param peer Peer who sent the message.
2175  *
2176  * @return GNUNET_OK to keep the connection open,
2177  *         GNUNET_SYSERR to close it (signal serious error)
2178  */
2179 int
2180 GCC_handle_encrypted (void *cls, const struct GNUNET_PeerIdentity *peer,
2181                       const struct GNUNET_MessageHeader *message)
2182 {
2183   return handle_cadet_encrypted (peer,
2184                                 (struct GNUNET_CADET_Encrypted *)message);
2185 }
2186
2187
2188 /**
2189  * Core handler for key exchange traffic (ephemeral key, ping, pong).
2190  *
2191  * @param cls Closure (unused).
2192  * @param message Message received.
2193  * @param peer Peer who sent the message.
2194  *
2195  * @return GNUNET_OK to keep the connection open,
2196  *         GNUNET_SYSERR to close it (signal serious error)
2197  */
2198 int
2199 GCC_handle_kx (void *cls, const struct GNUNET_PeerIdentity *peer,
2200                const struct GNUNET_MessageHeader *message)
2201 {
2202   return handle_cadet_kx (peer,
2203                          (struct GNUNET_CADET_KX *) message);
2204 }
2205
2206
2207 /**
2208  * Core handler for cadet network traffic point-to-point acks.
2209  *
2210  * @param cls closure
2211  * @param message message
2212  * @param peer peer identity this notification is about
2213  *
2214  * @return GNUNET_OK to keep the connection open,
2215  *         GNUNET_SYSERR to close it (signal serious error)
2216  */
2217 int
2218 GCC_handle_ack (void *cls, const struct GNUNET_PeerIdentity *peer,
2219                 const struct GNUNET_MessageHeader *message)
2220 {
2221   struct GNUNET_CADET_ACK *msg;
2222   struct CadetConnection *c;
2223   struct CadetFlowControl *fc;
2224   GNUNET_PEER_Id id;
2225   uint32_t ack;
2226   int fwd;
2227
2228   msg = (struct GNUNET_CADET_ACK *) message;
2229   log_message (message, peer, &msg->cid);
2230   c = connection_get (&msg->cid);
2231   if (NULL == c)
2232   {
2233     GNUNET_STATISTICS_update (stats, "# ack on unknown connection", 1,
2234                               GNUNET_NO);
2235     send_broken_unknown (&msg->cid, &my_full_id, NULL, peer);
2236     return GNUNET_OK;
2237   }
2238
2239   /* Is this a forward or backward ACK? */
2240   id = GNUNET_PEER_search (peer);
2241   if (GCP_get_short_id (get_next_hop (c)) == id)
2242   {
2243     LOG (GNUNET_ERROR_TYPE_DEBUG, "  FWD ACK\n");
2244     fc = &c->fwd_fc;
2245     fwd = GNUNET_YES;
2246   }
2247   else if (GCP_get_short_id (get_prev_hop (c)) == id)
2248   {
2249     LOG (GNUNET_ERROR_TYPE_DEBUG, "  BCK ACK\n");
2250     fc = &c->bck_fc;
2251     fwd = GNUNET_NO;
2252   }
2253   else
2254   {
2255     GNUNET_break_op (0);
2256     return GNUNET_OK;
2257   }
2258
2259   ack = ntohl (msg->ack);
2260   LOG (GNUNET_ERROR_TYPE_DEBUG, "  ACK %u (was %u)\n",
2261               ack, fc->last_ack_recv);
2262   if (GC_is_pid_bigger (ack, fc->last_ack_recv))
2263     fc->last_ack_recv = ack;
2264
2265   /* Cancel polling if the ACK is big enough. */
2266   if (GNUNET_SCHEDULER_NO_TASK != fc->poll_task &&
2267       GC_is_pid_bigger (fc->last_ack_recv, fc->last_pid_sent))
2268   {
2269     LOG (GNUNET_ERROR_TYPE_DEBUG, "  Cancel poll\n");
2270     GNUNET_SCHEDULER_cancel (fc->poll_task);
2271     fc->poll_task = GNUNET_SCHEDULER_NO_TASK;
2272     fc->poll_time = GNUNET_TIME_UNIT_SECONDS;
2273   }
2274
2275   connection_unlock_queue (c, fwd);
2276
2277   return GNUNET_OK;
2278 }
2279
2280
2281 /**
2282  * Core handler for cadet network traffic point-to-point ack polls.
2283  *
2284  * @param cls closure
2285  * @param message message
2286  * @param peer peer identity this notification is about
2287  *
2288  * @return GNUNET_OK to keep the connection open,
2289  *         GNUNET_SYSERR to close it (signal serious error)
2290  */
2291 int
2292 GCC_handle_poll (void *cls, const struct GNUNET_PeerIdentity *peer,
2293                  const struct GNUNET_MessageHeader *message)
2294 {
2295   struct GNUNET_CADET_Poll *msg;
2296   struct CadetConnection *c;
2297   struct CadetFlowControl *fc;
2298   GNUNET_PEER_Id id;
2299   uint32_t pid;
2300   int fwd;
2301
2302   msg = (struct GNUNET_CADET_Poll *) message;
2303   log_message (message, peer, &msg->cid);
2304   c = connection_get (&msg->cid);
2305   if (NULL == c)
2306   {
2307     GNUNET_STATISTICS_update (stats, "# poll on unknown connection", 1,
2308                               GNUNET_NO);
2309     LOG (GNUNET_ERROR_TYPE_DEBUG, "POLL message on unknown connection %s!\n",
2310          GNUNET_h2s (GC_h2hc (&msg->cid)));
2311     send_broken_unknown (&msg->cid, &my_full_id, NULL, peer);
2312     return GNUNET_OK;
2313   }
2314
2315   /* Is this a forward or backward ACK?
2316    * Note: a poll should never be needed in a loopback case,
2317    * since there is no possiblility of packet loss there, so
2318    * this way of discerining FWD/BCK should not be a problem.
2319    */
2320   id = GNUNET_PEER_search (peer);
2321   if (GCP_get_short_id (get_next_hop (c)) == id)
2322   {
2323     LOG (GNUNET_ERROR_TYPE_DEBUG, "  FWD FC\n");
2324     fc = &c->fwd_fc;
2325   }
2326   else if (GCP_get_short_id (get_prev_hop (c)) == id)
2327   {
2328     LOG (GNUNET_ERROR_TYPE_DEBUG, "  BCK FC\n");
2329     fc = &c->bck_fc;
2330   }
2331   else
2332   {
2333     GNUNET_break_op (0);
2334     return GNUNET_OK;
2335   }
2336
2337   pid = ntohl (msg->pid);
2338   LOG (GNUNET_ERROR_TYPE_DEBUG, "  PID %u, OLD %u\n", pid, fc->last_pid_recv);
2339   fc->last_pid_recv = pid;
2340   fwd = fc == &c->bck_fc;
2341   GCC_send_ack (c, fwd, GNUNET_YES);
2342
2343   return GNUNET_OK;
2344 }
2345
2346
2347 /**
2348  * Send an ACK on the appropriate connection/channel, depending on
2349  * the direction and the position of the peer.
2350  *
2351  * @param c Which connection to send the hop-by-hop ACK.
2352  * @param fwd Is this a fwd ACK? (will go dest->root).
2353  * @param force Send the ACK even if suboptimal (e.g. requested by POLL).
2354  */
2355 void
2356 GCC_send_ack (struct CadetConnection *c, int fwd, int force)
2357 {
2358   unsigned int buffer;
2359
2360   LOG (GNUNET_ERROR_TYPE_DEBUG,
2361        "GMC send %s ACK on %s\n",
2362        GC_f2s (fwd), GCC_2s (c));
2363
2364   if (NULL == c)
2365   {
2366     GNUNET_break (0);
2367     return;
2368   }
2369
2370   if (GNUNET_NO != c->destroy)
2371   {
2372     LOG (GNUNET_ERROR_TYPE_DEBUG, "  being destroyed, why bother...\n");
2373     return;
2374   }
2375
2376   /* Get available buffer space */
2377   if (GCC_is_terminal (c, fwd))
2378   {
2379     LOG (GNUNET_ERROR_TYPE_DEBUG, "  getting from all channels\n");
2380     buffer = GCT_get_channels_buffer (c->t);
2381   }
2382   else
2383   {
2384     LOG (GNUNET_ERROR_TYPE_DEBUG, "  getting from one connection\n");
2385     buffer = GCC_get_buffer (c, fwd);
2386   }
2387   LOG (GNUNET_ERROR_TYPE_DEBUG, "  buffer available: %u\n", buffer);
2388   if (0 == buffer && GNUNET_NO == force)
2389     return;
2390
2391   /* Send available buffer space */
2392   if (GCC_is_origin (c, fwd))
2393   {
2394     GNUNET_assert (NULL != c->t);
2395     LOG (GNUNET_ERROR_TYPE_DEBUG, "  sending on channels...\n");
2396     GCT_unchoke_channels (c->t);
2397   }
2398   else
2399   {
2400     LOG (GNUNET_ERROR_TYPE_DEBUG, "  sending on connection\n");
2401     send_ack (c, buffer, fwd, force);
2402   }
2403 }
2404
2405
2406 /**
2407  * Initialize the connections subsystem
2408  *
2409  * @param c Configuration handle.
2410  */
2411 void
2412 GCC_init (const struct GNUNET_CONFIGURATION_Handle *c)
2413 {
2414   LOG (GNUNET_ERROR_TYPE_DEBUG, "init\n");
2415   if (GNUNET_OK !=
2416       GNUNET_CONFIGURATION_get_value_number (c, "CADET", "MAX_MSGS_QUEUE",
2417                                              &max_msgs_queue))
2418   {
2419     GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
2420                                "CADET", "MAX_MSGS_QUEUE", "MISSING");
2421     GNUNET_SCHEDULER_shutdown ();
2422     return;
2423   }
2424
2425   if (GNUNET_OK !=
2426       GNUNET_CONFIGURATION_get_value_number (c, "CADET", "MAX_CONNECTIONS",
2427                                              &max_connections))
2428   {
2429     GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
2430                                "CADET", "MAX_CONNECTIONS", "MISSING");
2431     GNUNET_SCHEDULER_shutdown ();
2432     return;
2433   }
2434
2435   if (GNUNET_OK !=
2436       GNUNET_CONFIGURATION_get_value_time (c, "CADET", "REFRESH_CONNECTION_TIME",
2437                                            &refresh_connection_time))
2438   {
2439     GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
2440                                "CADET", "REFRESH_CONNECTION_TIME", "MISSING");
2441     GNUNET_SCHEDULER_shutdown ();
2442     return;
2443   }
2444   create_connection_time = GNUNET_TIME_UNIT_SECONDS;
2445   connections = GNUNET_CONTAINER_multihashmap_create (1024, GNUNET_NO);
2446 }
2447
2448
2449 /**
2450  * Destroy each connection on shutdown.
2451  *
2452  * @param cls Closure (unused).
2453  * @param key Current key code (CID, unused).
2454  * @param value Value in the hash map (connection)
2455  *
2456  * @return #GNUNET_YES, because we should continue to iterate,
2457  */
2458 static int
2459 shutdown_iterator (void *cls,
2460                    const struct GNUNET_HashCode *key,
2461                    void *value)
2462 {
2463   struct CadetConnection *c = value;
2464
2465   GCC_destroy (c);
2466   return GNUNET_YES;
2467 }
2468
2469
2470 /**
2471  * Shut down the connections subsystem.
2472  */
2473 void
2474 GCC_shutdown (void)
2475 {
2476   GNUNET_CONTAINER_multihashmap_iterate (connections, &shutdown_iterator, NULL);
2477   GNUNET_CONTAINER_multihashmap_destroy (connections);
2478   connections = NULL;
2479 }
2480
2481
2482 struct CadetConnection *
2483 GCC_new (const struct GNUNET_CADET_Hash *cid,
2484          struct CadetTunnel *t,
2485          struct CadetPeerPath *p,
2486          unsigned int own_pos)
2487 {
2488   struct CadetConnection *c;
2489
2490   c = GNUNET_new (struct CadetConnection);
2491   c->id = *cid;
2492   GNUNET_assert (GNUNET_OK ==
2493                  GNUNET_CONTAINER_multihashmap_put (connections,
2494                                                     GCC_get_h (c), c,
2495                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
2496   fc_init (&c->fwd_fc);
2497   fc_init (&c->bck_fc);
2498   c->fwd_fc.c = c;
2499   c->bck_fc.c = c;
2500
2501   c->t = t;
2502   GNUNET_assert (own_pos <= p->length - 1);
2503   c->own_pos = own_pos;
2504   c->path = p;
2505   p->c = c;
2506
2507   if (GNUNET_OK != register_neighbors (c))
2508   {
2509     if (0 == own_pos)
2510     {
2511       path_invalidate (c->path);
2512       c->t = NULL;
2513       c->path = NULL;
2514     }
2515     GCC_destroy (c);
2516     return NULL;
2517   }
2518
2519   return c;
2520 }
2521
2522
2523 void
2524 GCC_destroy (struct CadetConnection *c)
2525 {
2526   if (NULL == c)
2527   {
2528     GNUNET_break (0);
2529     return;
2530   }
2531
2532   if (2 == c->destroy) /* cancel queues -> GCP_queue_cancel -> q_destroy -> */
2533     return;            /* -> message_sent -> GCC_destroy. Don't loop. */
2534   c->destroy = 2;
2535
2536   LOG (GNUNET_ERROR_TYPE_DEBUG, "destroying connection %s\n", GCC_2s (c));
2537   LOG (GNUNET_ERROR_TYPE_DEBUG, " fc's f: %p, b: %p\n",
2538        &c->fwd_fc, &c->bck_fc);
2539   LOG (GNUNET_ERROR_TYPE_DEBUG, " fc tasks f: %u, b: %u\n",
2540        c->fwd_fc.poll_task, c->bck_fc.poll_task);
2541
2542   /* Cancel all traffic */
2543   if (NULL != c->path)
2544   {
2545     connection_cancel_queues (c, GNUNET_YES);
2546     connection_cancel_queues (c, GNUNET_NO);
2547     unregister_neighbors (c);
2548   }
2549
2550   LOG (GNUNET_ERROR_TYPE_DEBUG, " fc tasks f: %u, b: %u\n",
2551        c->fwd_fc.poll_task, c->bck_fc.poll_task);
2552
2553   /* Cancel maintainance task (keepalive/timeout) */
2554   if (NULL != c->fwd_fc.poll_msg)
2555   {
2556     GCC_cancel (c->fwd_fc.poll_msg);
2557     LOG (GNUNET_ERROR_TYPE_DEBUG, " *** POLL msg FWD canceled\n");
2558   }
2559   if (NULL != c->bck_fc.poll_msg)
2560   {
2561     GCC_cancel (c->bck_fc.poll_msg);
2562     LOG (GNUNET_ERROR_TYPE_DEBUG, " *** POLL msg BCK canceled\n");
2563   }
2564
2565   /* Delete from tunnel */
2566   if (NULL != c->t)
2567     GCT_remove_connection (c->t, c);
2568
2569   if (GNUNET_NO == GCC_is_origin (c, GNUNET_YES) && NULL != c->path)
2570     path_destroy (c->path);
2571   if (GNUNET_SCHEDULER_NO_TASK != c->fwd_maintenance_task)
2572     GNUNET_SCHEDULER_cancel (c->fwd_maintenance_task);
2573   if (GNUNET_SCHEDULER_NO_TASK != c->bck_maintenance_task)
2574     GNUNET_SCHEDULER_cancel (c->bck_maintenance_task);
2575   if (GNUNET_SCHEDULER_NO_TASK != c->fwd_fc.poll_task)
2576   {
2577     GNUNET_SCHEDULER_cancel (c->fwd_fc.poll_task);
2578     LOG (GNUNET_ERROR_TYPE_DEBUG, " *** POLL FWD canceled\n");
2579   }
2580   if (GNUNET_SCHEDULER_NO_TASK != c->bck_fc.poll_task)
2581   {
2582     GNUNET_SCHEDULER_cancel (c->bck_fc.poll_task);
2583     LOG (GNUNET_ERROR_TYPE_DEBUG, " *** POLL BCK canceled\n");
2584   }
2585
2586   GNUNET_break (GNUNET_YES ==
2587                 GNUNET_CONTAINER_multihashmap_remove (connections,
2588                                                       GCC_get_h (c), c));
2589
2590   GNUNET_STATISTICS_update (stats, "# connections", -1, GNUNET_NO);
2591   GNUNET_free (c);
2592 }
2593
2594 /**
2595  * Get the connection ID.
2596  *
2597  * @param c Connection to get the ID from.
2598  *
2599  * @return ID of the connection.
2600  */
2601 const struct GNUNET_CADET_Hash *
2602 GCC_get_id (const struct CadetConnection *c)
2603 {
2604   return &c->id;
2605 }
2606
2607
2608 /**
2609  * Get the connection ID.
2610  *
2611  * @param c Connection to get the ID from.
2612  *
2613  * @return ID of the connection.
2614  */
2615 const struct GNUNET_HashCode *
2616 GCC_get_h (const struct CadetConnection *c)
2617 {
2618   return GC_h2hc (&c->id);
2619 }
2620
2621
2622 /**
2623  * Get the connection path.
2624  *
2625  * @param c Connection to get the path from.
2626  *
2627  * @return path used by the connection.
2628  */
2629 const struct CadetPeerPath *
2630 GCC_get_path (const struct CadetConnection *c)
2631 {
2632   if (GNUNET_NO == c->destroy)
2633     return c->path;
2634   return NULL;
2635 }
2636
2637
2638 /**
2639  * Get the connection state.
2640  *
2641  * @param c Connection to get the state from.
2642  *
2643  * @return state of the connection.
2644  */
2645 enum CadetConnectionState
2646 GCC_get_state (const struct CadetConnection *c)
2647 {
2648   return c->state;
2649 }
2650
2651 /**
2652  * Get the connection tunnel.
2653  *
2654  * @param c Connection to get the tunnel from.
2655  *
2656  * @return tunnel of the connection.
2657  */
2658 struct CadetTunnel *
2659 GCC_get_tunnel (const struct CadetConnection *c)
2660 {
2661   return c->t;
2662 }
2663
2664
2665 /**
2666  * Get free buffer space in a connection.
2667  *
2668  * @param c Connection.
2669  * @param fwd Is query about FWD traffic?
2670  *
2671  * @return Free buffer space [0 - max_msgs_queue/max_connections]
2672  */
2673 unsigned int
2674 GCC_get_buffer (struct CadetConnection *c, int fwd)
2675 {
2676   struct CadetFlowControl *fc;
2677
2678   fc = fwd ? &c->fwd_fc : &c->bck_fc;
2679
2680   return (fc->queue_max - fc->queue_n);
2681 }
2682
2683 /**
2684  * Get how many messages have we allowed to send to us from a direction.
2685  *
2686  * @param c Connection.
2687  * @param fwd Are we asking about traffic from FWD (BCK messages)?
2688  *
2689  * @return last_ack_sent - last_pid_recv
2690  */
2691 unsigned int
2692 GCC_get_allowed (struct CadetConnection *c, int fwd)
2693 {
2694   struct CadetFlowControl *fc;
2695
2696   fc = fwd ? &c->fwd_fc : &c->bck_fc;
2697   if (GC_is_pid_bigger (fc->last_pid_recv, fc->last_ack_sent))
2698   {
2699     return 0;
2700   }
2701   return (fc->last_ack_sent - fc->last_pid_recv);
2702 }
2703
2704 /**
2705  * Get messages queued in a connection.
2706  *
2707  * @param c Connection.
2708  * @param fwd Is query about FWD traffic?
2709  *
2710  * @return Number of messages queued.
2711  */
2712 unsigned int
2713 GCC_get_qn (struct CadetConnection *c, int fwd)
2714 {
2715   struct CadetFlowControl *fc;
2716
2717   fc = fwd ? &c->fwd_fc : &c->bck_fc;
2718
2719   return fc->queue_n;
2720 }
2721
2722
2723 /**
2724  * Get next PID to use.
2725  *
2726  * @param c Connection.
2727  * @param fwd Is query about FWD traffic?
2728  *
2729  * @return Last PID used + 1.
2730  */
2731 unsigned int
2732 GCC_get_pid (struct CadetConnection *c, int fwd)
2733 {
2734   struct CadetFlowControl *fc;
2735
2736   fc = fwd ? &c->fwd_fc : &c->bck_fc;
2737
2738   return fc->last_pid_sent + 1;
2739 }
2740
2741
2742 /**
2743  * Allow the connection to advertise a buffer of the given size.
2744  *
2745  * The connection will send an @c fwd ACK message (so: in direction !fwd)
2746  * allowing up to last_pid_recv + buffer.
2747  *
2748  * @param c Connection.
2749  * @param buffer How many more messages the connection can accept.
2750  * @param fwd Is this about FWD traffic? (The ack will go dest->root).
2751  */
2752 void
2753 GCC_allow (struct CadetConnection *c, unsigned int buffer, int fwd)
2754 {
2755   LOG (GNUNET_ERROR_TYPE_DEBUG, "  allowing %s %u messages %s\n",
2756        GCC_2s (c), buffer, GC_f2s (fwd));
2757   send_ack (c, buffer, fwd, GNUNET_NO);
2758 }
2759
2760
2761 /**
2762  * Notify other peers on a connection of a broken link. Mark connections
2763  * to destroy after all traffic has been sent.
2764  *
2765  * @param c Connection on which there has been a disconnection.
2766  * @param peer Peer that disconnected.
2767  */
2768 void
2769 GCC_notify_broken (struct CadetConnection *c,
2770                    struct CadetPeer *peer)
2771 {
2772   int fwd;
2773
2774   LOG (GNUNET_ERROR_TYPE_DEBUG,
2775        " notify broken on %s due to %s disconnect\n",
2776        GCC_2s (c), GCP_2s (peer));
2777
2778   fwd = peer == get_prev_hop (c);
2779
2780   if (GNUNET_YES == GCC_is_terminal (c, fwd))
2781   {
2782     /* Local shutdown, no one to notify about this. */
2783     GCC_destroy (c);
2784     return;
2785   }
2786   if (GNUNET_NO == c->destroy)
2787     send_broken (c, &my_full_id, GCP_get_id (peer), fwd);
2788
2789   /* Connection will have at least one pending message
2790    * (the one we just scheduled), so no point in checking whether to
2791    * destroy immediately. */
2792   c->destroy = GNUNET_YES;
2793   c->state = CADET_CONNECTION_DESTROYED;
2794
2795   /**
2796    * Cancel all queues, if no message is left, connection will be destroyed.
2797    */
2798   connection_cancel_queues (c, !fwd);
2799
2800   return;
2801 }
2802
2803
2804 /**
2805  * Is this peer the first one on the connection?
2806  *
2807  * @param c Connection.
2808  * @param fwd Is this about fwd traffic?
2809  *
2810  * @return #GNUNET_YES if origin, #GNUNET_NO if relay/terminal.
2811  */
2812 int
2813 GCC_is_origin (struct CadetConnection *c, int fwd)
2814 {
2815   if (!fwd && c->path->length - 1 == c->own_pos )
2816     return GNUNET_YES;
2817   if (fwd && 0 == c->own_pos)
2818     return GNUNET_YES;
2819   return GNUNET_NO;
2820 }
2821
2822
2823 /**
2824  * Is this peer the last one on the connection?
2825  *
2826  * @param c Connection.
2827  * @param fwd Is this about fwd traffic?
2828  *            Note that the ROOT is the terminal for BCK traffic!
2829  *
2830  * @return #GNUNET_YES if terminal, #GNUNET_NO if relay/origin.
2831  */
2832 int
2833 GCC_is_terminal (struct CadetConnection *c, int fwd)
2834 {
2835   return GCC_is_origin (c, !fwd);
2836 }
2837
2838
2839 /**
2840  * See if we are allowed to send by the next hop in the given direction.
2841  *
2842  * @param c Connection.
2843  * @param fwd Is this about fwd traffic?
2844  *
2845  * @return #GNUNET_YES in case it's OK to send.
2846  */
2847 int
2848 GCC_is_sendable (struct CadetConnection *c, int fwd)
2849 {
2850   struct CadetFlowControl *fc;
2851
2852   LOG (GNUNET_ERROR_TYPE_DEBUG, " checking sendability of %s traffic on %s\n",
2853        GC_f2s (fwd), GCC_2s (c));
2854   if (NULL == c)
2855   {
2856     GNUNET_break (0);
2857     return GNUNET_YES;
2858   }
2859   fc = fwd ? &c->fwd_fc : &c->bck_fc;
2860   LOG (GNUNET_ERROR_TYPE_DEBUG,
2861        " last ack recv: %u, last pid sent: %u\n",
2862        fc->last_ack_recv, fc->last_pid_sent);
2863   if (GC_is_pid_bigger (fc->last_ack_recv, fc->last_pid_sent))
2864   {
2865     LOG (GNUNET_ERROR_TYPE_DEBUG, " sendable\n");
2866     return GNUNET_YES;
2867   }
2868   LOG (GNUNET_ERROR_TYPE_DEBUG, " not sendable\n");
2869   return GNUNET_NO;
2870 }
2871
2872
2873 /**
2874  * Check if this connection is a direct one (never trim a direct connection).
2875  *
2876  * @param c Connection.
2877  *
2878  * @return #GNUNET_YES in case it's a direct connection, #GNUNET_NO otherwise.
2879  */
2880 int
2881 GCC_is_direct (struct CadetConnection *c)
2882 {
2883   return (c->path->length == 2) ? GNUNET_YES : GNUNET_NO;
2884 }
2885
2886 /**
2887  * Sends an already built message on a connection, properly registering
2888  * all used resources.
2889  *
2890  * @param message Message to send. Function makes a copy of it.
2891  *                If message is not hop-by-hop, decrements TTL of copy.
2892  * @param payload_type Type of payload, in case the message is encrypted.
2893  * @param c Connection on which this message is transmitted.
2894  * @param fwd Is this a fwd message?
2895  * @param force Force the connection to accept the message (buffer overfill).
2896  * @param cont Continuation called once message is sent. Can be NULL.
2897  * @param cont_cls Closure for @c cont.
2898  *
2899  * @return Handle to cancel the message before it's sent.
2900  *         NULL on error or if @c cont is NULL.
2901  *         Invalid on @c cont call.
2902  */
2903 struct CadetConnectionQueue *
2904 GCC_send_prebuilt_message (const struct GNUNET_MessageHeader *message,
2905                            uint16_t payload_type, uint32_t payload_id,
2906                            struct CadetConnection *c, int fwd, int force,
2907                            GCC_sent cont, void *cont_cls)
2908 {
2909   struct CadetFlowControl *fc;
2910   struct CadetConnectionQueue *q;
2911   void *data;
2912   size_t size;
2913   uint16_t type;
2914   int droppable;
2915
2916   size = ntohs (message->size);
2917   data = GNUNET_malloc (size);
2918   memcpy (data, message, size);
2919   type = ntohs (message->type);
2920   LOG (GNUNET_ERROR_TYPE_INFO, "--> %s (%s %u) on connection %s (%u bytes)\n",
2921        GC_m2s (type), GC_m2s (payload_type), payload_id, GCC_2s (c), size);
2922
2923   fc = fwd ? &c->fwd_fc : &c->bck_fc;
2924   droppable = GNUNET_NO == force;
2925   switch (type)
2926   {
2927     struct GNUNET_CADET_Encrypted *emsg;
2928     struct GNUNET_CADET_KX        *kmsg;
2929     struct GNUNET_CADET_ACK       *amsg;
2930     struct GNUNET_CADET_Poll      *pmsg;
2931     struct GNUNET_CADET_ConnectionDestroy *dmsg;
2932     struct GNUNET_CADET_ConnectionBroken  *bmsg;
2933     uint32_t ttl;
2934
2935     case GNUNET_MESSAGE_TYPE_CADET_ENCRYPTED:
2936       emsg = (struct GNUNET_CADET_Encrypted *) data;
2937       ttl = ntohl (emsg->ttl);
2938       if (0 == ttl)
2939       {
2940         GNUNET_break_op (0);
2941         GNUNET_free (data);
2942         return NULL;
2943       }
2944       emsg->cid = c->id;
2945       emsg->ttl = htonl (ttl - 1);
2946       emsg->pid = htonl (0);
2947       LOG (GNUNET_ERROR_TYPE_DEBUG, "  Q_N+ %p %u\n", fc, fc->queue_n);
2948       LOG (GNUNET_ERROR_TYPE_DEBUG, "last pid sent %u\n", fc->last_pid_sent);
2949       LOG (GNUNET_ERROR_TYPE_DEBUG, "     ack recv %u\n", fc->last_ack_recv);
2950       if (GNUNET_YES == droppable)
2951       {
2952         fc->queue_n++;
2953       }
2954       else
2955       {
2956         LOG (GNUNET_ERROR_TYPE_DEBUG, "  not droppable, Q_N stays the same\n");
2957       }
2958       if (GC_is_pid_bigger (fc->last_pid_sent + 1, fc->last_ack_recv))
2959       {
2960         GCC_start_poll (c, fwd);
2961       }
2962       break;
2963
2964     case GNUNET_MESSAGE_TYPE_CADET_KX:
2965       kmsg = (struct GNUNET_CADET_KX *) data;
2966       kmsg->cid = c->id;
2967       break;
2968
2969     case GNUNET_MESSAGE_TYPE_CADET_ACK:
2970       amsg = (struct GNUNET_CADET_ACK *) data;
2971       amsg->cid = c->id;
2972       LOG (GNUNET_ERROR_TYPE_DEBUG, " ack %u\n", ntohl (amsg->ack));
2973       droppable = GNUNET_NO;
2974       break;
2975
2976     case GNUNET_MESSAGE_TYPE_CADET_POLL:
2977       pmsg = (struct GNUNET_CADET_Poll *) data;
2978       pmsg->cid = c->id;
2979       LOG (GNUNET_ERROR_TYPE_DEBUG, " poll %u\n", ntohl (pmsg->pid));
2980       droppable = GNUNET_NO;
2981       break;
2982
2983     case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY:
2984       dmsg = (struct GNUNET_CADET_ConnectionDestroy *) data;
2985       dmsg->cid = c->id;
2986       break;
2987
2988     case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN:
2989       bmsg = (struct GNUNET_CADET_ConnectionBroken *) data;
2990       bmsg->cid = c->id;
2991       break;
2992
2993     case GNUNET_MESSAGE_TYPE_CADET_KEEPALIVE:
2994       GNUNET_break (0);
2995       /* falltrough */
2996     case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE:
2997     case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK:
2998       break;
2999
3000     default:
3001       GNUNET_break (0);
3002       GNUNET_free (data);
3003       return NULL;
3004   }
3005
3006   if (fc->queue_n > fc->queue_max && droppable)
3007   {
3008     GNUNET_STATISTICS_update (stats, "# messages dropped (buffer full)",
3009                               1, GNUNET_NO);
3010     GNUNET_break (0);
3011     LOG (GNUNET_ERROR_TYPE_DEBUG, "queue full: %u/%u\n",
3012          fc->queue_n, fc->queue_max);
3013     if (GNUNET_MESSAGE_TYPE_CADET_ENCRYPTED == type)
3014     {
3015       fc->queue_n--;
3016     }
3017     GNUNET_free (data);
3018     return NULL; /* Drop this message */
3019   }
3020
3021   LOG (GNUNET_ERROR_TYPE_DEBUG, "  C_P+ %s %u\n",
3022        GCC_2s (c), c->pending_messages);
3023   c->pending_messages++;
3024
3025   q = GNUNET_new (struct CadetConnectionQueue);
3026   q->forced = !droppable;
3027   q->q = GCP_queue_add (get_hop (c, fwd), data, type, payload_type, payload_id,
3028                         size, c, fwd, &conn_message_sent, q);
3029   if (NULL == q->q)
3030   {
3031     LOG (GNUNET_ERROR_TYPE_DEBUG, "dropping msg on %s, NULL q\n", GCC_2s (c));
3032     GNUNET_free (data);
3033     GNUNET_free (q);
3034     return NULL;
3035   }
3036   q->cont = cont;
3037   q->cont_cls = cont_cls;
3038   return (NULL == cont) ? NULL : q;
3039 }
3040
3041
3042 /**
3043  * Cancel a previously sent message while it's in the queue.
3044  *
3045  * ONLY can be called before the continuation given to the send function
3046  * is called. Once the continuation is called, the message is no longer in the
3047  * queue.
3048  *
3049  * @param q Handle to the queue.
3050  */
3051 void
3052 GCC_cancel (struct CadetConnectionQueue *q)
3053 {
3054   LOG (GNUNET_ERROR_TYPE_DEBUG, "!  GMC cancel message\n");
3055
3056   /* queue destroy calls message_sent, which calls q->cont and frees q */
3057   GCP_queue_destroy (q->q, GNUNET_YES, GNUNET_NO, 0);
3058 }
3059
3060
3061 /**
3062  * Sends a CREATE CONNECTION message for a path to a peer.
3063  * Changes the connection and tunnel states if necessary.
3064  *
3065  * @param connection Connection to create.
3066  */
3067 void
3068 GCC_send_create (struct CadetConnection *connection)
3069 {
3070   enum CadetTunnelCState state;
3071   size_t size;
3072
3073   size = sizeof (struct GNUNET_CADET_ConnectionCreate);
3074   size += connection->path->length * sizeof (struct GNUNET_PeerIdentity);
3075
3076   LOG (GNUNET_ERROR_TYPE_INFO, "===> %s on connection %s  (%u bytes)\n",
3077        GC_m2s (GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE),
3078        GCC_2s (connection), size);
3079   LOG (GNUNET_ERROR_TYPE_DEBUG, "  C_P+ %p %u (create)\n",
3080        connection, connection->pending_messages);
3081   connection->pending_messages++;
3082
3083   connection->maintenance_q =
3084     GCP_queue_add (get_next_hop (connection), NULL,
3085                    GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE, 0, 0,
3086                    size, connection, GNUNET_YES, &conn_message_sent, NULL);
3087
3088   state = GCT_get_cstate (connection->t);
3089   if (CADET_TUNNEL_SEARCHING == state || CADET_TUNNEL_NEW == state)
3090     GCT_change_cstate (connection->t, CADET_TUNNEL_WAITING);
3091   if (CADET_CONNECTION_NEW == connection->state)
3092     connection_change_state (connection, CADET_CONNECTION_SENT);
3093 }
3094
3095
3096 /**
3097  * Send a message to all peers in this connection that the connection
3098  * is no longer valid.
3099  *
3100  * If some peer should not receive the message, it should be zero'ed out
3101  * before calling this function.
3102  *
3103  * @param c The connection whose peers to notify.
3104  */
3105 void
3106 GCC_send_destroy (struct CadetConnection *c)
3107 {
3108   struct GNUNET_CADET_ConnectionDestroy msg;
3109
3110   if (GNUNET_YES == c->destroy)
3111     return;
3112
3113   msg.header.size = htons (sizeof (msg));
3114   msg.header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY);
3115   msg.cid = c->id;
3116   LOG (GNUNET_ERROR_TYPE_DEBUG,
3117               "  sending connection destroy for connection %s\n",
3118               GCC_2s (c));
3119
3120   if (GNUNET_NO == GCC_is_terminal (c, GNUNET_YES))
3121     GNUNET_assert (NULL == GCC_send_prebuilt_message (&msg.header, 0, 0, c,
3122                                                       GNUNET_YES, GNUNET_YES,
3123                                                       NULL, NULL));
3124   if (GNUNET_NO == GCC_is_terminal (c, GNUNET_NO))
3125     GNUNET_assert (NULL == GCC_send_prebuilt_message (&msg.header, 0, 0, c,
3126                                                       GNUNET_NO, GNUNET_YES,
3127                                                       NULL, NULL));
3128   c->destroy = GNUNET_YES;
3129   c->state = CADET_CONNECTION_DESTROYED;
3130 }
3131
3132
3133 /**
3134  * @brief Start a polling timer for the connection.
3135  *
3136  * When a neighbor does not accept more traffic on the connection it could be
3137  * caused by a simple congestion or by a lost ACK. Polling enables to check
3138  * for the lastest ACK status for a connection.
3139  *
3140  * @param c Connection.
3141  * @param fwd Should we poll in the FWD direction?
3142  */
3143 void
3144 GCC_start_poll (struct CadetConnection *c, int fwd)
3145 {
3146   struct CadetFlowControl *fc;
3147
3148   fc = fwd ? &c->fwd_fc : &c->bck_fc;
3149   LOG (GNUNET_ERROR_TYPE_DEBUG, " *** POLL %s requested\n",
3150        GC_f2s (fwd));
3151   if (GNUNET_SCHEDULER_NO_TASK != fc->poll_task || NULL != fc->poll_msg)
3152   {
3153     LOG (GNUNET_ERROR_TYPE_DEBUG, " ***   not needed (%u, %p)\n",
3154          fc->poll_task, fc->poll_msg);
3155     return;
3156   }
3157   LOG (GNUNET_ERROR_TYPE_DEBUG, " *** POLL started on request\n");
3158   fc->poll_task = GNUNET_SCHEDULER_add_delayed (fc->poll_time,
3159                                                 &connection_poll,
3160                                                 fc);
3161 }
3162
3163
3164 /**
3165  * @brief Stop polling a connection for ACKs.
3166  *
3167  * Once we have enough ACKs for future traffic, polls are no longer necessary.
3168  *
3169  * @param c Connection.
3170  * @param fwd Should we stop the poll in the FWD direction?
3171  */
3172 void
3173 GCC_stop_poll (struct CadetConnection *c, int fwd)
3174 {
3175   struct CadetFlowControl *fc;
3176
3177   fc = fwd ? &c->fwd_fc : &c->bck_fc;
3178   if (GNUNET_SCHEDULER_NO_TASK != fc->poll_task)
3179   {
3180     GNUNET_SCHEDULER_cancel (fc->poll_task);
3181     fc->poll_task = GNUNET_SCHEDULER_NO_TASK;
3182   }
3183 }
3184
3185 /**
3186  * Get a (static) string for a connection.
3187  *
3188  * @param c Connection.
3189  */
3190 const char *
3191 GCC_2s (const struct CadetConnection *c)
3192 {
3193   if (NULL == c)
3194     return "NULL";
3195
3196   if (NULL != c->t)
3197   {
3198     static char buf[128];
3199
3200     sprintf (buf, "%s (->%s)",
3201              GNUNET_h2s (GC_h2hc (GCC_get_id (c))), GCT_2s (c->t));
3202     return buf;
3203   }
3204   return GNUNET_h2s (GC_h2hc (&c->id));
3205 }
3206
3207
3208 /**
3209  * Log all possible info about the connection state.
3210  *
3211  * @param c Connection to debug.
3212  * @param level Debug level to use.
3213  */
3214 void
3215 GCC_debug (const struct CadetConnection *c, enum GNUNET_ErrorType level)
3216 {
3217   int do_log;
3218   char *s;
3219
3220   do_log = GNUNET_get_log_call_status (level & (~GNUNET_ERROR_TYPE_BULK),
3221                                        "cadet-con",
3222                                        __FILE__, __FUNCTION__, __LINE__);
3223   if (0 == do_log)
3224     return;
3225
3226   if (NULL == c)
3227   {
3228     LOG2 (level, "CCC DEBUG NULL CONNECTION\n");
3229     return;
3230   }
3231
3232   LOG2 (level, "CCC DEBUG CONNECTION %s\n", GCC_2s (c));
3233   s = path_2s (c->path);
3234   LOG2 (level, "CCC  path %s, own pos: %u\n", s, c->own_pos);
3235   GNUNET_free (s);
3236   LOG2 (level, "CCC  state: %s, destroy: %u\n",
3237         GCC_state2s (c->state), c->destroy);
3238   LOG2 (level, "CCC  pending messages: %u\n", c->pending_messages);
3239   if (NULL != c->perf)
3240     LOG2 (level, "CCC  us/byte: %f\n", c->perf->avg);
3241
3242   LOG2 (level, "CCC  FWD flow control:\n");
3243   LOG2 (level, "CCC   queue: %u/%u\n", c->fwd_fc.queue_n, c->fwd_fc.queue_max);
3244   LOG2 (level, "CCC   last PID sent: %5u, recv: %5u\n",
3245         c->fwd_fc.last_pid_sent, c->fwd_fc.last_pid_recv);
3246   LOG2 (level, "CCC   last ACK sent: %5u, recv: %5u\n",
3247         c->fwd_fc.last_ack_sent, c->fwd_fc.last_ack_recv);
3248   LOG2 (level, "CCC   POLL: task %d, msg  %p, msg_ack %p)\n",
3249         c->fwd_fc.poll_task, c->fwd_fc.poll_msg, c->fwd_fc.ack_msg);
3250
3251   LOG2 (level, "CCC  BCK flow control:\n");
3252   LOG2 (level, "CCC   queue: %u/%u\n", c->bck_fc.queue_n, c->bck_fc.queue_max);
3253   LOG2 (level, "CCC   last PID sent: %5u, recv: %5u\n",
3254         c->bck_fc.last_pid_sent, c->bck_fc.last_pid_recv);
3255   LOG2 (level, "CCC   last ACK sent: %5u, recv: %5u\n",
3256         c->bck_fc.last_ack_sent, c->bck_fc.last_ack_recv);
3257   LOG2 (level, "CCC   POLL: task %d, msg  %p, msg_ack %p)\n",
3258         c->bck_fc.poll_task, c->bck_fc.poll_msg, c->bck_fc.ack_msg);
3259
3260   LOG2 (level, "CCC DEBUG CONNECTION END\n");
3261 }
3262