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