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  * Resend all queued messages for a connection on other connections of the
1262  * same tunnel, if possible. The connection WILL BE DESTROYED by this function.
1263  *
1264  * @param c Connection whose messages to resend.
1265  * @param fwd Resend fwd messages?
1266  */
1267 static void
1268 resend_messages_and_destroy (struct CadetConnection *c, int fwd)
1269 {
1270   struct GNUNET_MessageHeader *out_msg;
1271   struct CadetTunnel *t = c->t;
1272   struct CadetPeer *neighbor;
1273   int destroyed;
1274
1275   c->state = CADET_CONNECTION_DESTROYED;
1276   c->destroy = GNUNET_YES;
1277
1278   destroyed = GNUNET_NO;
1279   neighbor = get_hop (c, fwd);
1280
1281   while (NULL != (out_msg = GCP_connection_pop (neighbor, c, &destroyed)))
1282     GCT_resend_message (out_msg, t);
1283
1284   /* All pending messages should have been popped,
1285    * and the connection destroyed by the continuation.
1286    */
1287   if (GNUNET_YES != destroyed)
1288   {
1289     GNUNET_break (0);
1290     GCC_debug (c, GNUNET_ERROR_TYPE_ERROR);
1291     GCT_debug (t, GNUNET_ERROR_TYPE_ERROR);
1292     GCC_destroy (c);
1293   }
1294 }
1295
1296
1297 /**
1298  * Timeout function due to lack of keepalive/traffic from the owner.
1299  * Destroys connection if called.
1300  *
1301  * @param cls Closure (connection to destroy).
1302  * @param tc TaskContext.
1303  */
1304 static void
1305 connection_fwd_timeout (void *cls,
1306                         const struct GNUNET_SCHEDULER_TaskContext *tc)
1307 {
1308   struct CadetConnection *c = cls;
1309
1310   c->fwd_maintenance_task = GNUNET_SCHEDULER_NO_TASK;
1311   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
1312     return;
1313
1314   LOG (GNUNET_ERROR_TYPE_DEBUG, "Connection %s FWD timed out. Destroying.\n",
1315        GCC_2s (c));
1316   GCC_debug (c, GNUNET_ERROR_TYPE_DEBUG);
1317
1318   if (GCC_is_origin (c, GNUNET_YES)) /* If local, leave. */
1319   {
1320     GNUNET_break (0);
1321     return;
1322   }
1323
1324   /* If dest, salvage queued traffic. */
1325   if (GCC_is_origin (c, GNUNET_NO) && 0 < c->bck_fc.queue_n)
1326   {
1327     resend_messages_and_destroy (c, GNUNET_NO);
1328     return;
1329   }
1330
1331   GCC_destroy (c);
1332 }
1333
1334
1335 /**
1336  * Timeout function due to lack of keepalive/traffic from the destination.
1337  * Destroys connection if called.
1338  *
1339  * FIXME refactor and merge with connection_fwd_timeout.
1340  *
1341  * @param cls Closure (connection to destroy).
1342  * @param tc TaskContext
1343  */
1344 static void
1345 connection_bck_timeout (void *cls,
1346                         const struct GNUNET_SCHEDULER_TaskContext *tc)
1347 {
1348   struct CadetConnection *c = cls;
1349
1350   c->bck_maintenance_task = GNUNET_SCHEDULER_NO_TASK;
1351   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
1352     return;
1353
1354   LOG (GNUNET_ERROR_TYPE_DEBUG, "Connection %s BCK timed out. Destroying.\n",
1355        GCC_2s (c));
1356
1357   if (GCC_is_origin (c, GNUNET_NO)) /* If local, leave. */
1358   {
1359     GNUNET_break (0);
1360     return;
1361   }
1362
1363   /* If dest, salvage queued traffic. */
1364   if (GCC_is_origin (c, GNUNET_YES) && 0 < c->fwd_fc.queue_n)
1365   {
1366     resend_messages_and_destroy (c, GNUNET_YES);
1367     return;
1368   }
1369
1370   GCC_destroy (c);
1371 }
1372
1373
1374 /**
1375  * Resets the connection timeout task, some other message has done the
1376  * task's job.
1377  * - For the first peer on the direction this means to send
1378  *   a keepalive or a path confirmation message (either create or ACK).
1379  * - For all other peers, this means to destroy the connection,
1380  *   due to lack of activity.
1381  * Starts the timeout if no timeout was running (connection just created).
1382  *
1383  * @param c Connection whose timeout to reset.
1384  * @param fwd Is this forward?
1385  *
1386  * TODO use heap to improve efficiency of scheduler.
1387  */
1388 static void
1389 connection_reset_timeout (struct CadetConnection *c, int fwd)
1390 {
1391   LOG (GNUNET_ERROR_TYPE_DEBUG, "Connection %s reset timeout\n", GC_f2s (fwd));
1392
1393   if (GCC_is_origin (c, fwd)) /* Startpoint */
1394   {
1395     schedule_next_keepalive (c, fwd);
1396   }
1397   else /* Relay, endpoint. */
1398   {
1399     struct GNUNET_TIME_Relative delay;
1400     GNUNET_SCHEDULER_TaskIdentifier *ti;
1401     GNUNET_SCHEDULER_Task f;
1402
1403     ti = fwd ? &c->fwd_maintenance_task : &c->bck_maintenance_task;
1404
1405     if (GNUNET_SCHEDULER_NO_TASK != *ti)
1406       GNUNET_SCHEDULER_cancel (*ti);
1407     delay = GNUNET_TIME_relative_multiply (refresh_connection_time, 4);
1408     f = fwd ? &connection_fwd_timeout : &connection_bck_timeout;
1409     *ti = GNUNET_SCHEDULER_add_delayed (delay, f, c);
1410   }
1411 }
1412
1413
1414 /**
1415  * Add the connection to the list of both neighbors.
1416  *
1417  * @param c Connection.
1418  *
1419  * @return #GNUNET_OK if everything went fine
1420  *         #GNUNET_SYSERR if the was an error and @c c is malformed.
1421  */
1422 static int
1423 register_neighbors (struct CadetConnection *c)
1424 {
1425   struct CadetPeer *next_peer;
1426   struct CadetPeer *prev_peer;
1427
1428   next_peer = get_next_hop (c);
1429   prev_peer = get_prev_hop (c);
1430
1431   LOG (GNUNET_ERROR_TYPE_DEBUG, "register neighbors for connection %s\n",
1432        GCC_2s (c));
1433   path_debug (c->path);
1434   LOG (GNUNET_ERROR_TYPE_DEBUG, "own pos %u\n", c->own_pos);
1435   LOG (GNUNET_ERROR_TYPE_DEBUG, "putting connection %s to next peer %p\n",
1436        GCC_2s (c), next_peer);
1437   LOG (GNUNET_ERROR_TYPE_DEBUG, "next peer %p %s\n", next_peer, GCP_2s (next_peer));
1438   LOG (GNUNET_ERROR_TYPE_DEBUG, "putting connection %s to prev peer %p\n",
1439        GCC_2s (c), prev_peer);
1440   LOG (GNUNET_ERROR_TYPE_DEBUG, "prev peer %p %s\n", prev_peer, GCP_2s (prev_peer));
1441
1442   if (GNUNET_NO == GCP_is_neighbor (next_peer)
1443       || GNUNET_NO == GCP_is_neighbor (prev_peer))
1444   {
1445     if (GCC_is_origin (c, GNUNET_YES))
1446       GNUNET_STATISTICS_update (stats, "# local bad paths", 1, GNUNET_NO);
1447     GNUNET_STATISTICS_update (stats, "# bad paths", 1, GNUNET_NO);
1448
1449     LOG (GNUNET_ERROR_TYPE_DEBUG, "  register neighbors failed\n");
1450     LOG (GNUNET_ERROR_TYPE_DEBUG, "  prev: %s, neighbor?: %d\n",
1451          GCP_2s (prev_peer), GCP_is_neighbor (prev_peer));
1452     LOG (GNUNET_ERROR_TYPE_DEBUG, "  next: %s, neighbor?: %d\n",
1453          GCP_2s (next_peer), GCP_is_neighbor (next_peer));
1454     return GNUNET_SYSERR;
1455   }
1456
1457   GCP_add_connection (next_peer, c);
1458   GCP_add_connection (prev_peer, c);
1459
1460   return GNUNET_OK;
1461 }
1462
1463
1464 /**
1465  * Remove the connection from the list of both neighbors.
1466  *
1467  * @param c Connection.
1468  */
1469 static void
1470 unregister_neighbors (struct CadetConnection *c)
1471 {
1472   struct CadetPeer *peer;
1473
1474   peer = get_next_hop (c);
1475   if (GNUNET_OK != GCP_remove_connection (peer, c))
1476   {
1477     GNUNET_assert (CADET_CONNECTION_NEW == c->state
1478                    || CADET_CONNECTION_DESTROYED <= c->state);
1479     LOG (GNUNET_ERROR_TYPE_DEBUG, "  cstate: %u\n", c->state);
1480     if (NULL != c->t) GCT_debug (c->t, GNUNET_ERROR_TYPE_DEBUG);
1481   }
1482
1483   peer = get_prev_hop (c);
1484   if (GNUNET_OK != GCP_remove_connection (peer, c))
1485   {
1486     GNUNET_assert (CADET_CONNECTION_NEW == c->state
1487                    || CADET_CONNECTION_DESTROYED <= c->state);
1488     LOG (GNUNET_ERROR_TYPE_DEBUG, "  cstate: %u\n", c->state);
1489     if (NULL != c->t) GCT_debug (c->t, GNUNET_ERROR_TYPE_DEBUG);
1490   }
1491 }
1492
1493
1494 /**
1495  * Bind the connection to the peer and the tunnel to that peer.
1496  *
1497  * If the peer has no tunnel, create one. Update tunnel and connection
1498  * data structres to reflect new status.
1499  *
1500  * @param c Connection.
1501  * @param peer Peer.
1502  */
1503 static void
1504 add_to_peer (struct CadetConnection *c, struct CadetPeer *peer)
1505 {
1506   GCP_add_tunnel (peer);
1507   c->t = GCP_get_tunnel (peer);
1508   GCT_add_connection (c->t, c);
1509 }
1510
1511
1512 /**
1513  * Log receipt of message on stderr (INFO level).
1514  *
1515  * @param message Message received.
1516  * @param peer Peer who sent the message.
1517  * @param hash Connection ID.
1518  */
1519 static void
1520 log_message (const struct GNUNET_MessageHeader *message,
1521              const struct GNUNET_PeerIdentity *peer,
1522              const struct GNUNET_CADET_Hash *hash)
1523 {
1524   LOG (GNUNET_ERROR_TYPE_INFO, "\n");
1525   LOG (GNUNET_ERROR_TYPE_INFO, "\n");
1526   LOG (GNUNET_ERROR_TYPE_INFO, "<-- %s on connection %s from %s\n",
1527        GC_m2s (ntohs (message->type)), GNUNET_h2s (GC_h2hc (hash)),
1528        GNUNET_i2s (peer));
1529 }
1530
1531 /******************************************************************************/
1532 /********************************    API    ***********************************/
1533 /******************************************************************************/
1534
1535 /**
1536  * Core handler for connection creation.
1537  *
1538  * @param cls Closure (unused).
1539  * @param peer Sender (neighbor).
1540  * @param message Message.
1541  *
1542  * @return GNUNET_OK to keep the connection open,
1543  *         GNUNET_SYSERR to close it (signal serious error)
1544  */
1545 int
1546 GCC_handle_create (void *cls, const struct GNUNET_PeerIdentity *peer,
1547                    const struct GNUNET_MessageHeader *message)
1548 {
1549   struct GNUNET_CADET_ConnectionCreate *msg;
1550   struct GNUNET_PeerIdentity *id;
1551   struct GNUNET_CADET_Hash *cid;
1552   struct CadetPeerPath *path;
1553   struct CadetPeer *dest_peer;
1554   struct CadetPeer *orig_peer;
1555   struct CadetConnection *c;
1556   unsigned int own_pos;
1557   uint16_t size;
1558
1559   /* Check size */
1560   size = ntohs (message->size);
1561   if (size < sizeof (struct GNUNET_CADET_ConnectionCreate))
1562   {
1563     GNUNET_break_op (0);
1564     return GNUNET_OK;
1565   }
1566
1567   /* Calculate hops */
1568   size -= sizeof (struct GNUNET_CADET_ConnectionCreate);
1569   if (size % sizeof (struct GNUNET_PeerIdentity))
1570   {
1571     GNUNET_break_op (0);
1572     return GNUNET_OK;
1573   }
1574   size /= sizeof (struct GNUNET_PeerIdentity);
1575   if (1 > size)
1576   {
1577     GNUNET_break_op (0);
1578     return GNUNET_OK;
1579   }
1580   LOG (GNUNET_ERROR_TYPE_DEBUG, "    path has %u hops.\n", size);
1581
1582   /* Get parameters */
1583   msg = (struct GNUNET_CADET_ConnectionCreate *) message;
1584   cid = &msg->cid;
1585   log_message (message, peer, cid);
1586   id = (struct GNUNET_PeerIdentity *) &msg[1];
1587   LOG (GNUNET_ERROR_TYPE_DEBUG, "    origin: %s\n", GNUNET_i2s (id));
1588
1589   /* Create connection */
1590   c = connection_get (cid);
1591   if (NULL == c)
1592   {
1593     path = path_build_from_peer_ids ((struct GNUNET_PeerIdentity *) &msg[1],
1594                                      size, myid, &own_pos);
1595     if (NULL == path)
1596       return GNUNET_OK;
1597
1598     if (0 == own_pos)
1599     {
1600       GNUNET_break_op (0);
1601       path_destroy (path);
1602       return GNUNET_OK;
1603     }
1604     LOG (GNUNET_ERROR_TYPE_DEBUG, "  Own position: %u\n", own_pos);
1605     LOG (GNUNET_ERROR_TYPE_DEBUG, "  Creating connection\n");
1606     c = GCC_new (cid, NULL, path_duplicate (path), own_pos);
1607     if (NULL == c)
1608     {
1609       if (path->length - 1 == own_pos)
1610       {
1611         /* If we are destination, why did the creation fail? */
1612         GNUNET_break (0);
1613         path_destroy (path);
1614         return GNUNET_OK;
1615       }
1616       send_broken_unknown (cid, &my_full_id,
1617                            GNUNET_PEER_resolve2 (path->peers[own_pos + 1]),
1618                            peer);
1619       path_destroy (path);
1620       return GNUNET_OK;
1621     }
1622     GCP_add_path_to_all (path, GNUNET_NO);
1623     connection_reset_timeout (c, GNUNET_YES);
1624   }
1625   else
1626   {
1627     path = path_duplicate (c->path);
1628   }
1629   if (CADET_CONNECTION_NEW == c->state)
1630     connection_change_state (c, CADET_CONNECTION_SENT);
1631
1632   /* Remember peers */
1633   dest_peer = GCP_get (&id[size - 1]);
1634   orig_peer = GCP_get (&id[0]);
1635
1636   /* Is it a connection to us? */
1637   if (c->own_pos == path->length - 1)
1638   {
1639     LOG (GNUNET_ERROR_TYPE_DEBUG, "  It's for us!\n");
1640     GCP_add_path_to_origin (orig_peer, path_duplicate (path), GNUNET_YES);
1641
1642     add_to_peer (c, orig_peer);
1643     if (CADET_TUNNEL_NEW == GCT_get_cstate (c->t))
1644       GCT_change_cstate (c->t,  CADET_TUNNEL_WAITING);
1645
1646     send_connection_ack (c, GNUNET_NO);
1647     if (CADET_CONNECTION_SENT == c->state)
1648       connection_change_state (c, CADET_CONNECTION_ACK);
1649   }
1650   else
1651   {
1652     /* It's for somebody else! Retransmit. */
1653     LOG (GNUNET_ERROR_TYPE_DEBUG, "  Retransmitting.\n");
1654     GCP_add_path (dest_peer, path_duplicate (path), GNUNET_NO);
1655     GCP_add_path_to_origin (orig_peer, path_duplicate (path), GNUNET_NO);
1656     GNUNET_assert (NULL == GCC_send_prebuilt_message (message, 0, 0, c,
1657                                                       GNUNET_YES, GNUNET_YES,
1658                                                       NULL, NULL));
1659   }
1660   path_destroy (path);
1661   return GNUNET_OK;
1662 }
1663
1664
1665 /**
1666  * Core handler for path confirmations.
1667  *
1668  * @param cls closure
1669  * @param message message
1670  * @param peer peer identity this notification is about
1671  *
1672  * @return GNUNET_OK to keep the connection open,
1673  *         GNUNET_SYSERR to close it (signal serious error)
1674  */
1675 int
1676 GCC_handle_confirm (void *cls, const struct GNUNET_PeerIdentity *peer,
1677                     const struct GNUNET_MessageHeader *message)
1678 {
1679   struct GNUNET_CADET_ConnectionACK *msg;
1680   struct CadetConnection *c;
1681   struct CadetPeerPath *p;
1682   struct CadetPeer *pi;
1683   enum CadetConnectionState oldstate;
1684   int fwd;
1685
1686   msg = (struct GNUNET_CADET_ConnectionACK *) message;
1687   log_message (message, peer, &msg->cid);
1688   c = connection_get (&msg->cid);
1689   if (NULL == c)
1690   {
1691     GNUNET_STATISTICS_update (stats, "# control on unknown connection",
1692                               1, GNUNET_NO);
1693     LOG (GNUNET_ERROR_TYPE_DEBUG, "  don't know the connection!\n");
1694     send_broken_unknown (&msg->cid, &my_full_id, NULL, peer);
1695     return GNUNET_OK;
1696   }
1697
1698   if (GNUNET_NO != c->destroy)
1699   {
1700     LOG (GNUNET_ERROR_TYPE_DEBUG, "  connection being destroyed\n");
1701     return GNUNET_OK;
1702   }
1703
1704   oldstate = c->state;
1705   LOG (GNUNET_ERROR_TYPE_DEBUG, "  via peer %s\n", GNUNET_i2s (peer));
1706   pi = GCP_get (peer);
1707   if (get_next_hop (c) == pi)
1708   {
1709     LOG (GNUNET_ERROR_TYPE_DEBUG, "  SYNACK\n");
1710     fwd = GNUNET_NO;
1711     if (CADET_CONNECTION_SENT == oldstate)
1712       connection_change_state (c, CADET_CONNECTION_ACK);
1713   }
1714   else if (get_prev_hop (c) == pi)
1715   {
1716     LOG (GNUNET_ERROR_TYPE_DEBUG, "  FINAL ACK\n");
1717     fwd = GNUNET_YES;
1718     connection_change_state (c, CADET_CONNECTION_READY);
1719   }
1720   else
1721   {
1722     GNUNET_break_op (0);
1723     return GNUNET_OK;
1724   }
1725
1726   connection_reset_timeout (c, fwd);
1727
1728   /* Add path to peers? */
1729   p = c->path;
1730   if (NULL != p)
1731   {
1732     GCP_add_path_to_all (p, GNUNET_YES);
1733   }
1734   else
1735   {
1736     GNUNET_break (0);
1737   }
1738
1739   /* Message for us as creator? */
1740   if (GCC_is_origin (c, GNUNET_YES))
1741   {
1742     if (GNUNET_NO != fwd)
1743     {
1744       GNUNET_break_op (0);
1745       return GNUNET_OK;
1746     }
1747     LOG (GNUNET_ERROR_TYPE_DEBUG, "  Connection (SYN)ACK for us!\n");
1748
1749     /* If just created, cancel the short timeout and start a long one */
1750     if (CADET_CONNECTION_SENT == oldstate)
1751       connection_reset_timeout (c, GNUNET_YES);
1752
1753     /* Change connection state */
1754     connection_change_state (c, CADET_CONNECTION_READY);
1755     send_connection_ack (c, GNUNET_YES);
1756
1757     /* Change tunnel state, trigger KX */
1758     if (CADET_TUNNEL_WAITING == GCT_get_cstate (c->t))
1759       GCT_change_cstate (c->t, CADET_TUNNEL_READY);
1760
1761     return GNUNET_OK;
1762   }
1763
1764   /* Message for us as destination? */
1765   if (GCC_is_terminal (c, GNUNET_YES))
1766   {
1767     if (GNUNET_YES != fwd)
1768     {
1769       GNUNET_break_op (0);
1770       return GNUNET_OK;
1771     }
1772     LOG (GNUNET_ERROR_TYPE_DEBUG, "  Connection ACK for us!\n");
1773
1774     /* If just created, cancel the short timeout and start a long one */
1775     if (CADET_CONNECTION_ACK == oldstate)
1776       connection_reset_timeout (c, GNUNET_NO);
1777
1778     /* Change tunnel state */
1779     if (CADET_TUNNEL_WAITING == GCT_get_cstate (c->t))
1780       GCT_change_cstate (c->t, CADET_TUNNEL_READY);
1781
1782     return GNUNET_OK;
1783   }
1784
1785   LOG (GNUNET_ERROR_TYPE_DEBUG, "  not for us, retransmitting...\n");
1786   GNUNET_assert (NULL == GCC_send_prebuilt_message (message, 0, 0, c, fwd,
1787                                                     GNUNET_YES, NULL, NULL));
1788   return GNUNET_OK;
1789 }
1790
1791
1792 /**
1793  * Core handler for notifications of broken connections.
1794  *
1795  * @param cls Closure (unused).
1796  * @param id Peer identity of sending neighbor.
1797  * @param message Message.
1798  *
1799  * @return GNUNET_OK to keep the connection open,
1800  *         GNUNET_SYSERR to close it (signal serious error)
1801  */
1802 int
1803 GCC_handle_broken (void* cls,
1804                    const struct GNUNET_PeerIdentity* id,
1805                    const struct GNUNET_MessageHeader* message)
1806 {
1807   struct GNUNET_CADET_ConnectionBroken *msg;
1808   struct CadetConnection *c;
1809   struct CadetTunnel *t;
1810   int pending;
1811   int fwd;
1812
1813   msg = (struct GNUNET_CADET_ConnectionBroken *) message;
1814   log_message (message, id, &msg->cid);
1815   LOG (GNUNET_ERROR_TYPE_DEBUG, "  regarding %s\n",
1816               GNUNET_i2s (&msg->peer1));
1817   LOG (GNUNET_ERROR_TYPE_DEBUG, "  regarding %s\n",
1818               GNUNET_i2s (&msg->peer2));
1819   c = connection_get (&msg->cid);
1820   if (NULL == c)
1821   {
1822     LOG (GNUNET_ERROR_TYPE_DEBUG, "  duplicate CONNECTION_BROKEN\n");
1823     return GNUNET_OK;
1824   }
1825
1826   t = c->t;
1827   fwd = is_fwd (c, id);
1828   c->destroy = GNUNET_YES;
1829   if (GCC_is_terminal (c, fwd))
1830   {
1831     struct CadetPeer *endpoint;
1832
1833     if (NULL == t)
1834     {
1835       /* A terminal connection should not have 't' set to NULL. */
1836       GNUNET_break (0);
1837       GCC_debug (c, GNUNET_ERROR_TYPE_ERROR);
1838       return GNUNET_OK;
1839     }
1840     endpoint = GCP_get_short (c->path->peers[c->path->length - 1]);
1841     path_invalidate (c->path);
1842     GCP_notify_broken_link (endpoint, &msg->peer1, &msg->peer2);
1843
1844     c->state = CADET_CONNECTION_BROKEN;
1845     GCT_remove_connection (t, c);
1846     c->t = NULL;
1847
1848     pending = c->pending_messages;
1849     if (0 < pending)
1850       resend_messages_and_destroy (c, !fwd);
1851     else
1852       GCC_destroy (c);
1853   }
1854   else
1855   {
1856     GNUNET_assert (NULL == GCC_send_prebuilt_message (message, 0, 0, c, fwd,
1857                                                       GNUNET_YES, NULL, NULL));
1858     connection_cancel_queues (c, !fwd);
1859   }
1860
1861   return GNUNET_OK;
1862 }
1863
1864
1865 /**
1866  * Core handler for tunnel destruction
1867  *
1868  * @param cls Closure (unused).
1869  * @param peer Peer identity of sending neighbor.
1870  * @param message Message.
1871  *
1872  * @return GNUNET_OK to keep the connection open,
1873  *         GNUNET_SYSERR to close it (signal serious error)
1874  */
1875 int
1876 GCC_handle_destroy (void *cls, const struct GNUNET_PeerIdentity *peer,
1877                     const struct GNUNET_MessageHeader *message)
1878 {
1879   struct GNUNET_CADET_ConnectionDestroy *msg;
1880   struct CadetConnection *c;
1881   int fwd;
1882
1883   msg = (struct GNUNET_CADET_ConnectionDestroy *) message;
1884   log_message (message, peer, &msg->cid);
1885   c = connection_get (&msg->cid);
1886   if (NULL == c)
1887   {
1888     /* Probably already got the message from another path,
1889      * destroyed the tunnel and retransmitted to children.
1890      * Safe to ignore.
1891      */
1892     GNUNET_STATISTICS_update (stats, "# control on unknown connection",
1893                               1, GNUNET_NO);
1894     LOG (GNUNET_ERROR_TYPE_DEBUG, "  connection unknown: already destroyed?\n");
1895     return GNUNET_OK;
1896   }
1897   fwd = is_fwd (c, peer);
1898   if (GNUNET_SYSERR == fwd)
1899   {
1900     GNUNET_break_op (0); /* FIXME */
1901     return GNUNET_OK;
1902   }
1903   if (GNUNET_NO == GCC_is_terminal (c, fwd))
1904     GNUNET_assert (NULL == GCC_send_prebuilt_message (message, 0, 0, c, fwd,
1905                                                       GNUNET_YES, NULL, NULL));
1906   else if (0 == c->pending_messages)
1907   {
1908     LOG (GNUNET_ERROR_TYPE_DEBUG, "  directly destroying connection!\n");
1909     GCC_destroy (c);
1910     return GNUNET_OK;
1911   }
1912   c->destroy = GNUNET_YES;
1913   c->state = CADET_CONNECTION_DESTROYED;
1914   if (NULL != c->t)
1915   {
1916     GCT_remove_connection (c->t, c);
1917     c->t = NULL;
1918   }
1919
1920   return GNUNET_OK;
1921 }
1922
1923 /**
1924  * Generic handler for cadet network encrypted traffic.
1925  *
1926  * @param peer Peer identity this notification is about.
1927  * @param msg Encrypted message.
1928  *
1929  * @return GNUNET_OK to keep the connection open,
1930  *         GNUNET_SYSERR to close it (signal serious error)
1931  */
1932 static int
1933 handle_cadet_encrypted (const struct GNUNET_PeerIdentity *peer,
1934                        const struct GNUNET_CADET_Encrypted *msg)
1935 {
1936   struct CadetConnection *c;
1937   struct CadetPeer *neighbor;
1938   struct CadetFlowControl *fc;
1939   GNUNET_PEER_Id peer_id;
1940   uint32_t pid;
1941   uint32_t ttl;
1942   size_t size;
1943   int fwd;
1944
1945   log_message (&msg->header, peer, &msg->cid);
1946
1947   /* Check size */
1948   size = ntohs (msg->header.size);
1949   if (size <
1950       sizeof (struct GNUNET_CADET_Encrypted) +
1951       sizeof (struct GNUNET_MessageHeader))
1952   {
1953     GNUNET_break_op (0);
1954     return GNUNET_OK;
1955   }
1956
1957   /* Check connection */
1958   c = connection_get (&msg->cid);
1959   if (NULL == c)
1960   {
1961     GNUNET_STATISTICS_update (stats, "# unknown connection", 1, GNUNET_NO);
1962     LOG (GNUNET_ERROR_TYPE_DEBUG, "enc on unknown connection %s\n",
1963          GNUNET_h2s (GC_h2hc (&msg->cid)));
1964     send_broken_unknown (&msg->cid, &my_full_id, NULL, peer);
1965     return GNUNET_OK;
1966   }
1967
1968   LOG (GNUNET_ERROR_TYPE_DEBUG, "  connection %s\n", GCC_2s (c));
1969
1970   /* Check if origin is as expected */
1971   neighbor = get_prev_hop (c);
1972   peer_id = GNUNET_PEER_search (peer);
1973   if (peer_id == GCP_get_short_id (neighbor))
1974   {
1975     fwd = GNUNET_YES;
1976   }
1977   else
1978   {
1979     neighbor = get_next_hop (c);
1980     if (peer_id == GCP_get_short_id (neighbor))
1981     {
1982       fwd = GNUNET_NO;
1983     }
1984     else
1985     {
1986       /* Unexpected peer sending traffic on a connection. */
1987       GNUNET_break_op (0);
1988       return GNUNET_OK;
1989     }
1990   }
1991
1992   /* Check PID */
1993   fc = fwd ? &c->bck_fc : &c->fwd_fc;
1994   pid = ntohl (msg->pid);
1995   LOG (GNUNET_ERROR_TYPE_DEBUG, " PID %u (expected %u+)\n",
1996        pid, fc->last_pid_recv + 1);
1997   if (GC_is_pid_bigger (pid, fc->last_ack_sent))
1998   {
1999     GNUNET_STATISTICS_update (stats, "# unsolicited message", 1, GNUNET_NO);
2000     GNUNET_break_op (0);
2001     LOG (GNUNET_ERROR_TYPE_WARNING,
2002          "Received PID %u, (prev %u), ACK %u\n",
2003          pid, fc->last_pid_recv, fc->last_ack_sent);
2004     return GNUNET_OK;
2005   }
2006   if (GNUNET_NO == GC_is_pid_bigger (pid, fc->last_pid_recv))
2007   {
2008     GNUNET_STATISTICS_update (stats, "# duplicate PID", 1, GNUNET_NO);
2009     LOG (GNUNET_ERROR_TYPE_DEBUG,
2010                 " PID %u not expected (%u+), dropping!\n",
2011                 pid, fc->last_pid_recv + 1);
2012     return GNUNET_OK;
2013   }
2014   if (CADET_CONNECTION_SENT == c->state || CADET_CONNECTION_ACK == c->state)
2015     connection_change_state (c, CADET_CONNECTION_READY);
2016   connection_reset_timeout (c, fwd);
2017   fc->last_pid_recv = pid;
2018
2019   /* Is this message for us? */
2020   if (GCC_is_terminal (c, fwd))
2021   {
2022     LOG (GNUNET_ERROR_TYPE_DEBUG, "  message for us!\n");
2023     GNUNET_STATISTICS_update (stats, "# messages received", 1, GNUNET_NO);
2024
2025     if (NULL == c->t)
2026     {
2027       GNUNET_break (GNUNET_NO != c->destroy);
2028       return GNUNET_OK;
2029     }
2030     fc->last_pid_recv = pid;
2031     GCT_handle_encrypted (c->t, msg);
2032     GCC_send_ack (c, fwd, GNUNET_NO);
2033     return GNUNET_OK;
2034   }
2035
2036   /* Message not for us: forward to next hop */
2037   LOG (GNUNET_ERROR_TYPE_DEBUG, "  not for us, retransmitting...\n");
2038   ttl = ntohl (msg->ttl);
2039   LOG (GNUNET_ERROR_TYPE_DEBUG, "   ttl: %u\n", ttl);
2040   if (ttl == 0)
2041   {
2042     GNUNET_STATISTICS_update (stats, "# TTL drops", 1, GNUNET_NO);
2043     LOG (GNUNET_ERROR_TYPE_WARNING, " TTL is 0, DROPPING!\n");
2044     GCC_send_ack (c, fwd, GNUNET_NO);
2045     return GNUNET_OK;
2046   }
2047
2048   GNUNET_STATISTICS_update (stats, "# messages forwarded", 1, GNUNET_NO);
2049   GNUNET_assert (NULL == GCC_send_prebuilt_message (&msg->header, 0, 0, c, fwd,
2050                                                     GNUNET_NO, NULL, NULL));
2051
2052   return GNUNET_OK;
2053 }
2054
2055 /**
2056  * Generic handler for cadet network encrypted traffic.
2057  *
2058  * @param peer Peer identity this notification is about.
2059  * @param msg Encrypted message.
2060  *
2061  * @return GNUNET_OK to keep the connection open,
2062  *         GNUNET_SYSERR to close it (signal serious error)
2063  */
2064 static int
2065 handle_cadet_kx (const struct GNUNET_PeerIdentity *peer,
2066                 const struct GNUNET_CADET_KX *msg)
2067 {
2068   struct CadetConnection *c;
2069   struct CadetPeer *neighbor;
2070   GNUNET_PEER_Id peer_id;
2071   size_t size;
2072   int fwd;
2073
2074   log_message (&msg->header, peer, &msg->cid);
2075
2076   /* Check size */
2077   size = ntohs (msg->header.size);
2078   if (size <
2079       sizeof (struct GNUNET_CADET_KX) +
2080       sizeof (struct GNUNET_MessageHeader))
2081   {
2082     GNUNET_break_op (0);
2083     return GNUNET_OK;
2084   }
2085
2086   /* Check connection */
2087   c = connection_get (&msg->cid);
2088   if (NULL == c)
2089   {
2090     GNUNET_STATISTICS_update (stats, "# unknown connection", 1, GNUNET_NO);
2091     LOG (GNUNET_ERROR_TYPE_DEBUG, "kx on unknown connection %s\n",
2092          GNUNET_h2s (GC_h2hc (&msg->cid)));
2093     send_broken_unknown (&msg->cid, &my_full_id, NULL, peer);
2094     return GNUNET_OK;
2095   }
2096   LOG (GNUNET_ERROR_TYPE_DEBUG, " on connection %s\n", GCC_2s (c));
2097
2098   /* Check if origin is as expected */
2099   neighbor = get_prev_hop (c);
2100   peer_id = GNUNET_PEER_search (peer);
2101   if (peer_id == GCP_get_short_id (neighbor))
2102   {
2103     fwd = GNUNET_YES;
2104   }
2105   else
2106   {
2107     neighbor = get_next_hop (c);
2108     if (peer_id == GCP_get_short_id (neighbor))
2109     {
2110       fwd = GNUNET_NO;
2111     }
2112     else
2113     {
2114       /* Unexpected peer sending traffic on a connection. */
2115       GNUNET_break_op (0);
2116       return GNUNET_OK;
2117     }
2118   }
2119
2120   /* Count as connection confirmation. */
2121   if (CADET_CONNECTION_SENT == c->state || CADET_CONNECTION_ACK == c->state)
2122   {
2123     connection_change_state (c, CADET_CONNECTION_READY);
2124     if (NULL != c->t)
2125     {
2126       if (CADET_TUNNEL_WAITING == GCT_get_cstate (c->t))
2127         GCT_change_cstate (c->t, CADET_TUNNEL_READY);
2128     }
2129   }
2130   connection_reset_timeout (c, fwd);
2131
2132   /* Is this message for us? */
2133   if (GCC_is_terminal (c, fwd))
2134   {
2135     LOG (GNUNET_ERROR_TYPE_DEBUG, "  message for us!\n");
2136     GNUNET_STATISTICS_update (stats, "# messages received", 1, GNUNET_NO);
2137     if (NULL == c->t)
2138     {
2139       GNUNET_break (0);
2140       return GNUNET_OK;
2141     }
2142     GCT_handle_kx (c->t, &msg[1].header);
2143     return GNUNET_OK;
2144   }
2145
2146   /* Message not for us: forward to next hop */
2147   LOG (GNUNET_ERROR_TYPE_DEBUG, "  not for us, retransmitting...\n");
2148   GNUNET_STATISTICS_update (stats, "# messages forwarded", 1, GNUNET_NO);
2149   GNUNET_assert (NULL == GCC_send_prebuilt_message (&msg->header, 0, 0, c, fwd,
2150                                                     GNUNET_NO, NULL, NULL));
2151
2152   return GNUNET_OK;
2153 }
2154
2155
2156 /**
2157  * Core handler for encrypted cadet network traffic (channel mgmt, data).
2158  *
2159  * @param cls Closure (unused).
2160  * @param message Message received.
2161  * @param peer Peer who sent the message.
2162  *
2163  * @return GNUNET_OK to keep the connection open,
2164  *         GNUNET_SYSERR to close it (signal serious error)
2165  */
2166 int
2167 GCC_handle_encrypted (void *cls, const struct GNUNET_PeerIdentity *peer,
2168                       const struct GNUNET_MessageHeader *message)
2169 {
2170   return handle_cadet_encrypted (peer,
2171                                 (struct GNUNET_CADET_Encrypted *)message);
2172 }
2173
2174
2175 /**
2176  * Core handler for key exchange traffic (ephemeral key, ping, pong).
2177  *
2178  * @param cls Closure (unused).
2179  * @param message Message received.
2180  * @param peer Peer who sent the message.
2181  *
2182  * @return GNUNET_OK to keep the connection open,
2183  *         GNUNET_SYSERR to close it (signal serious error)
2184  */
2185 int
2186 GCC_handle_kx (void *cls, const struct GNUNET_PeerIdentity *peer,
2187                const struct GNUNET_MessageHeader *message)
2188 {
2189   return handle_cadet_kx (peer,
2190                          (struct GNUNET_CADET_KX *) message);
2191 }
2192
2193
2194 /**
2195  * Core handler for cadet network traffic point-to-point acks.
2196  *
2197  * @param cls closure
2198  * @param message message
2199  * @param peer peer identity this notification is about
2200  *
2201  * @return GNUNET_OK to keep the connection open,
2202  *         GNUNET_SYSERR to close it (signal serious error)
2203  */
2204 int
2205 GCC_handle_ack (void *cls, const struct GNUNET_PeerIdentity *peer,
2206                 const struct GNUNET_MessageHeader *message)
2207 {
2208   struct GNUNET_CADET_ACK *msg;
2209   struct CadetConnection *c;
2210   struct CadetFlowControl *fc;
2211   GNUNET_PEER_Id id;
2212   uint32_t ack;
2213   int fwd;
2214
2215   msg = (struct GNUNET_CADET_ACK *) message;
2216   log_message (message, peer, &msg->cid);
2217   c = connection_get (&msg->cid);
2218   if (NULL == c)
2219   {
2220     GNUNET_STATISTICS_update (stats, "# ack on unknown connection", 1,
2221                               GNUNET_NO);
2222     send_broken_unknown (&msg->cid, &my_full_id, NULL, peer);
2223     return GNUNET_OK;
2224   }
2225
2226   /* Is this a forward or backward ACK? */
2227   id = GNUNET_PEER_search (peer);
2228   if (GCP_get_short_id (get_next_hop (c)) == id)
2229   {
2230     LOG (GNUNET_ERROR_TYPE_DEBUG, "  FWD ACK\n");
2231     fc = &c->fwd_fc;
2232     fwd = GNUNET_YES;
2233   }
2234   else if (GCP_get_short_id (get_prev_hop (c)) == id)
2235   {
2236     LOG (GNUNET_ERROR_TYPE_DEBUG, "  BCK ACK\n");
2237     fc = &c->bck_fc;
2238     fwd = GNUNET_NO;
2239   }
2240   else
2241   {
2242     GNUNET_break_op (0);
2243     return GNUNET_OK;
2244   }
2245
2246   ack = ntohl (msg->ack);
2247   LOG (GNUNET_ERROR_TYPE_DEBUG, "  ACK %u (was %u)\n",
2248               ack, fc->last_ack_recv);
2249   if (GC_is_pid_bigger (ack, fc->last_ack_recv))
2250     fc->last_ack_recv = ack;
2251
2252   /* Cancel polling if the ACK is big enough. */
2253   if (GNUNET_SCHEDULER_NO_TASK != fc->poll_task &&
2254       GC_is_pid_bigger (fc->last_ack_recv, fc->last_pid_sent))
2255   {
2256     LOG (GNUNET_ERROR_TYPE_DEBUG, "  Cancel poll\n");
2257     GNUNET_SCHEDULER_cancel (fc->poll_task);
2258     fc->poll_task = GNUNET_SCHEDULER_NO_TASK;
2259     fc->poll_time = GNUNET_TIME_UNIT_SECONDS;
2260   }
2261
2262   connection_unlock_queue (c, fwd);
2263
2264   return GNUNET_OK;
2265 }
2266
2267
2268 /**
2269  * Core handler for cadet network traffic point-to-point ack polls.
2270  *
2271  * @param cls closure
2272  * @param message message
2273  * @param peer peer identity this notification is about
2274  *
2275  * @return GNUNET_OK to keep the connection open,
2276  *         GNUNET_SYSERR to close it (signal serious error)
2277  */
2278 int
2279 GCC_handle_poll (void *cls, const struct GNUNET_PeerIdentity *peer,
2280                  const struct GNUNET_MessageHeader *message)
2281 {
2282   struct GNUNET_CADET_Poll *msg;
2283   struct CadetConnection *c;
2284   struct CadetFlowControl *fc;
2285   GNUNET_PEER_Id id;
2286   uint32_t pid;
2287   int fwd;
2288
2289   msg = (struct GNUNET_CADET_Poll *) message;
2290   log_message (message, peer, &msg->cid);
2291   c = connection_get (&msg->cid);
2292   if (NULL == c)
2293   {
2294     GNUNET_STATISTICS_update (stats, "# poll on unknown connection", 1,
2295                               GNUNET_NO);
2296     LOG (GNUNET_ERROR_TYPE_DEBUG, "POLL message on unknown connection %s!\n",
2297          GNUNET_h2s (GC_h2hc (&msg->cid)));
2298     send_broken_unknown (&msg->cid, &my_full_id, NULL, peer);
2299     return GNUNET_OK;
2300   }
2301
2302   /* Is this a forward or backward ACK?
2303    * Note: a poll should never be needed in a loopback case,
2304    * since there is no possiblility of packet loss there, so
2305    * this way of discerining FWD/BCK should not be a problem.
2306    */
2307   id = GNUNET_PEER_search (peer);
2308   if (GCP_get_short_id (get_next_hop (c)) == id)
2309   {
2310     LOG (GNUNET_ERROR_TYPE_DEBUG, "  FWD FC\n");
2311     fc = &c->fwd_fc;
2312   }
2313   else if (GCP_get_short_id (get_prev_hop (c)) == id)
2314   {
2315     LOG (GNUNET_ERROR_TYPE_DEBUG, "  BCK FC\n");
2316     fc = &c->bck_fc;
2317   }
2318   else
2319   {
2320     GNUNET_break_op (0);
2321     return GNUNET_OK;
2322   }
2323
2324   pid = ntohl (msg->pid);
2325   LOG (GNUNET_ERROR_TYPE_DEBUG, "  PID %u, OLD %u\n", pid, fc->last_pid_recv);
2326   fc->last_pid_recv = pid;
2327   fwd = fc == &c->bck_fc;
2328   GCC_send_ack (c, fwd, GNUNET_YES);
2329
2330   return GNUNET_OK;
2331 }
2332
2333
2334 /**
2335  * Send an ACK on the appropriate connection/channel, depending on
2336  * the direction and the position of the peer.
2337  *
2338  * @param c Which connection to send the hop-by-hop ACK.
2339  * @param fwd Is this a fwd ACK? (will go dest->root).
2340  * @param force Send the ACK even if suboptimal (e.g. requested by POLL).
2341  */
2342 void
2343 GCC_send_ack (struct CadetConnection *c, int fwd, int force)
2344 {
2345   unsigned int buffer;
2346
2347   LOG (GNUNET_ERROR_TYPE_DEBUG,
2348        "GMC send %s ACK on %s\n",
2349        GC_f2s (fwd), GCC_2s (c));
2350
2351   if (NULL == c)
2352   {
2353     GNUNET_break (0);
2354     return;
2355   }
2356
2357   if (GNUNET_NO != c->destroy)
2358   {
2359     LOG (GNUNET_ERROR_TYPE_DEBUG, "  being destroyed, why bother...\n");
2360     return;
2361   }
2362
2363   /* Get available buffer space */
2364   if (GCC_is_terminal (c, fwd))
2365   {
2366     LOG (GNUNET_ERROR_TYPE_DEBUG, "  getting from all channels\n");
2367     buffer = GCT_get_channels_buffer (c->t);
2368   }
2369   else
2370   {
2371     LOG (GNUNET_ERROR_TYPE_DEBUG, "  getting from one connection\n");
2372     buffer = GCC_get_buffer (c, fwd);
2373   }
2374   LOG (GNUNET_ERROR_TYPE_DEBUG, "  buffer available: %u\n", buffer);
2375   if (0 == buffer && GNUNET_NO == force)
2376     return;
2377
2378   /* Send available buffer space */
2379   if (GCC_is_origin (c, fwd))
2380   {
2381     GNUNET_assert (NULL != c->t);
2382     LOG (GNUNET_ERROR_TYPE_DEBUG, "  sending on channels...\n");
2383     GCT_unchoke_channels (c->t);
2384   }
2385   else
2386   {
2387     LOG (GNUNET_ERROR_TYPE_DEBUG, "  sending on connection\n");
2388     send_ack (c, buffer, fwd, force);
2389   }
2390 }
2391
2392
2393 /**
2394  * Initialize the connections subsystem
2395  *
2396  * @param c Configuration handle.
2397  */
2398 void
2399 GCC_init (const struct GNUNET_CONFIGURATION_Handle *c)
2400 {
2401   LOG (GNUNET_ERROR_TYPE_DEBUG, "init\n");
2402   if (GNUNET_OK !=
2403       GNUNET_CONFIGURATION_get_value_number (c, "CADET", "MAX_MSGS_QUEUE",
2404                                              &max_msgs_queue))
2405   {
2406     GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
2407                                "CADET", "MAX_MSGS_QUEUE", "MISSING");
2408     GNUNET_SCHEDULER_shutdown ();
2409     return;
2410   }
2411
2412   if (GNUNET_OK !=
2413       GNUNET_CONFIGURATION_get_value_number (c, "CADET", "MAX_CONNECTIONS",
2414                                              &max_connections))
2415   {
2416     GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
2417                                "CADET", "MAX_CONNECTIONS", "MISSING");
2418     GNUNET_SCHEDULER_shutdown ();
2419     return;
2420   }
2421
2422   if (GNUNET_OK !=
2423       GNUNET_CONFIGURATION_get_value_time (c, "CADET", "REFRESH_CONNECTION_TIME",
2424                                            &refresh_connection_time))
2425   {
2426     GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
2427                                "CADET", "REFRESH_CONNECTION_TIME", "MISSING");
2428     GNUNET_SCHEDULER_shutdown ();
2429     return;
2430   }
2431   create_connection_time = GNUNET_TIME_UNIT_SECONDS;
2432   connections = GNUNET_CONTAINER_multihashmap_create (1024, GNUNET_NO);
2433 }
2434
2435
2436 /**
2437  * Destroy each connection on shutdown.
2438  *
2439  * @param cls Closure (unused).
2440  * @param key Current key code (CID, unused).
2441  * @param value Value in the hash map (connection)
2442  *
2443  * @return #GNUNET_YES, because we should continue to iterate,
2444  */
2445 static int
2446 shutdown_iterator (void *cls,
2447                    const struct GNUNET_HashCode *key,
2448                    void *value)
2449 {
2450   struct CadetConnection *c = value;
2451
2452   GCC_destroy (c);
2453   return GNUNET_YES;
2454 }
2455
2456
2457 /**
2458  * Shut down the connections subsystem.
2459  */
2460 void
2461 GCC_shutdown (void)
2462 {
2463   GNUNET_CONTAINER_multihashmap_iterate (connections, &shutdown_iterator, NULL);
2464   GNUNET_CONTAINER_multihashmap_destroy (connections);
2465   connections = NULL;
2466 }
2467
2468
2469 struct CadetConnection *
2470 GCC_new (const struct GNUNET_CADET_Hash *cid,
2471          struct CadetTunnel *t,
2472          struct CadetPeerPath *p,
2473          unsigned int own_pos)
2474 {
2475   struct CadetConnection *c;
2476
2477   c = GNUNET_new (struct CadetConnection);
2478   c->id = *cid;
2479   GNUNET_assert (GNUNET_OK ==
2480                  GNUNET_CONTAINER_multihashmap_put (connections,
2481                                                     GCC_get_h (c), c,
2482                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
2483   fc_init (&c->fwd_fc);
2484   fc_init (&c->bck_fc);
2485   c->fwd_fc.c = c;
2486   c->bck_fc.c = c;
2487
2488   c->t = t;
2489   GNUNET_assert (own_pos <= p->length - 1);
2490   c->own_pos = own_pos;
2491   c->path = p;
2492   p->c = c;
2493
2494   if (GNUNET_OK != register_neighbors (c))
2495   {
2496     if (0 == own_pos)
2497     {
2498       path_invalidate (c->path);
2499       c->t = NULL;
2500       c->path = NULL;
2501     }
2502     GCC_destroy (c);
2503     return NULL;
2504   }
2505
2506   return c;
2507 }
2508
2509
2510 void
2511 GCC_destroy (struct CadetConnection *c)
2512 {
2513   if (NULL == c)
2514   {
2515     GNUNET_break (0);
2516     return;
2517   }
2518
2519   if (2 == c->destroy) /* cancel queues -> GCP_queue_cancel -> q_destroy -> */
2520     return;            /* -> message_sent -> GCC_destroy. Don't loop. */
2521   c->destroy = 2;
2522
2523   LOG (GNUNET_ERROR_TYPE_DEBUG, "destroying connection %s\n", GCC_2s (c));
2524   LOG (GNUNET_ERROR_TYPE_DEBUG, " fc's f: %p, b: %p\n",
2525        &c->fwd_fc, &c->bck_fc);
2526   LOG (GNUNET_ERROR_TYPE_DEBUG, " fc tasks f: %u, b: %u\n",
2527        c->fwd_fc.poll_task, c->bck_fc.poll_task);
2528
2529   /* Cancel all traffic */
2530   if (NULL != c->path)
2531   {
2532     connection_cancel_queues (c, GNUNET_YES);
2533     connection_cancel_queues (c, GNUNET_NO);
2534     unregister_neighbors (c);
2535   }
2536
2537   LOG (GNUNET_ERROR_TYPE_DEBUG, " fc tasks f: %u, b: %u\n",
2538        c->fwd_fc.poll_task, c->bck_fc.poll_task);
2539
2540   /* Cancel maintainance task (keepalive/timeout) */
2541   if (NULL != c->fwd_fc.poll_msg)
2542   {
2543     GCC_cancel (c->fwd_fc.poll_msg);
2544     LOG (GNUNET_ERROR_TYPE_DEBUG, " *** POLL msg FWD canceled\n");
2545   }
2546   if (NULL != c->bck_fc.poll_msg)
2547   {
2548     GCC_cancel (c->bck_fc.poll_msg);
2549     LOG (GNUNET_ERROR_TYPE_DEBUG, " *** POLL msg BCK canceled\n");
2550   }
2551
2552   /* Delete from tunnel */
2553   if (NULL != c->t)
2554     GCT_remove_connection (c->t, c);
2555
2556   if (GNUNET_NO == GCC_is_origin (c, GNUNET_YES) && NULL != c->path)
2557     path_destroy (c->path);
2558   if (GNUNET_SCHEDULER_NO_TASK != c->fwd_maintenance_task)
2559     GNUNET_SCHEDULER_cancel (c->fwd_maintenance_task);
2560   if (GNUNET_SCHEDULER_NO_TASK != c->bck_maintenance_task)
2561     GNUNET_SCHEDULER_cancel (c->bck_maintenance_task);
2562   if (GNUNET_SCHEDULER_NO_TASK != c->fwd_fc.poll_task)
2563   {
2564     GNUNET_SCHEDULER_cancel (c->fwd_fc.poll_task);
2565     LOG (GNUNET_ERROR_TYPE_DEBUG, " *** POLL FWD canceled\n");
2566   }
2567   if (GNUNET_SCHEDULER_NO_TASK != c->bck_fc.poll_task)
2568   {
2569     GNUNET_SCHEDULER_cancel (c->bck_fc.poll_task);
2570     LOG (GNUNET_ERROR_TYPE_DEBUG, " *** POLL BCK canceled\n");
2571   }
2572
2573   GNUNET_break (GNUNET_YES ==
2574                 GNUNET_CONTAINER_multihashmap_remove (connections,
2575                                                       GCC_get_h (c), c));
2576
2577   GNUNET_STATISTICS_update (stats, "# connections", -1, GNUNET_NO);
2578   GNUNET_free (c);
2579 }
2580
2581 /**
2582  * Get the connection ID.
2583  *
2584  * @param c Connection to get the ID from.
2585  *
2586  * @return ID of the connection.
2587  */
2588 const struct GNUNET_CADET_Hash *
2589 GCC_get_id (const struct CadetConnection *c)
2590 {
2591   return &c->id;
2592 }
2593
2594
2595 /**
2596  * Get the connection ID.
2597  *
2598  * @param c Connection to get the ID from.
2599  *
2600  * @return ID of the connection.
2601  */
2602 const struct GNUNET_HashCode *
2603 GCC_get_h (const struct CadetConnection *c)
2604 {
2605   return GC_h2hc (&c->id);
2606 }
2607
2608
2609 /**
2610  * Get the connection path.
2611  *
2612  * @param c Connection to get the path from.
2613  *
2614  * @return path used by the connection.
2615  */
2616 const struct CadetPeerPath *
2617 GCC_get_path (const struct CadetConnection *c)
2618 {
2619   if (GNUNET_NO == c->destroy)
2620     return c->path;
2621   return NULL;
2622 }
2623
2624
2625 /**
2626  * Get the connection state.
2627  *
2628  * @param c Connection to get the state from.
2629  *
2630  * @return state of the connection.
2631  */
2632 enum CadetConnectionState
2633 GCC_get_state (const struct CadetConnection *c)
2634 {
2635   return c->state;
2636 }
2637
2638 /**
2639  * Get the connection tunnel.
2640  *
2641  * @param c Connection to get the tunnel from.
2642  *
2643  * @return tunnel of the connection.
2644  */
2645 struct CadetTunnel *
2646 GCC_get_tunnel (const struct CadetConnection *c)
2647 {
2648   return c->t;
2649 }
2650
2651
2652 /**
2653  * Get free buffer space in a connection.
2654  *
2655  * @param c Connection.
2656  * @param fwd Is query about FWD traffic?
2657  *
2658  * @return Free buffer space [0 - max_msgs_queue/max_connections]
2659  */
2660 unsigned int
2661 GCC_get_buffer (struct CadetConnection *c, int fwd)
2662 {
2663   struct CadetFlowControl *fc;
2664
2665   fc = fwd ? &c->fwd_fc : &c->bck_fc;
2666
2667   return (fc->queue_max - fc->queue_n);
2668 }
2669
2670 /**
2671  * Get how many messages have we allowed to send to us from a direction.
2672  *
2673  * @param c Connection.
2674  * @param fwd Are we asking about traffic from FWD (BCK messages)?
2675  *
2676  * @return last_ack_sent - last_pid_recv
2677  */
2678 unsigned int
2679 GCC_get_allowed (struct CadetConnection *c, int fwd)
2680 {
2681   struct CadetFlowControl *fc;
2682
2683   fc = fwd ? &c->fwd_fc : &c->bck_fc;
2684   if (GC_is_pid_bigger (fc->last_pid_recv, fc->last_ack_sent))
2685   {
2686     return 0;
2687   }
2688   return (fc->last_ack_sent - fc->last_pid_recv);
2689 }
2690
2691 /**
2692  * Get messages queued in a connection.
2693  *
2694  * @param c Connection.
2695  * @param fwd Is query about FWD traffic?
2696  *
2697  * @return Number of messages queued.
2698  */
2699 unsigned int
2700 GCC_get_qn (struct CadetConnection *c, int fwd)
2701 {
2702   struct CadetFlowControl *fc;
2703
2704   fc = fwd ? &c->fwd_fc : &c->bck_fc;
2705
2706   return fc->queue_n;
2707 }
2708
2709
2710 /**
2711  * Get next PID to use.
2712  *
2713  * @param c Connection.
2714  * @param fwd Is query about FWD traffic?
2715  *
2716  * @return Last PID used + 1.
2717  */
2718 unsigned int
2719 GCC_get_pid (struct CadetConnection *c, int fwd)
2720 {
2721   struct CadetFlowControl *fc;
2722
2723   fc = fwd ? &c->fwd_fc : &c->bck_fc;
2724
2725   return fc->last_pid_sent + 1;
2726 }
2727
2728
2729 /**
2730  * Allow the connection to advertise a buffer of the given size.
2731  *
2732  * The connection will send an @c fwd ACK message (so: in direction !fwd)
2733  * allowing up to last_pid_recv + buffer.
2734  *
2735  * @param c Connection.
2736  * @param buffer How many more messages the connection can accept.
2737  * @param fwd Is this about FWD traffic? (The ack will go dest->root).
2738  */
2739 void
2740 GCC_allow (struct CadetConnection *c, unsigned int buffer, int fwd)
2741 {
2742   LOG (GNUNET_ERROR_TYPE_DEBUG, "  allowing %s %u messages %s\n",
2743        GCC_2s (c), buffer, GC_f2s (fwd));
2744   send_ack (c, buffer, fwd, GNUNET_NO);
2745 }
2746
2747
2748 /**
2749  * Notify other peers on a connection of a broken link. Mark connections
2750  * to destroy after all traffic has been sent.
2751  *
2752  * @param c Connection on which there has been a disconnection.
2753  * @param peer Peer that disconnected.
2754  */
2755 void
2756 GCC_notify_broken (struct CadetConnection *c,
2757                    struct CadetPeer *peer)
2758 {
2759   int fwd;
2760
2761   LOG (GNUNET_ERROR_TYPE_DEBUG,
2762        " notify broken on %s due to %s disconnect\n",
2763        GCC_2s (c), GCP_2s (peer));
2764
2765   fwd = peer == get_prev_hop (c);
2766
2767   if (GNUNET_YES == GCC_is_terminal (c, fwd))
2768   {
2769     /* Local shutdown, no one to notify about this. */
2770     GCC_destroy (c);
2771     return;
2772   }
2773   if (GNUNET_NO == c->destroy)
2774     send_broken (c, &my_full_id, GCP_get_id (peer), fwd);
2775
2776   /* Connection will have at least one pending message
2777    * (the one we just scheduled), so no point in checking whether to
2778    * destroy immediately. */
2779   c->destroy = GNUNET_YES;
2780   c->state = CADET_CONNECTION_DESTROYED;
2781
2782   /**
2783    * Cancel all queues, if no message is left, connection will be destroyed.
2784    */
2785   connection_cancel_queues (c, !fwd);
2786
2787   return;
2788 }
2789
2790
2791 /**
2792  * Is this peer the first one on the connection?
2793  *
2794  * @param c Connection.
2795  * @param fwd Is this about fwd traffic?
2796  *
2797  * @return #GNUNET_YES if origin, #GNUNET_NO if relay/terminal.
2798  */
2799 int
2800 GCC_is_origin (struct CadetConnection *c, int fwd)
2801 {
2802   if (!fwd && c->path->length - 1 == c->own_pos )
2803     return GNUNET_YES;
2804   if (fwd && 0 == c->own_pos)
2805     return GNUNET_YES;
2806   return GNUNET_NO;
2807 }
2808
2809
2810 /**
2811  * Is this peer the last one on the connection?
2812  *
2813  * @param c Connection.
2814  * @param fwd Is this about fwd traffic?
2815  *            Note that the ROOT is the terminal for BCK traffic!
2816  *
2817  * @return #GNUNET_YES if terminal, #GNUNET_NO if relay/origin.
2818  */
2819 int
2820 GCC_is_terminal (struct CadetConnection *c, int fwd)
2821 {
2822   return GCC_is_origin (c, !fwd);
2823 }
2824
2825
2826 /**
2827  * See if we are allowed to send by the next hop in the given direction.
2828  *
2829  * @param c Connection.
2830  * @param fwd Is this about fwd traffic?
2831  *
2832  * @return #GNUNET_YES in case it's OK to send.
2833  */
2834 int
2835 GCC_is_sendable (struct CadetConnection *c, int fwd)
2836 {
2837   struct CadetFlowControl *fc;
2838
2839   LOG (GNUNET_ERROR_TYPE_DEBUG, " checking sendability of %s traffic on %s\n",
2840        GC_f2s (fwd), GCC_2s (c));
2841   if (NULL == c)
2842   {
2843     GNUNET_break (0);
2844     return GNUNET_YES;
2845   }
2846   fc = fwd ? &c->fwd_fc : &c->bck_fc;
2847   LOG (GNUNET_ERROR_TYPE_DEBUG,
2848        " last ack recv: %u, last pid sent: %u\n",
2849        fc->last_ack_recv, fc->last_pid_sent);
2850   if (GC_is_pid_bigger (fc->last_ack_recv, fc->last_pid_sent))
2851   {
2852     LOG (GNUNET_ERROR_TYPE_DEBUG, " sendable\n");
2853     return GNUNET_YES;
2854   }
2855   LOG (GNUNET_ERROR_TYPE_DEBUG, " not sendable\n");
2856   return GNUNET_NO;
2857 }
2858
2859
2860 /**
2861  * Check if this connection is a direct one (never trim a direct connection).
2862  *
2863  * @param c Connection.
2864  *
2865  * @return #GNUNET_YES in case it's a direct connection, #GNUNET_NO otherwise.
2866  */
2867 int
2868 GCC_is_direct (struct CadetConnection *c)
2869 {
2870   return (c->path->length == 2) ? GNUNET_YES : GNUNET_NO;
2871 }
2872
2873 /**
2874  * Sends an already built message on a connection, properly registering
2875  * all used resources.
2876  *
2877  * @param message Message to send. Function makes a copy of it.
2878  *                If message is not hop-by-hop, decrements TTL of copy.
2879  * @param payload_type Type of payload, in case the message is encrypted.
2880  * @param c Connection on which this message is transmitted.
2881  * @param fwd Is this a fwd message?
2882  * @param force Force the connection to accept the message (buffer overfill).
2883  * @param cont Continuation called once message is sent. Can be NULL.
2884  * @param cont_cls Closure for @c cont.
2885  *
2886  * @return Handle to cancel the message before it's sent.
2887  *         NULL on error or if @c cont is NULL.
2888  *         Invalid on @c cont call.
2889  */
2890 struct CadetConnectionQueue *
2891 GCC_send_prebuilt_message (const struct GNUNET_MessageHeader *message,
2892                            uint16_t payload_type, uint32_t payload_id,
2893                            struct CadetConnection *c, int fwd, int force,
2894                            GCC_sent cont, void *cont_cls)
2895 {
2896   struct CadetFlowControl *fc;
2897   struct CadetConnectionQueue *q;
2898   void *data;
2899   size_t size;
2900   uint16_t type;
2901   int droppable;
2902
2903   size = ntohs (message->size);
2904   data = GNUNET_malloc (size);
2905   memcpy (data, message, size);
2906   type = ntohs (message->type);
2907   LOG (GNUNET_ERROR_TYPE_INFO, "--> %s (%s %u) on connection %s (%u bytes)\n",
2908        GC_m2s (type), GC_m2s (payload_type), payload_id, GCC_2s (c), size);
2909
2910   fc = fwd ? &c->fwd_fc : &c->bck_fc;
2911   droppable = GNUNET_NO == force;
2912   switch (type)
2913   {
2914     struct GNUNET_CADET_Encrypted *emsg;
2915     struct GNUNET_CADET_KX        *kmsg;
2916     struct GNUNET_CADET_ACK       *amsg;
2917     struct GNUNET_CADET_Poll      *pmsg;
2918     struct GNUNET_CADET_ConnectionDestroy *dmsg;
2919     struct GNUNET_CADET_ConnectionBroken  *bmsg;
2920     uint32_t ttl;
2921
2922     case GNUNET_MESSAGE_TYPE_CADET_ENCRYPTED:
2923       emsg = (struct GNUNET_CADET_Encrypted *) data;
2924       ttl = ntohl (emsg->ttl);
2925       if (0 == ttl)
2926       {
2927         GNUNET_break_op (0);
2928         GNUNET_free (data);
2929         return NULL;
2930       }
2931       emsg->cid = c->id;
2932       emsg->ttl = htonl (ttl - 1);
2933       emsg->pid = htonl (0);
2934       LOG (GNUNET_ERROR_TYPE_DEBUG, "  Q_N+ %p %u\n", fc, fc->queue_n);
2935       LOG (GNUNET_ERROR_TYPE_DEBUG, "last pid sent %u\n", fc->last_pid_sent);
2936       LOG (GNUNET_ERROR_TYPE_DEBUG, "     ack recv %u\n", fc->last_ack_recv);
2937       if (GNUNET_YES == droppable)
2938       {
2939         fc->queue_n++;
2940       }
2941       else
2942       {
2943         LOG (GNUNET_ERROR_TYPE_DEBUG, "  not droppable, Q_N stays the same\n");
2944       }
2945       if (GC_is_pid_bigger (fc->last_pid_sent + 1, fc->last_ack_recv))
2946       {
2947         GCC_start_poll (c, fwd);
2948       }
2949       break;
2950
2951     case GNUNET_MESSAGE_TYPE_CADET_KX:
2952       kmsg = (struct GNUNET_CADET_KX *) data;
2953       kmsg->cid = c->id;
2954       break;
2955
2956     case GNUNET_MESSAGE_TYPE_CADET_ACK:
2957       amsg = (struct GNUNET_CADET_ACK *) data;
2958       amsg->cid = c->id;
2959       LOG (GNUNET_ERROR_TYPE_DEBUG, " ack %u\n", ntohl (amsg->ack));
2960       droppable = GNUNET_NO;
2961       break;
2962
2963     case GNUNET_MESSAGE_TYPE_CADET_POLL:
2964       pmsg = (struct GNUNET_CADET_Poll *) data;
2965       pmsg->cid = c->id;
2966       LOG (GNUNET_ERROR_TYPE_DEBUG, " poll %u\n", ntohl (pmsg->pid));
2967       droppable = GNUNET_NO;
2968       break;
2969
2970     case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY:
2971       dmsg = (struct GNUNET_CADET_ConnectionDestroy *) data;
2972       dmsg->cid = c->id;
2973       break;
2974
2975     case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN:
2976       bmsg = (struct GNUNET_CADET_ConnectionBroken *) data;
2977       bmsg->cid = c->id;
2978       break;
2979
2980     case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE:
2981     case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK:
2982       break;
2983
2984     default:
2985       GNUNET_break (0);
2986       GNUNET_free (data);
2987       return NULL;
2988   }
2989
2990   if (fc->queue_n > fc->queue_max && droppable)
2991   {
2992     GNUNET_STATISTICS_update (stats, "# messages dropped (buffer full)",
2993                               1, GNUNET_NO);
2994     GNUNET_break (0);
2995     LOG (GNUNET_ERROR_TYPE_DEBUG, "queue full: %u/%u\n",
2996          fc->queue_n, fc->queue_max);
2997     if (GNUNET_MESSAGE_TYPE_CADET_ENCRYPTED == type)
2998     {
2999       fc->queue_n--;
3000     }
3001     GNUNET_free (data);
3002     return NULL; /* Drop this message */
3003   }
3004
3005   LOG (GNUNET_ERROR_TYPE_DEBUG, "  C_P+ %s %u\n",
3006        GCC_2s (c), c->pending_messages);
3007   c->pending_messages++;
3008
3009   q = GNUNET_new (struct CadetConnectionQueue);
3010   q->forced = !droppable;
3011   q->q = GCP_queue_add (get_hop (c, fwd), data, type, payload_type, payload_id,
3012                         size, c, fwd, &conn_message_sent, q);
3013   if (NULL == q->q)
3014   {
3015     LOG (GNUNET_ERROR_TYPE_DEBUG, "dropping msg on %s, NULL q\n", GCC_2s (c));
3016     GNUNET_free (data);
3017     GNUNET_free (q);
3018     return NULL;
3019   }
3020   q->cont = cont;
3021   q->cont_cls = cont_cls;
3022   return (NULL == cont) ? NULL : q;
3023 }
3024
3025
3026 /**
3027  * Cancel a previously sent message while it's in the queue.
3028  *
3029  * ONLY can be called before the continuation given to the send function
3030  * is called. Once the continuation is called, the message is no longer in the
3031  * queue.
3032  *
3033  * @param q Handle to the queue.
3034  */
3035 void
3036 GCC_cancel (struct CadetConnectionQueue *q)
3037 {
3038   LOG (GNUNET_ERROR_TYPE_DEBUG, "!  GMC cancel message\n");
3039
3040   /* queue destroy calls message_sent, which calls q->cont and frees q */
3041   GCP_queue_destroy (q->q, GNUNET_YES, GNUNET_NO, 0);
3042 }
3043
3044
3045 /**
3046  * Sends a CREATE CONNECTION message for a path to a peer.
3047  * Changes the connection and tunnel states if necessary.
3048  *
3049  * @param connection Connection to create.
3050  */
3051 void
3052 GCC_send_create (struct CadetConnection *connection)
3053 {
3054   enum CadetTunnelCState state;
3055   size_t size;
3056
3057   size = sizeof (struct GNUNET_CADET_ConnectionCreate);
3058   size += connection->path->length * sizeof (struct GNUNET_PeerIdentity);
3059
3060   LOG (GNUNET_ERROR_TYPE_INFO, "===> %s on connection %s  (%u bytes)\n",
3061        GC_m2s (GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE),
3062        GCC_2s (connection), size);
3063   LOG (GNUNET_ERROR_TYPE_DEBUG, "  C_P+ %p %u (create)\n",
3064        connection, connection->pending_messages);
3065   connection->pending_messages++;
3066
3067   connection->maintenance_q =
3068     GCP_queue_add (get_next_hop (connection), NULL,
3069                    GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE, 0, 0,
3070                    size, connection, GNUNET_YES, &conn_message_sent, NULL);
3071
3072   state = GCT_get_cstate (connection->t);
3073   if (CADET_TUNNEL_SEARCHING == state || CADET_TUNNEL_NEW == state)
3074     GCT_change_cstate (connection->t, CADET_TUNNEL_WAITING);
3075   if (CADET_CONNECTION_NEW == connection->state)
3076     connection_change_state (connection, CADET_CONNECTION_SENT);
3077 }
3078
3079
3080 /**
3081  * Send a message to all peers in this connection that the connection
3082  * is no longer valid.
3083  *
3084  * If some peer should not receive the message, it should be zero'ed out
3085  * before calling this function.
3086  *
3087  * @param c The connection whose peers to notify.
3088  */
3089 void
3090 GCC_send_destroy (struct CadetConnection *c)
3091 {
3092   struct GNUNET_CADET_ConnectionDestroy msg;
3093
3094   if (GNUNET_YES == c->destroy)
3095     return;
3096
3097   msg.header.size = htons (sizeof (msg));
3098   msg.header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY);
3099   msg.cid = c->id;
3100   LOG (GNUNET_ERROR_TYPE_DEBUG,
3101               "  sending connection destroy for connection %s\n",
3102               GCC_2s (c));
3103
3104   if (GNUNET_NO == GCC_is_terminal (c, GNUNET_YES))
3105     GNUNET_assert (NULL == GCC_send_prebuilt_message (&msg.header, 0, 0, c,
3106                                                       GNUNET_YES, GNUNET_YES,
3107                                                       NULL, NULL));
3108   if (GNUNET_NO == GCC_is_terminal (c, GNUNET_NO))
3109     GNUNET_assert (NULL == GCC_send_prebuilt_message (&msg.header, 0, 0, c,
3110                                                       GNUNET_NO, GNUNET_YES,
3111                                                       NULL, NULL));
3112   c->destroy = GNUNET_YES;
3113   c->state = CADET_CONNECTION_DESTROYED;
3114 }
3115
3116
3117 /**
3118  * @brief Start a polling timer for the connection.
3119  *
3120  * When a neighbor does not accept more traffic on the connection it could be
3121  * caused by a simple congestion or by a lost ACK. Polling enables to check
3122  * for the lastest ACK status for a connection.
3123  *
3124  * @param c Connection.
3125  * @param fwd Should we poll in the FWD direction?
3126  */
3127 void
3128 GCC_start_poll (struct CadetConnection *c, int fwd)
3129 {
3130   struct CadetFlowControl *fc;
3131
3132   fc = fwd ? &c->fwd_fc : &c->bck_fc;
3133   LOG (GNUNET_ERROR_TYPE_DEBUG, " *** POLL %s requested\n",
3134        GC_f2s (fwd));
3135   if (GNUNET_SCHEDULER_NO_TASK != fc->poll_task || NULL != fc->poll_msg)
3136   {
3137     LOG (GNUNET_ERROR_TYPE_DEBUG, " ***   not needed (%u, %p)\n",
3138          fc->poll_task, fc->poll_msg);
3139     return;
3140   }
3141   LOG (GNUNET_ERROR_TYPE_DEBUG, " *** POLL started on request\n");
3142   fc->poll_task = GNUNET_SCHEDULER_add_delayed (fc->poll_time,
3143                                                 &connection_poll,
3144                                                 fc);
3145 }
3146
3147
3148 /**
3149  * @brief Stop polling a connection for ACKs.
3150  *
3151  * Once we have enough ACKs for future traffic, polls are no longer necessary.
3152  *
3153  * @param c Connection.
3154  * @param fwd Should we stop the poll in the FWD direction?
3155  */
3156 void
3157 GCC_stop_poll (struct CadetConnection *c, int fwd)
3158 {
3159   struct CadetFlowControl *fc;
3160
3161   fc = fwd ? &c->fwd_fc : &c->bck_fc;
3162   if (GNUNET_SCHEDULER_NO_TASK != fc->poll_task)
3163   {
3164     GNUNET_SCHEDULER_cancel (fc->poll_task);
3165     fc->poll_task = GNUNET_SCHEDULER_NO_TASK;
3166   }
3167 }
3168
3169 /**
3170  * Get a (static) string for a connection.
3171  *
3172  * @param c Connection.
3173  */
3174 const char *
3175 GCC_2s (const struct CadetConnection *c)
3176 {
3177   if (NULL == c)
3178     return "NULL";
3179
3180   if (NULL != c->t)
3181   {
3182     static char buf[128];
3183
3184     SPRINTF (buf, "%s (->%s)",
3185              GNUNET_h2s (GC_h2hc (GCC_get_id (c))), GCT_2s (c->t));
3186     return buf;
3187   }
3188   return GNUNET_h2s (GC_h2hc (&c->id));
3189 }
3190
3191
3192 /**
3193  * Log all possible info about the connection state.
3194  *
3195  * @param c Connection to debug.
3196  * @param level Debug level to use.
3197  */
3198 void
3199 GCC_debug (const struct CadetConnection *c, enum GNUNET_ErrorType level)
3200 {
3201   int do_log;
3202   char *s;
3203
3204   do_log = GNUNET_get_log_call_status (level & (~GNUNET_ERROR_TYPE_BULK),
3205                                        "cadet-con",
3206                                        __FILE__, __FUNCTION__, __LINE__);
3207   if (0 == do_log)
3208     return;
3209
3210   if (NULL == c)
3211   {
3212     LOG2 (level, "CCC DEBUG NULL CONNECTION\n");
3213     return;
3214   }
3215
3216   LOG2 (level, "CCC DEBUG CONNECTION %s\n", GCC_2s (c));
3217   s = path_2s (c->path);
3218   LOG2 (level, "CCC  path %s, own pos: %u\n", s, c->own_pos);
3219   GNUNET_free (s);
3220   LOG2 (level, "CCC  state: %s, destroy: %u\n",
3221         GCC_state2s (c->state), c->destroy);
3222   LOG2 (level, "CCC  pending messages: %u\n", c->pending_messages);
3223   if (NULL != c->perf)
3224     LOG2 (level, "CCC  us/byte: %f\n", c->perf->avg);
3225
3226   LOG2 (level, "CCC  FWD flow control:\n");
3227   LOG2 (level, "CCC   queue: %u/%u\n", c->fwd_fc.queue_n, c->fwd_fc.queue_max);
3228   LOG2 (level, "CCC   last PID sent: %5u, recv: %5u\n",
3229         c->fwd_fc.last_pid_sent, c->fwd_fc.last_pid_recv);
3230   LOG2 (level, "CCC   last ACK sent: %5u, recv: %5u\n",
3231         c->fwd_fc.last_ack_sent, c->fwd_fc.last_ack_recv);
3232   LOG2 (level, "CCC   POLL: task %d, msg  %p, msg_ack %p)\n",
3233         c->fwd_fc.poll_task, c->fwd_fc.poll_msg, c->fwd_fc.ack_msg);
3234
3235   LOG2 (level, "CCC  BCK flow control:\n");
3236   LOG2 (level, "CCC   queue: %u/%u\n", c->bck_fc.queue_n, c->bck_fc.queue_max);
3237   LOG2 (level, "CCC   last PID sent: %5u, recv: %5u\n",
3238         c->bck_fc.last_pid_sent, c->bck_fc.last_pid_recv);
3239   LOG2 (level, "CCC   last ACK sent: %5u, recv: %5u\n",
3240         c->bck_fc.last_ack_sent, c->bck_fc.last_ack_recv);
3241   LOG2 (level, "CCC   POLL: task %d, msg  %p, msg_ack %p)\n",
3242         c->bck_fc.poll_task, c->bck_fc.poll_msg, c->bck_fc.ack_msg);
3243
3244   LOG2 (level, "CCC DEBUG CONNECTION END\n");
3245 }
3246