src/transport/gnunet-service-transport_neighbours.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2010,2011 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 transport/gnunet-service-transport_neighbours.c
  23  * @brief neighbour management
  24  * @author Christian Grothoff
  25  */
  26 #include "platform.h"
  27 #include "gnunet_ats_service.h"
  28 #include "gnunet-service-transport_neighbours.h"
  29 #include "gnunet-service-transport_plugins.h"
  30 #include "gnunet-service-transport_validation.h"
  31 #include "gnunet-service-transport_clients.h"
  32 #include "gnunet-service-transport.h"
  33 #include "gnunet_peerinfo_service.h"
  34 #include "gnunet_constants.h"
  35 #include "transport.h"
  36
  37
  38 /**
  39  * Size of the neighbour hash map.
  40  */
  41 #define NEIGHBOUR_TABLE_SIZE 256
  42
  43 /**
  44  * How often must a peer violate bandwidth quotas before we start
  45  * to simply drop its messages?
  46  */
  47 #define QUOTA_VIOLATION_DROP_THRESHOLD 10
  48
  49 /**
  50  * How often do we send KEEPALIVE messages to each of our neighbours?
  51  * (idle timeout is 5 minutes or 300 seconds, so with 90s interval we
  52  * send 3 keepalives in each interval, so 3 messages would need to be
  53  * lost in a row for a disconnect).
  54  */
  55 #define KEEPALIVE_FREQUENCY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 90)
  56
  57
  58 /**
  59  * Entry in neighbours.
  60  */
  61 struct NeighbourMapEntry;
  62
  63 /**
  64  * Message a peer sends to another to indicate its
  65  * preference for communicating via a particular
  66  * session (and the desire to establish a real
  67  * connection).
  68  */
  69 struct SessionConnectMessage
  70 {
  71   /**
  72    * Header of type 'GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_CONNECT'
  73    */
  74   struct GNUNET_MessageHeader header;
  75
  76   /**
  77    * Always zero.
  78    */
  79   uint32_t reserved GNUNET_PACKED;
  80
  81   /**
  82    * Absolute time at the sender.  Only the most recent connect
  83    * message implies which session is preferred by the sender.
  84    */
  85   struct GNUNET_TIME_AbsoluteNBO timestamp;
  86
  87 };
  88
  89
  90 struct SessionDisconnectMessage
  91 {
  92   /**
  93    * Header of type 'GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_DISCONNECT'
  94    */
  95   struct GNUNET_MessageHeader header;
  96
  97   /**
  98    * Always zero.
  99    */
 100   uint32_t reserved GNUNET_PACKED;
 101
 102   /**
 103    * Purpose of the signature.  Extends over the timestamp.
 104    * Purpose should be GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DISCONNECT.
 105    */
 106   struct GNUNET_CRYPTO_RsaSignaturePurpose purpose;
 107
 108   /**
 109    * Absolute time at the sender.  Only the most recent connect
 110    * message implies which session is preferred by the sender.
 111    */
 112   struct GNUNET_TIME_AbsoluteNBO timestamp;
 113
 114   /**
 115    * Public key of the sender.
 116    */
 117   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded public_key;
 118
 119   /**
 120    * Signature of the peer that sends us the disconnect.  Only
 121    * valid if the timestamp is AFTER the timestamp from the
 122    * corresponding 'CONNECT' message.
 123    */
 124   struct GNUNET_CRYPTO_RsaSignature signature;
 125
 126 };
 127
 128
 129 /**
 130  * For each neighbour we keep a list of messages
 131  * that we still want to transmit to the neighbour.
 132  */
 133 struct MessageQueue
 134 {
 135
 136   /**
 137    * This is a doubly linked list.
 138    */
 139   struct MessageQueue *next;
 140
 141   /**
 142    * This is a doubly linked list.
 143    */
 144   struct MessageQueue *prev;
 145
 146   /**
 147    * Once this message is actively being transmitted, which
 148    * neighbour is it associated with?
 149    */
 150   struct NeighbourMapEntry *n;
 151
 152   /**
 153    * Function to call once we're done.
 154    */
 155   GST_NeighbourSendContinuation cont;
 156
 157   /**
 158    * Closure for 'cont'
 159    */
 160   void *cont_cls;
 161
 162   /**
 163    * The message(s) we want to transmit, GNUNET_MessageHeader(s)
 164    * stuck together in memory.  Allocated at the end of this struct.
 165    */
 166   const char *message_buf;
 167
 168   /**
 169    * Size of the message buf
 170    */
 171   size_t message_buf_size;
 172
 173   /**
 174    * At what time should we fail?
 175    */
 176   struct GNUNET_TIME_Absolute timeout;
 177
 178 };
 179
 180
 181 /**
 182  * Entry in neighbours.
 183  */
 184 struct NeighbourMapEntry
 185 {
 186
 187   /**
 188    * Head of list of messages we would like to send to this peer;
 189    * must contain at most one message per client.
 190    */
 191   struct MessageQueue *messages_head;
 192
 193   /**
 194    * Tail of list of messages we would like to send to this peer; must
 195    * contain at most one message per client.
 196    */
 197   struct MessageQueue *messages_tail;
 198
 199   /**
 200    * Performance data for the peer.
 201    */
 202   //struct GNUNET_ATS_Information *ats;
 203
 204   /**
 205    * Are we currently trying to send a message? If so, which one?
 206    */
 207   struct MessageQueue *is_active;
 208
 209   /**
 210    * Active session for communicating with the peer.
 211    */
 212   struct Session *session;
 213
 214   /**
 215    * Name of the plugin we currently use.
 216    */
 217   char *plugin_name;
 218
 219   /**
 220    * Address used for communicating with the peer, NULL for inbound connections.
 221    */
 222   void *addr;
 223
 224   /**
 225    * Number of bytes in 'addr'.
 226    */
 227   size_t addrlen;
 228
 229   /**
 230    * Identity of this neighbour.
 231    */
 232   struct GNUNET_PeerIdentity id;
 233
 234   /**
 235    * ID of task scheduled to run when this peer is about to
 236    * time out (will free resources associated with the peer).
 237    */
 238   GNUNET_SCHEDULER_TaskIdentifier timeout_task;
 239
 240   /**
 241    * ID of task scheduled to send keepalives.
 242    */
 243   GNUNET_SCHEDULER_TaskIdentifier keepalive_task;
 244
 245   /**
 246    * ID of task scheduled to run when we should try transmitting
 247    * the head of the message queue.
 248    */
 249   GNUNET_SCHEDULER_TaskIdentifier transmission_task;
 250
 251   /**
 252    * Tracker for inbound bandwidth.
 253    */
 254   struct GNUNET_BANDWIDTH_Tracker in_tracker;
 255
 256   /**
 257    * Timestamp of the 'SESSION_CONNECT' message we got from the other peer
 258    */
 259   struct GNUNET_TIME_Absolute connect_ts;
 260
 261   /**
 262    * How often has the other peer (recently) violated the inbound
 263    * traffic limit?  Incremented by 10 per violation, decremented by 1
 264    * per non-violation (for each time interval).
 265    */
 266   unsigned int quota_violation_count;
 267
 268   /**
 269    * Number of values in 'ats' array.
 270    */
 271   //unsigned int ats_count;
 272
 273   /**
 274    * Are we already in the process of disconnecting this neighbour?
 275    */
 276   int in_disconnect;
 277
 278   /**
 279    * Do we currently consider this neighbour connected? (as far as
 280    * the connect/disconnect callbacks are concerned)?
 281    */
 282   int is_connected;
 283
 284 };
 285
 286
 287 /**
 288  * All known neighbours and their HELLOs.
 289  */
 290 static struct GNUNET_CONTAINER_MultiHashMap *neighbours;
 291
 292 /**
 293  * Closure for connect_notify_cb and disconnect_notify_cb
 294  */
 295 static void *callback_cls;
 296
 297 /**
 298  * Function to call when we connected to a neighbour.
 299  */
 300 static GNUNET_TRANSPORT_NotifyConnect connect_notify_cb;
 301
 302 /**
 303  * Function to call when we disconnected from a neighbour.
 304  */
 305 static GNUNET_TRANSPORT_NotifyDisconnect disconnect_notify_cb;
 306
 307 /**
 308  * counter for connected neighbours
 309  */
 310 static int neighbours_connected;
 311
 312 /**
 313  * Lookup a neighbour entry in the neighbours hash map.
 314  *
 315  * @param pid identity of the peer to look up
 316  * @return the entry, NULL if there is no existing record
 317  */
 318 static struct NeighbourMapEntry *
 319 lookup_neighbour (const struct GNUNET_PeerIdentity *pid)
 320 {
 321   return GNUNET_CONTAINER_multihashmap_get (neighbours, &pid->hashPubKey);
 322 }
 323
 324
 325 /**
 326  * Task invoked to start a transmission to another peer.
 327  *
 328  * @param cls the 'struct NeighbourMapEntry'
 329  * @param tc scheduler context
 330  */
 331 static void
 332 transmission_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 333
 334
 335 /**
 336  * We're done with our transmission attempt, continue processing.
 337  *
 338  * @param cls the 'struct MessageQueue' of the message
 339  * @param receiver intended receiver
 340  * @param success whether it worked or not
 341  */
 342 static void
 343 transmit_send_continuation (void *cls,
 344                             const struct GNUNET_PeerIdentity *receiver,
 345                             int success)
 346 {
 347   struct MessageQueue *mq;
 348   struct NeighbourMapEntry *n;
 349
 350   mq = cls;
 351   n = mq->n;
 352   if (NULL != n)
 353   {
 354     GNUNET_assert (n->is_active == mq);
 355     n->is_active = NULL;
 356     GNUNET_assert (n->transmission_task == GNUNET_SCHEDULER_NO_TASK);
 357     n->transmission_task = GNUNET_SCHEDULER_add_now (&transmission_task, n);
 358   }
 359   if (NULL != mq->cont)
 360     mq->cont (mq->cont_cls, success);
 361   GNUNET_free (mq);
 362 }
 363
 364
 365 /**
 366  * Check the ready list for the given neighbour and if a plugin is
 367  * ready for transmission (and if we have a message), do so!
 368  *
 369  * @param n target peer for which to transmit
 370  */
 371 static void
 372 try_transmission_to_peer (struct NeighbourMapEntry *n)
 373 {
 374   struct MessageQueue *mq;
 375   struct GNUNET_TIME_Relative timeout;
 376   ssize_t ret;
 377   struct GNUNET_TRANSPORT_PluginFunctions *papi;
 378
 379   if (n->is_active != NULL)
 380     return;                     /* transmission already pending */
 381   if (n->transmission_task != GNUNET_SCHEDULER_NO_TASK)
 382     return;                     /* currently waiting for bandwidth */
 383   while (NULL != (mq = n->messages_head))
 384   {
 385     timeout = GNUNET_TIME_absolute_get_remaining (mq->timeout);
 386     if (timeout.rel_value > 0)
 387       break;
 388     GNUNET_CONTAINER_DLL_remove (n->messages_head, n->messages_tail, mq);
 389     n->is_active = mq;
 390     transmit_send_continuation (mq, &n->id, GNUNET_SYSERR);     /* timeout */
 391   }
 392   if (NULL == mq)
 393     return;                     /* no more messages */
 394
 395   papi = GST_plugins_find (n->plugin_name);
 396   if (papi == NULL)
 397   {
 398     GNUNET_break (0);
 399     return;
 400   }
 401   GNUNET_CONTAINER_DLL_remove (n->messages_head, n->messages_tail, mq);
 402   n->is_active = mq;
 403   mq->n = n;
 404
 405   if  (((n->session == NULL) && (n->addr == NULL) && (n->addrlen == 0)))
 406   {
 407     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "No address for peer `%s'\n",
 408                 GNUNET_i2s (&n->id));
 409     transmit_send_continuation (mq, &n->id, GNUNET_SYSERR);
 410     n->transmission_task = GNUNET_SCHEDULER_add_now (&transmission_task, n);
 411     return;
 412   }
 413
 414   ret =
 415       papi->send (papi->cls, &n->id, mq->message_buf, mq->message_buf_size,
 416                   0 /* priority -- remove from plugin API? */ ,
 417                   timeout, n->session, n->addr, n->addrlen, GNUNET_YES,
 418                   &transmit_send_continuation, mq);
 419   if (ret == -1)
 420   {
 421     /* failure, but 'send' would not call continuation in this case,
 422      * so we need to do it here! */
 423     transmit_send_continuation (mq, &n->id, GNUNET_SYSERR);
 424     n->transmission_task = GNUNET_SCHEDULER_add_now (&transmission_task, n);
 425   }
 426 }
 427
 428
 429 /**
 430  * Task invoked to start a transmission to another peer.
 431  *
 432  * @param cls the 'struct NeighbourMapEntry'
 433  * @param tc scheduler context
 434  */
 435 static void
 436 transmission_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 437 {
 438   struct NeighbourMapEntry *n = cls;
 439
 440   n->transmission_task = GNUNET_SCHEDULER_NO_TASK;
 441   try_transmission_to_peer (n);
 442 }
 443
 444
 445 /**
 446  * Initialize the neighbours subsystem.
 447  *
 448  * @param cls closure for callbacks
 449  * @param connect_cb function to call if we connect to a peer
 450  * @param disconnect_cb function to call if we disconnect from a peer
 451  */
 452 void
 453 GST_neighbours_start (void *cls, GNUNET_TRANSPORT_NotifyConnect connect_cb,
 454                       GNUNET_TRANSPORT_NotifyDisconnect disconnect_cb)
 455 {
 456   callback_cls = cls;
 457   connect_notify_cb = connect_cb;
 458   disconnect_notify_cb = disconnect_cb;
 459   neighbours = GNUNET_CONTAINER_multihashmap_create (NEIGHBOUR_TABLE_SIZE);
 460 }
 461
 462
 463 /**
 464  * Disconnect from the given neighbour, clean up the record.
 465  *
 466  * @param n neighbour to disconnect from
 467  */
 468 static void
 469 disconnect_neighbour (struct NeighbourMapEntry *n)
 470 {
 471   struct MessageQueue *mq;
 472
 473   if (GNUNET_YES == n->in_disconnect)
 474     return;
 475   n->in_disconnect = GNUNET_YES;
 476   while (NULL != (mq = n->messages_head))
 477   {
 478     GNUNET_CONTAINER_DLL_remove (n->messages_head, n->messages_tail, mq);
 479     if (NULL != mq->cont)
 480       mq->cont (mq->cont_cls, GNUNET_SYSERR);
 481     GNUNET_free (mq);
 482   }
 483   if (NULL != n->is_active)
 484   {
 485     n->is_active->n = NULL;
 486     n->is_active = NULL;
 487   }
 488   if (GNUNET_YES == n->is_connected)
 489   {
 490     n->is_connected = GNUNET_NO;
 491     GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != n->keepalive_task);
 492     GNUNET_SCHEDULER_cancel (n->keepalive_task);
 493     n->keepalive_task = GNUNET_SCHEDULER_NO_TASK;
 494     GNUNET_assert (neighbours_connected > 0);
 495     neighbours_connected--;
 496     GNUNET_STATISTICS_update (GST_stats, gettext_noop ("# peers connected"), -1,
 497                               GNUNET_NO);
 498     disconnect_notify_cb (callback_cls, &n->id);
 499   }
 500   GNUNET_assert (GNUNET_YES ==
 501                  GNUNET_CONTAINER_multihashmap_remove (neighbours,
 502                                                        &n->id.hashPubKey, n));
 503   if (GNUNET_SCHEDULER_NO_TASK != n->timeout_task)
 504   {
 505     GNUNET_SCHEDULER_cancel (n->timeout_task);
 506     n->timeout_task = GNUNET_SCHEDULER_NO_TASK;
 507   }
 508   if (GNUNET_SCHEDULER_NO_TASK != n->transmission_task)
 509   {
 510     GNUNET_SCHEDULER_cancel (n->transmission_task);
 511     n->transmission_task = GNUNET_SCHEDULER_NO_TASK;
 512   }
 513   if (NULL != n->plugin_name)
 514   {
 515     GNUNET_free (n->plugin_name);
 516     n->plugin_name = NULL;
 517   }
 518   if (NULL != n->addr)
 519   {
 520     GNUNET_free (n->addr);
 521     n->addr = NULL;
 522     n->addrlen = 0;
 523   }
 524   n->session = NULL;
 525   GNUNET_free (n);
 526 }
 527
 528
 529 /**
 530  * Peer has been idle for too long. Disconnect.
 531  *
 532  * @param cls the 'struct NeighbourMapEntry' of the neighbour that went idle
 533  * @param tc scheduler context
 534  */
 535 static void
 536 neighbour_timeout_task (void *cls,
 537                         const struct GNUNET_SCHEDULER_TaskContext *tc)
 538 {
 539   struct NeighbourMapEntry *n = cls;
 540
 541   n->timeout_task = GNUNET_SCHEDULER_NO_TASK;
 542   if (GNUNET_YES == n->is_connected)
 543     GNUNET_STATISTICS_update (GST_stats,
 544                             gettext_noop ("# peers disconnected due to timeout"), 1,
 545                             GNUNET_NO);
 546   disconnect_neighbour (n);
 547 }
 548
 549
 550 /**
 551  * Send another keepalive message.
 552  *
 553  * @param cls the 'struct NeighbourMapEntry' of the neighbour that went idle
 554  * @param tc scheduler context
 555  */
 556 static void
 557 neighbour_keepalive_task (void *cls,
 558                           const struct GNUNET_SCHEDULER_TaskContext *tc)
 559 {
 560   struct NeighbourMapEntry *n = cls;
 561   struct GNUNET_MessageHeader m;
 562   struct GNUNET_TRANSPORT_PluginFunctions *papi;
 563
 564   n->keepalive_task = GNUNET_SCHEDULER_add_delayed (KEEPALIVE_FREQUENCY,
 565                                                     &neighbour_keepalive_task,
 566                                                     n);
 567   GNUNET_assert (GNUNET_YES == n->is_connected);
 568   GNUNET_STATISTICS_update (GST_stats,
 569                             gettext_noop ("# keepalives sent"), 1,
 570                             GNUNET_NO);
 571   m.size = htons (sizeof (struct GNUNET_MessageHeader));
 572   m.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_KEEPALIVE);
 573   papi = GST_plugins_find (n->plugin_name);
 574   if (papi != NULL)
 575     papi->send (papi->cls,
 576                 &n->id, (const void *) &m,
 577                 sizeof (m),
 578                 UINT32_MAX /* priority */ ,
 579                 GNUNET_TIME_UNIT_FOREVER_REL, n->session, n->addr, n->addrlen,
 580                 GNUNET_YES, NULL, NULL);
 581 }
 582
 583
 584 /**
 585  * Disconnect from the given neighbour.
 586  *
 587  * @param cls unused
 588  * @param key hash of neighbour's public key (not used)
 589  * @param value the 'struct NeighbourMapEntry' of the neighbour
 590  */
 591 static int
 592 disconnect_all_neighbours (void *cls, const GNUNET_HashCode * key, void *value)
 593 {
 594   struct NeighbourMapEntry *n = value;
 595
 596 #if DEBUG_TRANSPORT
 597   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting peer `%4s', %s\n",
 598               GNUNET_i2s (&n->id), "SHUTDOWN_TASK");
 599 #endif
 600   if (GNUNET_YES == n->is_connected)
 601     GNUNET_STATISTICS_update (GST_stats,
 602                               gettext_noop ("# peers disconnected due to global disconnect"), 1,
 603                               GNUNET_NO);
 604   disconnect_neighbour (n);
 605   return GNUNET_OK;
 606 }
 607
 608
 609 /**
 610  * Cleanup the neighbours subsystem.
 611  */
 612 void
 613 GST_neighbours_stop ()
 614 {
 615   GNUNET_assert (neighbours != NULL);
 616
 617   GNUNET_CONTAINER_multihashmap_iterate (neighbours, &disconnect_all_neighbours,
 618                                          NULL);
 619   GNUNET_CONTAINER_multihashmap_destroy (neighbours);
 620   GNUNET_assert (neighbours_connected == 0);
 621   neighbours = NULL;
 622   callback_cls = NULL;
 623   connect_notify_cb = NULL;
 624   disconnect_notify_cb = NULL;
 625 }
 626
 627
 628 /**
 629  * We tried to send a SESSION_CONNECT message to another peer.  If this
 630  * succeeded, we should mark the peer up.  If it failed, we should tell
 631  * ATS to not use this address anymore (until it is re-validated).
 632  *
 633  * @param cls the 'struct NeighbourMapEntry'
 634  * @param success GNUNET_OK on success
 635  */
 636 static void
 637 send_connect_continuation (void *cls,
 638                            int success)
 639 {
 640   struct NeighbourMapEntry *n = cls;
 641
 642   if (GNUNET_YES == n->in_disconnect)
 643     return; /* neighbour is going away */
 644   if (GNUNET_YES != success)
 645   {
 646     GNUNET_ATS_address_destroyed (GST_ats,
 647                                   &n->id,
 648                                   n->plugin_name,
 649                                   n->addr,
 650                                   n->addrlen,
 651                                   NULL);
 652     return;
 653   }
 654 }
 655
 656
 657 /**
 658  * For an existing neighbour record, set the active connection to
 659  * the given address.
 660  *
 661  * @param peer identity of the peer to switch the address for
 662  * @param plugin_name name of transport that delivered the PONG
 663  * @param address address of the other peer, NULL if other peer
 664  *                       connected to us
 665  * @param address_len number of bytes in address
 666  * @param session session to use (or NULL)
 667  * @param ats performance data
 668  * @param ats_count number of entries in ats (excluding 0-termination)
 669  */
 670 void
 671 GST_neighbours_switch_to_address (const struct GNUNET_PeerIdentity *peer,
 672                                   const char *plugin_name, const void *address,
 673                                   size_t address_len, struct Session *session,
 674                                   const struct GNUNET_ATS_Information
 675                                   *ats, uint32_t ats_count)
 676 {
 677   struct NeighbourMapEntry *n;
 678   struct SessionConnectMessage connect_msg;
 679   int was_connected;
 680
 681   GNUNET_assert (neighbours != NULL);
 682   n = lookup_neighbour (peer);
 683   if (NULL == n)
 684   {
 685     if (NULL == session)
 686       GNUNET_ATS_address_destroyed (GST_ats,
 687                                     peer,
 688                                     plugin_name, address,
 689                                     address_len, NULL);
 690     return;
 691   }
 692   was_connected = n->is_connected;
 693   n->is_connected = GNUNET_YES;
 694   if (GNUNET_YES != was_connected)
 695     n->keepalive_task = GNUNET_SCHEDULER_add_delayed (KEEPALIVE_FREQUENCY,
 696                                                       &neighbour_keepalive_task,
 697                                                       n);
 698
 699 #if DEBUG_TRANSPORT
 700   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 701               "SWITCH! Peer `%4s' switches to plugin `%s' address '%s' session %X\n",
 702               GNUNET_i2s (peer), plugin_name,
 703               (address_len == 0) ? "<inbound>" : GST_plugins_a2s (plugin_name,
 704                                                                   address,
 705                                                                   address_len),
 706               session);
 707 #endif
 708   GNUNET_free_non_null (n->addr);
 709   n->addr = GNUNET_malloc (address_len);
 710   memcpy (n->addr, address, address_len);
 711   n->addrlen = address_len;
 712   n->session = session;
 713   GNUNET_free_non_null (n->plugin_name);
 714   n->plugin_name = GNUNET_strdup (plugin_name);
 715   GNUNET_SCHEDULER_cancel (n->timeout_task);
 716   n->timeout_task =
 717       GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
 718                                     &neighbour_timeout_task, n);
 719   connect_msg.header.size = htons (sizeof (struct SessionConnectMessage));
 720   connect_msg.header.type =
 721       htons (GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_CONNECT);
 722   connect_msg.reserved = htonl (0);
 723   connect_msg.timestamp =
 724       GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get ());
 725   GST_neighbours_send (peer, &connect_msg, sizeof (connect_msg),
 726                        GNUNET_TIME_UNIT_FOREVER_REL,
 727                        &send_connect_continuation,
 728                        n);
 729   if (GNUNET_YES == was_connected)
 730     return;
 731   /* First tell clients about connected neighbours...*/
 732   neighbours_connected++;
 733   GNUNET_STATISTICS_update (GST_stats, gettext_noop ("# peers connected"), 1,
 734                             GNUNET_NO);
 735   connect_notify_cb (callback_cls, peer, ats, ats_count);
 736 }
 737
 738
 739 /**
 740  * Create an entry in the neighbour map for the given peer
 741  *
 742  * @param peer peer to create an entry for
 743  * @return new neighbour map entry
 744  */
 745 static struct NeighbourMapEntry *
 746 setup_neighbour (const struct GNUNET_PeerIdentity *peer)
 747 {
 748   struct NeighbourMapEntry *n;
 749
 750 #if DEBUG_TRANSPORT
 751   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 752               "Unknown peer `%s', creating new neighbour\n",
 753               GNUNET_i2s (peer));
 754 #endif
 755   n = GNUNET_malloc (sizeof (struct NeighbourMapEntry));
 756   n->id = *peer;
 757   GNUNET_BANDWIDTH_tracker_init (&n->in_tracker,
 758                                  GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT,
 759                                  MAX_BANDWIDTH_CARRY_S);
 760   n->timeout_task =
 761     GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
 762                                   &neighbour_timeout_task, n);
 763   GNUNET_assert (GNUNET_OK ==
 764                  GNUNET_CONTAINER_multihashmap_put (neighbours,
 765                                                     &n->id.hashPubKey, n,
 766                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 767   return n;
 768 }
 769
 770
 771 /**
 772  * Try to create a connection to the given target (eventually).
 773  *
 774  * @param target peer to try to connect to
 775  */
 776 void
 777 GST_neighbours_try_connect (const struct GNUNET_PeerIdentity *target)
 778 {
 779   struct NeighbourMapEntry *n;
 780
 781   GNUNET_assert (neighbours != NULL);
 782 #if DEBUG_TRANSPORT
 783   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Trying to connect to peer `%s'\n",
 784               GNUNET_i2s (target));
 785 #endif
 786   GNUNET_assert (0 !=
 787                  memcmp (target, &GST_my_identity,
 788                          sizeof (struct GNUNET_PeerIdentity)));
 789   n = lookup_neighbour (target);
 790   if ((NULL != n) && (GNUNET_YES == n->is_connected))
 791     return;                     /* already connected */
 792   if (n == NULL)
 793     n = setup_neighbour (target);
 794 #if DEBUG_TRANSPORT
 795   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 796               "Asking ATS for suggested address to connect to peer `%s'\n",
 797               GNUNET_i2s (&n->id));
 798 #endif
 799    GNUNET_ATS_suggest_address (GST_ats, &n->id);
 800 }
 801
 802
 803 /**
 804  * Test if we're connected to the given peer.
 805  *
 806  * @param target peer to test
 807  * @return GNUNET_YES if we are connected, GNUNET_NO if not
 808  */
 809 int
 810 GST_neighbours_test_connected (const struct GNUNET_PeerIdentity *target)
 811 {
 812   struct NeighbourMapEntry *n;
 813
 814   GNUNET_assert (neighbours != NULL);
 815
 816   n = lookup_neighbour (target);
 817   if ((NULL == n) || (n->is_connected != GNUNET_YES))
 818     return GNUNET_NO;           /* not connected */
 819   return GNUNET_YES;
 820 }
 821
 822
 823 /**
 824  * A session was terminated. Take note.
 825  *
 826  * @param peer identity of the peer where the session died
 827  * @param session session that is gone
 828  */
 829 void
 830 GST_neighbours_session_terminated (const struct GNUNET_PeerIdentity *peer,
 831                                    struct Session *session)
 832 {
 833   struct NeighbourMapEntry *n;
 834
 835   GNUNET_assert (neighbours != NULL);
 836
 837 #if DEBUG_TRANSPORT
 838   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 839               "Session %X to peer `%s' ended \n",
 840               session, GNUNET_i2s (peer));
 841 #endif
 842   n = lookup_neighbour (peer);
 843   if (NULL == n)
 844     return;
 845   if (session != n->session)
 846     return;                     /* doesn't affect us */
 847
 848   n->session = NULL;
 849   GNUNET_free (n->addr);
 850   n->addr = NULL;
 851   n->addrlen = 0;
 852
 853
 854   if (GNUNET_YES != n->is_connected)
 855     return;                     /* not connected anymore anyway, shouldn't matter */
 856   /* fast disconnect unless ATS suggests a new address */
 857   GNUNET_SCHEDULER_cancel (n->timeout_task);
 858   n->timeout_task =
 859       GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_DISCONNECT_SESSION_TIMEOUT,
 860                                     &neighbour_timeout_task, n);
 861   /* try QUICKLY to re-establish a connection, reduce timeout! */
 862   GNUNET_ATS_suggest_address (GST_ats, peer);
 863 }
 864
 865
 866 /**
 867  * Transmit a message to the given target using the active connection.
 868  *
 869  * @param target destination
 870  * @param msg message to send
 871  * @param msg_size number of bytes in msg
 872  * @param timeout when to fail with timeout
 873  * @param cont function to call when done
 874  * @param cont_cls closure for 'cont'
 875  */
 876 void
 877 GST_neighbours_send (const struct GNUNET_PeerIdentity *target, const void *msg,
 878                      size_t msg_size, struct GNUNET_TIME_Relative timeout,
 879                      GST_NeighbourSendContinuation cont, void *cont_cls)
 880 {
 881   struct NeighbourMapEntry *n;
 882   struct MessageQueue *mq;
 883
 884   GNUNET_assert (neighbours != NULL);
 885
 886   n = lookup_neighbour (target);
 887   if ((n == NULL) || (GNUNET_YES != n->is_connected))
 888   {
 889     GNUNET_STATISTICS_update (GST_stats,
 890                               gettext_noop
 891                               ("# messages not sent (no such peer or not connected)"),
 892                               1, GNUNET_NO);
 893 #if DEBUG_TRANSPORT
 894     if (n == NULL)
 895       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 896                   "Could not send message to peer `%s': unknown neighbor",
 897                   GNUNET_i2s (target));
 898     else if (GNUNET_YES != n->is_connected)
 899       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 900                   "Could not send message to peer `%s': not connected\n",
 901                   GNUNET_i2s (target));
 902 #endif
 903     if (NULL != cont)
 904       cont (cont_cls, GNUNET_SYSERR);
 905     return;
 906   }
 907
 908   if ((n->session == NULL) && (n->addr == NULL) && (n->addrlen ==0))
 909   {
 910     GNUNET_STATISTICS_update (GST_stats,
 911                               gettext_noop
 912                               ("# messages not sent (no such peer or not connected)"),
 913                               1, GNUNET_NO);
 914 #if DEBUG_TRANSPORT
 915       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 916                   "Could not send message to peer `%s': no address available\n",
 917                   GNUNET_i2s (target));
 918 #endif
 919
 920     if (NULL != cont)
 921       cont (cont_cls, GNUNET_SYSERR);
 922     return;
 923   }
 924   GNUNET_assert (msg_size >= sizeof (struct GNUNET_MessageHeader));
 925   GNUNET_STATISTICS_update (GST_stats,
 926                             gettext_noop
 927                             ("# bytes in message queue for other peers"),
 928                             msg_size, GNUNET_NO);
 929   mq = GNUNET_malloc (sizeof (struct MessageQueue) + msg_size);
 930   mq->cont = cont;
 931   mq->cont_cls = cont_cls;
 932   /* FIXME: this memcpy can be up to 7% of our total runtime! */
 933   memcpy (&mq[1], msg, msg_size);
 934   mq->message_buf = (const char *) &mq[1];
 935   mq->message_buf_size = msg_size;
 936   mq->timeout = GNUNET_TIME_relative_to_absolute (timeout);
 937   GNUNET_CONTAINER_DLL_insert_tail (n->messages_head, n->messages_tail, mq);
 938   if ((GNUNET_SCHEDULER_NO_TASK == n->transmission_task) &&
 939       (NULL == n->is_active))
 940     n->transmission_task = GNUNET_SCHEDULER_add_now (&transmission_task, n);
 941 }
 942
 943
 944 /**
 945  * We have received a message from the given sender.  How long should
 946  * we delay before receiving more?  (Also used to keep the peer marked
 947  * as live).
 948  *
 949  * @param sender sender of the message
 950  * @param size size of the message
 951  * @param do_forward set to GNUNET_YES if the message should be forwarded to clients
 952  *                   GNUNET_NO if the neighbour is not connected or violates the quota,
 953  *                   GNUNET_SYSERR if the connection is not fully up yet
 954  * @return how long to wait before reading more from this sender
 955  */
 956 struct GNUNET_TIME_Relative
 957 GST_neighbours_calculate_receive_delay (const struct GNUNET_PeerIdentity
 958                                         *sender, ssize_t size, int *do_forward)
 959 {
 960   struct NeighbourMapEntry *n;
 961   struct GNUNET_TIME_Relative ret;
 962
 963   GNUNET_assert (neighbours != NULL);
 964
 965   n = lookup_neighbour (sender);
 966   if (n == NULL)
 967   {
 968     *do_forward = GNUNET_NO;
 969     return GNUNET_TIME_UNIT_ZERO;
 970   }
 971   if (GNUNET_YES != n->is_connected)
 972   {
 973     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 974                 _("Plugin gave us %d bytes of data but somehow the session is not marked as UP yet!\n"),
 975                 (int) size);
 976     *do_forward = GNUNET_SYSERR;
 977     return GNUNET_TIME_UNIT_ZERO;
 978   }
 979   if (GNUNET_YES == GNUNET_BANDWIDTH_tracker_consume (&n->in_tracker, size))
 980   {
 981     n->quota_violation_count++;
 982 #if DEBUG_TRANSPORT
 983     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 984                 "Bandwidth quota (%u b/s) violation detected (total of %u).\n",
 985                 n->in_tracker.available_bytes_per_s__,
 986                 n->quota_violation_count);
 987 #endif
 988     /* Discount 32k per violation */
 989     GNUNET_BANDWIDTH_tracker_consume (&n->in_tracker, -32 * 1024);
 990   }
 991   else
 992   {
 993     if (n->quota_violation_count > 0)
 994     {
 995       /* try to add 32k back */
 996       GNUNET_BANDWIDTH_tracker_consume (&n->in_tracker, 32 * 1024);
 997       n->quota_violation_count--;
 998     }
 999   }
1000   if (n->quota_violation_count > QUOTA_VIOLATION_DROP_THRESHOLD)
1001   {
1002     GNUNET_STATISTICS_update (GST_stats,
1003                               gettext_noop
1004                               ("# bandwidth quota violations by other peers"),
1005                               1, GNUNET_NO);
1006     *do_forward = GNUNET_NO;
1007     return GNUNET_CONSTANTS_QUOTA_VIOLATION_TIMEOUT;
1008   }
1009   *do_forward = GNUNET_YES;
1010   ret = GNUNET_BANDWIDTH_tracker_get_delay (&n->in_tracker, 0);
1011   if (ret.rel_value > 0)
1012   {
1013 #if DEBUG_TRANSPORT
1014     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1015                 "Throttling read (%llu bytes excess at %u b/s), waiting %llu ms before reading more.\n",
1016                 (unsigned long long) n->in_tracker.
1017                 consumption_since_last_update__,
1018                 (unsigned int) n->in_tracker.available_bytes_per_s__,
1019                 (unsigned long long) ret.rel_value);
1020 #endif
1021     GNUNET_STATISTICS_update (GST_stats,
1022                               gettext_noop ("# ms throttling suggested"),
1023                               (int64_t) ret.rel_value, GNUNET_NO);
1024   }
1025   return ret;
1026 }
1027
1028
1029 /**
1030  * Keep the connection to the given neighbour alive longer,
1031  * we received a KEEPALIVE (or equivalent).
1032  *
1033  * @param neighbour neighbour to keep alive
1034  */
1035 void
1036 GST_neighbours_keepalive (const struct GNUNET_PeerIdentity *neighbour)
1037 {
1038   struct NeighbourMapEntry *n;
1039
1040   GNUNET_assert (neighbours != NULL);
1041
1042   n = lookup_neighbour (neighbour);
1043   if (NULL == n)
1044   {
1045     GNUNET_STATISTICS_update (GST_stats,
1046                               gettext_noop
1047                               ("# KEEPALIVE messages discarded (not connected)"),
1048                               1, GNUNET_NO);
1049     return;
1050   }
1051   GNUNET_SCHEDULER_cancel (n->timeout_task);
1052   n->timeout_task =
1053       GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
1054                                     &neighbour_timeout_task, n);
1055 }
1056
1057
1058 /**
1059  * Change the incoming quota for the given peer.
1060  *
1061  * @param neighbour identity of peer to change qutoa for
1062  * @param quota new quota
1063  */
1064 void
1065 GST_neighbours_set_incoming_quota (const struct GNUNET_PeerIdentity *neighbour,
1066                                    struct GNUNET_BANDWIDTH_Value32NBO quota)
1067 {
1068   struct NeighbourMapEntry *n;
1069
1070   GNUNET_assert (neighbours != NULL);
1071
1072   n = lookup_neighbour (neighbour);
1073   if (n == NULL)
1074   {
1075     GNUNET_STATISTICS_update (GST_stats,
1076                               gettext_noop
1077                               ("# SET QUOTA messages ignored (no such peer)"),
1078                               1, GNUNET_NO);
1079     return;
1080   }
1081   GNUNET_BANDWIDTH_tracker_update_quota (&n->in_tracker, quota);
1082   if (0 != ntohl (quota.value__))
1083     return;
1084 #if DEBUG_TRANSPORT
1085   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting peer `%4s' due to `%s'\n",
1086               GNUNET_i2s (&n->id), "SET_QUOTA");
1087 #endif
1088   if (GNUNET_YES == n->is_connected)
1089     GNUNET_STATISTICS_update (GST_stats,
1090                               gettext_noop ("# disconnects due to quota of 0"), 1,
1091                               GNUNET_NO);
1092   disconnect_neighbour (n);
1093 }
1094
1095
1096 /**
1097  * Closure for the neighbours_iterate function.
1098  */
1099 struct IteratorContext
1100 {
1101   /**
1102    * Function to call on each connected neighbour.
1103    */
1104   GST_NeighbourIterator cb;
1105
1106   /**
1107    * Closure for 'cb'.
1108    */
1109   void *cb_cls;
1110 };
1111
1112
1113 /**
1114  * Call the callback from the closure for each connected neighbour.
1115  *
1116  * @param cls the 'struct IteratorContext'
1117  * @param key the hash of the public key of the neighbour
1118  * @param value the 'struct NeighbourMapEntry'
1119  * @return GNUNET_OK (continue to iterate)
1120  */
1121 static int
1122 neighbours_iterate (void *cls, const GNUNET_HashCode * key, void *value)
1123 {
1124   struct IteratorContext *ic = cls;
1125   struct NeighbourMapEntry *n = value;
1126
1127   if (GNUNET_YES != n->is_connected)
1128     return GNUNET_OK;
1129
1130   ic->cb (ic->cb_cls, &n->id, NULL, 0, n->plugin_name, n->addr, n->addrlen);
1131   return GNUNET_OK;
1132 }
1133
1134
1135 /**
1136  * Iterate over all connected neighbours.
1137  *
1138  * @param cb function to call
1139  * @param cb_cls closure for cb
1140  */
1141 void
1142 GST_neighbours_iterate (GST_NeighbourIterator cb, void *cb_cls)
1143 {
1144   struct IteratorContext ic;
1145
1146   GNUNET_assert (neighbours != NULL);
1147
1148   ic.cb = cb;
1149   ic.cb_cls = cb_cls;
1150   GNUNET_CONTAINER_multihashmap_iterate (neighbours, &neighbours_iterate, &ic);
1151 }
1152
1153
1154 /**
1155  * If we have an active connection to the given target, it must be shutdown.
1156  *
1157  * @param target peer to disconnect from
1158  */
1159 void
1160 GST_neighbours_force_disconnect (const struct GNUNET_PeerIdentity *target)
1161 {
1162   struct NeighbourMapEntry *n;
1163   struct GNUNET_TRANSPORT_PluginFunctions *papi;
1164   struct SessionDisconnectMessage disconnect_msg;
1165
1166   GNUNET_assert (neighbours != NULL);
1167
1168   n = lookup_neighbour (target);
1169   if (NULL == n)
1170     return;                     /* not active */
1171   if (GNUNET_YES == n->is_connected)
1172   {
1173     /* we're actually connected, send DISCONNECT message */
1174     disconnect_msg.header.size = htons (sizeof (struct SessionDisconnectMessage));
1175     disconnect_msg.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT);
1176     disconnect_msg.reserved = htonl (0);
1177     disconnect_msg.purpose.size = htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
1178                                          sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) +
1179                                          sizeof (struct GNUNET_TIME_AbsoluteNBO) );
1180     disconnect_msg.purpose.purpose = htonl (GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_DISCONNECT);
1181     disconnect_msg.timestamp = GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get ());
1182     disconnect_msg.public_key = GST_my_public_key;
1183     GNUNET_assert (GNUNET_OK ==
1184                    GNUNET_CRYPTO_rsa_sign (GST_my_private_key,
1185                                            &disconnect_msg.purpose,
1186                                            &disconnect_msg.signature));
1187     papi = GST_plugins_find (n->plugin_name);
1188     if (papi != NULL)
1189       papi->send (papi->cls, target, (const void *) &disconnect_msg,
1190                   sizeof (disconnect_msg),
1191                   UINT32_MAX /* priority */ ,
1192                   GNUNET_TIME_UNIT_FOREVER_REL, n->session, n->addr, n->addrlen,
1193                   GNUNET_YES, NULL, NULL);
1194     GNUNET_STATISTICS_update (GST_stats,
1195                               gettext_noop ("# peers disconnected due to external request"), 1,
1196                               GNUNET_NO);
1197     n = lookup_neighbour (target);
1198     if (NULL == n)
1199       return;                     /* gone already */
1200   }
1201   disconnect_neighbour (n);
1202 }
1203
1204
1205 /**
1206  * We received a disconnect message from the given peer,
1207  * validate and process.
1208  *
1209  * @param peer sender of the message
1210  * @param msg the disconnect message
1211  */
1212 void
1213 GST_neighbours_handle_disconnect_message (const struct GNUNET_PeerIdentity *peer,
1214                                           const struct GNUNET_MessageHeader *msg)
1215 {
1216   struct NeighbourMapEntry *n;
1217   const struct SessionDisconnectMessage *sdm;
1218   GNUNET_HashCode hc;
1219
1220   if (ntohs (msg->size) != sizeof (struct SessionDisconnectMessage))
1221   {
1222     // GNUNET_break_op (0);
1223     GNUNET_STATISTICS_update (GST_stats,
1224                               gettext_noop ("# disconnect messages ignored (old format)"), 1,
1225                               GNUNET_NO);
1226     return;
1227   }
1228   sdm = (const struct SessionDisconnectMessage* ) msg;
1229   n = lookup_neighbour (peer);
1230   if (NULL == n)
1231     return;                     /* gone already */
1232   if (GNUNET_TIME_absolute_ntoh (sdm->timestamp).abs_value <=
1233       n->connect_ts.abs_value)
1234   {
1235     GNUNET_STATISTICS_update (GST_stats,
1236                               gettext_noop ("# disconnect messages ignored (timestamp)"), 1,
1237                               GNUNET_NO);
1238     return;
1239   }
1240   GNUNET_CRYPTO_hash (&sdm->public_key,
1241                       sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
1242                       &hc);
1243   if (0 != memcmp (peer,
1244                    &hc,
1245                    sizeof (struct GNUNET_PeerIdentity)))
1246   {
1247     GNUNET_break_op (0);
1248     return;
1249   }
1250   if (ntohl (sdm->purpose.size) !=
1251       sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
1252       sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) +
1253       sizeof (struct GNUNET_TIME_AbsoluteNBO))
1254   {
1255     GNUNET_break_op (0);
1256     return;
1257   }
1258   if (GNUNET_OK !=
1259       GNUNET_CRYPTO_rsa_verify (GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_DISCONNECT,
1260                                 &sdm->purpose,
1261                                 &sdm->signature,
1262                                 &sdm->public_key))
1263   {
1264     GNUNET_break_op (0);
1265     return;
1266   }
1267   GST_neighbours_force_disconnect (peer);
1268 }
1269
1270
1271 /**
1272  * We received a 'SESSION_CONNECT' message from the other peer.
1273  * Consider switching to it.
1274  *
1275  * @param message possibly a 'struct SessionConnectMessage' (check format)
1276  * @param peer identity of the peer to switch the address for
1277  * @param plugin_name name of transport that delivered the PONG
1278  * @param address address of the other peer, NULL if other peer
1279  *                       connected to us
1280  * @param address_len number of bytes in address
1281  * @param session session to use (or NULL)
1282  * @param ats performance data
1283  * @param ats_count number of entries in ats (excluding 0-termination)
1284   */
1285 void
1286 GST_neighbours_handle_connect (const struct GNUNET_MessageHeader *message,
1287                                const struct GNUNET_PeerIdentity *peer,
1288                                const char *plugin_name,
1289                                const char *sender_address, uint16_t sender_address_len,
1290                                struct Session *session,
1291                                const struct GNUNET_ATS_Information *ats,
1292                                uint32_t ats_count)
1293 {
1294   const struct SessionConnectMessage *scm;
1295   struct GNUNET_TIME_Absolute ts;
1296   struct NeighbourMapEntry *n;
1297
1298   if (ntohs (message->size) != sizeof (struct SessionConnectMessage))
1299   {
1300     GNUNET_break_op (0);
1301     return;
1302   }
1303   scm = (const struct SessionConnectMessage *) message;
1304   GNUNET_break_op (ntohl (scm->reserved) == 0);
1305   ts = GNUNET_TIME_absolute_ntoh (scm->timestamp);
1306   n = lookup_neighbour (peer);
1307   if (NULL == n)
1308     n = setup_neighbour (peer);
1309   if (ts.abs_value > n->connect_ts.abs_value)
1310   {
1311     if (NULL != session)
1312       GNUNET_log_from (GNUNET_ERROR_TYPE_INFO | GNUNET_ERROR_TYPE_BULK,
1313                        "transport-ats",
1314                        "Giving ATS session %p of plugin %s for peer %s\n",
1315                        session,
1316                        plugin_name,
1317                        GNUNET_i2s (peer));
1318     GNUNET_ATS_address_update (GST_ats,
1319                                peer,
1320                                plugin_name, sender_address, sender_address_len,
1321                                session, ats, ats_count);
1322     n->connect_ts = ts;
1323   }
1324 }
1325
1326
1327 /* end of file gnunet-service-transport_neighbours.c */