src/testbed/gnunet-service-testbed_oc.c

   1 /*
   2   This file is part of GNUnet.
   3   (C) 2012 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 2, 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 testbed/gnunet-service-testbed_oc.c
  23  * @brief code for handling overlay connect operations
  24  * @author Sree Harsha Totakura
  25  */
  26
  27 #include "gnunet-service-testbed.h"
  28
  29 /**
  30  * Redefine LOG with a changed log component string
  31  */
  32 #ifdef LOG
  33 #undef LOG
  34 #endif
  35 #define LOG(kind,...)                                   \
  36   GNUNET_log_from (kind, "testbed-OC", __VA_ARGS__)
  37
  38
  39 /**
  40  * Context information for requesting TRANSPORT to connect to a peer
  41  */
  42 struct TryConnectContext
  43 {
  44   /**
  45    * The identity of the peer to which the transport has to attempt a connection
  46    */
  47   struct GNUNET_PeerIdentity *pid;
  48
  49   /**
  50    * The transport handle obtained from cache. Do NOT close/disconnect.
  51    */
  52   struct GNUNET_TRANSPORT_Handle *th_;
  53
  54   /**
  55    * The GetCacheHandle for the p1th transport handle
  56    */
  57   struct GSTCacheGetHandle *cgh_th;
  58
  59   /**
  60    * the try connect handle
  61    */
  62   struct GNUNET_TRANSPORT_TryConnectHandle *tch;
  63
  64   /**
  65    * The task handle
  66    */
  67   GNUNET_SCHEDULER_TaskIdentifier task;
  68
  69   /**
  70    * The id of the operation which is resposible for this context
  71    */
  72   uint64_t op_id;
  73
  74   /**
  75    * The number of times we attempted to connect
  76    */
  77   unsigned int retries;
  78
  79 };
  80
  81
  82 /**
  83  * Context information for connecting 2 peers in overlay.
  84  */
  85 struct OverlayConnectContext
  86 {
  87   /**
  88    * The next pointer for maintaining a DLL of all OverlayConnectContexts
  89    */
  90   struct OverlayConnectContext *next;
  91
  92   /**
  93    * The prev pointer for maintaining a DLL of all OverlayConnectContexts
  94    */
  95   struct OverlayConnectContext *prev;
  96
  97   /**
  98    * The client which has requested for overlay connection. This is used to send
  99    * either a success of failure message
 100    */
 101   struct GNUNET_SERVER_Client *client;
 102
 103   /**
 104    * the first peer which is to expect an overlay connection from the second peer.
 105    */
 106   struct Peer *peer;
 107
 108   /**
 109    * Transport handle of the first peer obtained from cache to get its HELLO. Do
 110    * NOT close/disconnect.
 111    */
 112   struct GNUNET_TRANSPORT_Handle *p1th_;
 113
 114   /**
 115    * The CacheGetHandle for the p1th transport handle
 116    */
 117   struct GSTCacheGetHandle *cgh_p1th;
 118
 119   /**
 120    * The GetCacheHandle for registering callback to notify CORE level peer
 121    * connects and to get our identity.
 122    */
 123   struct GSTCacheGetHandle *cgh_ch;
 124
 125   /**
 126    * HELLO of the first peer.  This should be sent to the second peer.
 127    */
 128   struct GNUNET_MessageHeader *hello;
 129
 130   /**
 131    * Get GetHelloHandle to acquire a HELLO of the first peer
 132    */
 133   struct GNUNET_TRANSPORT_GetHelloHandle *ghh;
 134
 135   /**
 136    * The handle for offering the HELLO of the first peer to the second
 137    * peer. This is only used if the second peer is a local peer.
 138    */
 139   struct GNUNET_TRANSPORT_OfferHelloHandle *ohh;
 140
 141   /**
 142    * The error message we send if this overlay connect operation has timed out
 143    */
 144   char *emsg;
 145
 146   /**
 147    * Operation context for the suboperation we start to get the identity of the
 148    * second peer if it is a remote peer
 149    */
 150   struct OperationContext *opc;
 151
 152   /**
 153    * Controller of peer 2; NULL if the peer is a local peer
 154    */
 155   struct GNUNET_TESTBED_Controller *peer2_controller;
 156
 157   /**
 158    * The transport TryConnectContext. This will be NULL if the second peer is a
 159    * remote peer
 160    */
 161   struct TryConnectContext tcc;
 162
 163   /**
 164    * The peer identity of the first peer
 165    */
 166   struct GNUNET_PeerIdentity peer_identity;
 167
 168   /**
 169    * The peer identity of the other peer
 170    */
 171   struct GNUNET_PeerIdentity other_peer_identity;
 172
 173   /**
 174    * The id of the operation responsible for creating this context
 175    */
 176   uint64_t op_id;
 177
 178   /**
 179    * The id of the task for sending HELLO of peer 2 to peer 1 and ask peer 1 to
 180    * connect to peer 2
 181    */
 182   GNUNET_SCHEDULER_TaskIdentifier send_hello_task;
 183
 184   /**
 185    * The id of the overlay connect timeout task
 186    */
 187   GNUNET_SCHEDULER_TaskIdentifier timeout_task;
 188
 189   /**
 190    * The id of the cleanup task
 191    */
 192   GNUNET_SCHEDULER_TaskIdentifier cleanup_task;
 193
 194   /**
 195    * The id of the second peer which is has to connect to the first peer
 196    */
 197   uint32_t other_peer_id;
 198
 199 };
 200
 201
 202 /**
 203  * Context information for remote overlay connect operations.  Remote overlay
 204  * connections are used when peers A and B reside on different hosts.  In these
 205  * operations the host controller for peer B is asked by the host controller of
 206  * peer A to make peer B connect to peer A by sending the controller of peer B
 207  * the HELLO of peer A.
 208  */
 209 struct RemoteOverlayConnectCtx
 210 {
 211   /**
 212    * the next pointer for DLL
 213    */
 214   struct RemoteOverlayConnectCtx *next;
 215
 216   /**
 217    * the prev pointer for DLL
 218    */
 219   struct RemoteOverlayConnectCtx *prev;
 220
 221   /**
 222    * The peer handle of peer B
 223    */
 224   struct Peer *peer;
 225
 226   /**
 227    * Peer A's HELLO
 228    */
 229   struct GNUNET_MessageHeader *hello;
 230
 231   /**
 232    * The handle for offering HELLO
 233    */
 234   struct GNUNET_TRANSPORT_OfferHelloHandle *ohh;
 235
 236   /**
 237    * The transport try connect context
 238    */
 239   struct TryConnectContext tcc;
 240
 241   /**
 242    * The peer identity of peer A
 243    */
 244   struct GNUNET_PeerIdentity a_id;
 245
 246   /**
 247    * Task for offering HELLO of A to B and doing try_connect
 248    */
 249   GNUNET_SCHEDULER_TaskIdentifier attempt_connect_task_id;
 250
 251   /**
 252    * Task to timeout RequestOverlayConnect
 253    */
 254   GNUNET_SCHEDULER_TaskIdentifier timeout_rocc_task_id;
 255
 256   /**
 257    * The id of the operation responsible for creating this context
 258    */
 259   uint64_t op_id;
 260 };
 261
 262
 263 /**
 264  * DLL head for OverlayConnectContext DLL - to be used to clean up during shutdown
 265  */
 266 static struct OverlayConnectContext *occq_head;
 267
 268 /**
 269  * DLL tail for OverlayConnectContext DLL
 270  */
 271 static struct OverlayConnectContext *occq_tail;
 272
 273 /**
 274  * DLL head for RequectOverlayConnectContext DLL - to be used to clean up during
 275  * shutdown
 276  */
 277 static struct RemoteOverlayConnectCtx *roccq_head;
 278
 279 /**
 280  * DLL tail for RequectOverlayConnectContext DLL
 281  */
 282 static struct RemoteOverlayConnectCtx *roccq_tail;
 283
 284
 285 /**
 286  * Cleans up ForwardedOverlayConnectContext
 287  *
 288  * @param focc the ForwardedOverlayConnectContext to cleanup
 289  */
 290 void
 291 GST_cleanup_focc (struct ForwardedOverlayConnectContext *focc)
 292 {
 293   GNUNET_free_non_null (focc->orig_msg);
 294   GNUNET_free (focc);
 295 }
 296
 297
 298 /**
 299  * Timeout task for cancelling a forwarded overlay connect connect
 300  *
 301  * @param cls the ForwardedOverlayConnectContext
 302  * @param tc the task context from the scheduler
 303  */
 304 static void
 305 forwarded_overlay_connect_timeout (void *cls,
 306                                    const struct GNUNET_SCHEDULER_TaskContext
 307                                    *tc)
 308 {
 309   struct ForwardedOperationContext *fopc = cls;
 310   struct RegisteredHostContext *rhc;
 311   struct ForwardedOverlayConnectContext *focc;
 312
 313   rhc = fopc->cls;
 314   focc = rhc->focc_dll_head;
 315   GNUNET_CONTAINER_DLL_remove (rhc->focc_dll_head, rhc->focc_dll_tail, focc);
 316   GST_cleanup_focc (focc);
 317   LOG_DEBUG ("Overlay linking between peers %u and %u failed\n", focc->peer1,
 318              focc->peer2);
 319   GST_forwarded_operation_timeout (cls, tc);
 320   if (NULL != rhc->focc_dll_head)
 321     GST_process_next_focc (rhc);
 322 }
 323
 324
 325 /**
 326  * Callback to be called when forwarded overlay connection operation has a reply
 327  * from the sub-controller successfull. We have to relay the reply msg back to
 328  * the client
 329  *
 330  * @param cls ForwardedOperationContext
 331  * @param msg the peer create success message
 332  */
 333 static void
 334 forwarded_overlay_connect_listener (void *cls,
 335                                     const struct GNUNET_MessageHeader *msg)
 336 {
 337   struct ForwardedOperationContext *fopc = cls;
 338   struct RegisteredHostContext *rhc;
 339   struct ForwardedOverlayConnectContext *focc;
 340
 341   rhc = fopc->cls;
 342   GST_forwarded_operation_reply_relay (cls, msg);
 343   focc = rhc->focc_dll_head;
 344   GNUNET_CONTAINER_DLL_remove (rhc->focc_dll_head, rhc->focc_dll_tail, focc);
 345   GST_cleanup_focc (focc);
 346   if (NULL != rhc->focc_dll_head)
 347     GST_process_next_focc (rhc);
 348 }
 349
 350
 351 /**
 352  * Processes a forwarded overlay connect context in the queue of the given RegisteredHostContext
 353  *
 354  * @param rhc the RegisteredHostContext
 355  */
 356 void
 357 GST_process_next_focc (struct RegisteredHostContext *rhc)
 358 {
 359   struct ForwardedOperationContext *fopc;
 360   struct ForwardedOverlayConnectContext *focc;
 361
 362   focc = rhc->focc_dll_head;
 363   GNUNET_assert (NULL != focc);
 364   GNUNET_assert (RHC_OL_CONNECT == rhc->state);
 365   fopc = GNUNET_malloc (sizeof (struct ForwardedOperationContext));
 366   GNUNET_SERVER_client_keep (rhc->client);
 367   fopc->client = rhc->client;
 368   fopc->operation_id = focc->operation_id;
 369   fopc->cls = rhc;
 370   fopc->type = OP_OVERLAY_CONNECT;
 371   fopc->opc =
 372       GNUNET_TESTBED_forward_operation_msg_ (rhc->gateway->controller,
 373                                              focc->operation_id, focc->orig_msg,
 374                                              &forwarded_overlay_connect_listener,
 375                                              fopc);
 376   GNUNET_free (focc->orig_msg);
 377   focc->orig_msg = NULL;
 378   fopc->timeout_task =
 379       GNUNET_SCHEDULER_add_delayed (GST_timeout, &forwarded_overlay_connect_timeout,
 380                                     fopc);
 381   GNUNET_CONTAINER_DLL_insert_tail (fopcq_head, fopcq_tail, fopc);
 382 }
 383
 384
 385 /**
 386  * Cleanup overlay connect context structure
 387  *
 388  * @param occ the overlay connect context
 389  */
 390 static void
 391 cleanup_occ (struct OverlayConnectContext *occ)
 392 {
 393   struct Peer *other_peer;
 394
 395   LOG_DEBUG ("0x%llx: Cleaning up occ\n", occ->op_id);
 396   GNUNET_free_non_null (occ->emsg);
 397   GNUNET_free_non_null (occ->hello);
 398   GNUNET_SERVER_client_drop (occ->client);
 399   if (NULL != occ->opc)
 400     GNUNET_TESTBED_forward_operation_msg_cancel_ (occ->opc);
 401   if (GNUNET_SCHEDULER_NO_TASK != occ->send_hello_task)
 402     GNUNET_SCHEDULER_cancel (occ->send_hello_task);
 403   if (GNUNET_SCHEDULER_NO_TASK != occ->cleanup_task)
 404     GNUNET_SCHEDULER_cancel (occ->cleanup_task);
 405   if (GNUNET_SCHEDULER_NO_TASK != occ->timeout_task)
 406     GNUNET_SCHEDULER_cancel (occ->timeout_task);
 407   if (NULL != occ->cgh_ch)
 408     GST_cache_get_handle_done (occ->cgh_ch);
 409   if (NULL != occ->ghh)
 410     GNUNET_TRANSPORT_get_hello_cancel (occ->ghh);
 411   if (NULL != occ->ohh)
 412     GNUNET_TRANSPORT_offer_hello_cancel (occ->ohh);
 413   if (GNUNET_SCHEDULER_NO_TASK != occ->tcc.task)
 414     GNUNET_SCHEDULER_cancel (occ->tcc.task);
 415   if (NULL != occ->tcc.tch)
 416     GNUNET_TRANSPORT_try_connect_cancel (occ->tcc.tch);
 417   if (NULL != occ->cgh_p1th)
 418     GST_cache_get_handle_done (occ->cgh_p1th);
 419   if (NULL != occ->tcc.cgh_th)
 420     GST_cache_get_handle_done (occ->tcc.cgh_th);
 421   GNUNET_assert (NULL != GST_peer_list);
 422   GNUNET_assert (occ->peer->reference_cnt > 0);
 423   occ->peer->reference_cnt--;
 424   if ( (GNUNET_YES == occ->peer->destroy_flag) &&
 425        (0 == occ->peer->reference_cnt) )
 426     GST_destroy_peer (occ->peer);
 427   if (NULL == occ->peer2_controller)
 428   {
 429     other_peer = GST_peer_list[occ->other_peer_id];
 430     GNUNET_assert (NULL != other_peer);
 431     GNUNET_assert (other_peer->reference_cnt > 0);
 432     other_peer->reference_cnt--;
 433     if ( (GNUNET_YES == other_peer->destroy_flag) &&
 434          (0 == other_peer->reference_cnt) )
 435       GST_destroy_peer (other_peer);
 436   }
 437   GNUNET_CONTAINER_DLL_remove (occq_head, occq_tail, occ);
 438   GNUNET_free (occ);
 439 }
 440
 441
 442 /**
 443  * Task for cleaing up overlay connect context structure
 444  *
 445  * @param cls the overlay connect context
 446  * @param tc the task context
 447  */
 448 static void
 449 do_cleanup_occ (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 450 {
 451   struct OverlayConnectContext *occ = cls;
 452
 453   occ->cleanup_task = GNUNET_SCHEDULER_NO_TASK;
 454   cleanup_occ (occ);
 455 }
 456
 457
 458 /**
 459  * Task which will be run when overlay connect request has been timed out
 460  *
 461  * @param cls the OverlayConnectContext
 462  * @param tc the TaskContext
 463  */
 464 static void
 465 timeout_overlay_connect (void *cls,
 466                          const struct GNUNET_SCHEDULER_TaskContext *tc)
 467 {
 468   struct OverlayConnectContext *occ = cls;
 469
 470   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != occ->timeout_task);
 471   occ->timeout_task = GNUNET_SCHEDULER_NO_TASK;
 472   /* LOG (GNUNET_ERROR_TYPE_WARNING, */
 473   /*      "0x%llx: Timeout while connecting peers %u and %u: %s\n", occ->op_id, */
 474   /*      occ->peer->id, occ->other_peer_id, occ->emsg); */
 475   GST_send_operation_fail_msg (occ->client, occ->op_id, occ->emsg);
 476   cleanup_occ (occ);
 477 }
 478
 479
 480 static void
 481 send_overlay_connect_success_msg (struct OverlayConnectContext *occ)
 482 {
 483   struct GNUNET_TESTBED_ConnectionEventMessage *msg;
 484
 485   LOG_DEBUG ("0x%llx: Peers connected - Sending overlay connect success\n",
 486              occ->op_id);
 487   msg = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_ConnectionEventMessage));
 488   msg->header.size =
 489       htons (sizeof (struct GNUNET_TESTBED_ConnectionEventMessage));
 490   msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_PEER_CONNECT_EVENT);
 491   msg->event_type = htonl (GNUNET_TESTBED_ET_CONNECT);
 492   msg->peer1 = htonl (occ->peer->id);
 493   msg->peer2 = htonl (occ->other_peer_id);
 494   msg->operation_id = GNUNET_htonll (occ->op_id);
 495   GST_queue_message (occ->client, &msg->header);
 496 }
 497
 498
 499 /**
 500  * Function called to notify transport users that another
 501  * peer connected to us.
 502  *
 503  * @param cls closure
 504  * @param new_peer the peer that connected
 505  */
 506 static void
 507 overlay_connect_notify (void *cls, const struct GNUNET_PeerIdentity *new_peer)
 508 {
 509   struct OverlayConnectContext *occ = cls;
 510   char *new_peer_str;
 511   char *other_peer_str;
 512
 513   //LOG_DEBUG ("Overlay connect notify\n");
 514   if (0 ==
 515       memcmp (new_peer, &occ->peer_identity,
 516               sizeof (struct GNUNET_PeerIdentity)))
 517     return;
 518   new_peer_str = GNUNET_strdup (GNUNET_i2s (new_peer));
 519   other_peer_str = GNUNET_strdup (GNUNET_i2s (&occ->other_peer_identity));
 520   if (0 !=
 521       memcmp (new_peer, &occ->other_peer_identity,
 522               sizeof (struct GNUNET_PeerIdentity)))
 523   {
 524     /* LOG_DEBUG ("Unexpected peer %4s connected when expecting peer %4s\n", */
 525     /*         new_peer_str, other_peer_str); */
 526     GNUNET_free (new_peer_str);
 527     GNUNET_free (other_peer_str);
 528     return;
 529   }
 530   GNUNET_free (new_peer_str);
 531   LOG_DEBUG ("0x%llx: Peer %4s connected to peer %4s\n", occ->op_id,
 532              other_peer_str, GNUNET_i2s (&occ->peer_identity));
 533   GNUNET_free (other_peer_str);
 534   if (GNUNET_SCHEDULER_NO_TASK != occ->send_hello_task)
 535   {
 536     GNUNET_SCHEDULER_cancel (occ->send_hello_task);
 537     occ->send_hello_task = GNUNET_SCHEDULER_NO_TASK;
 538   }
 539   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != occ->timeout_task);
 540   GNUNET_SCHEDULER_cancel (occ->timeout_task);
 541   occ->timeout_task = GNUNET_SCHEDULER_NO_TASK;
 542   if (GNUNET_SCHEDULER_NO_TASK != occ->tcc.task)
 543   {
 544     GNUNET_SCHEDULER_cancel (occ->tcc.task);
 545     occ->tcc.task = GNUNET_SCHEDULER_NO_TASK;
 546   }
 547   GNUNET_free_non_null (occ->emsg);
 548   occ->emsg = NULL;
 549   send_overlay_connect_success_msg (occ);
 550   occ->cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup_occ, occ);
 551   //cleanup_occ (occ);
 552 }
 553
 554
 555 /**
 556  * Task to ask transport of a peer to connect to another peer
 557  *
 558  * @param cls the TryConnectContext
 559  * @param tc the scheduler task context
 560  */
 561 static void
 562 try_connect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 563
 564
 565 /**
 566  * Callback to be called with result of the try connect request.
 567  *
 568  * @param cls the overlay connect context
 569  * @param result GNUNET_OK if message was transmitted to transport service
 570  *               GNUNET_SYSERR if message was not transmitted to transport service
 571  */
 572 static void
 573 try_connect_cb (void *cls, const int result)
 574 {
 575   struct TryConnectContext *tcc = cls;
 576
 577   tcc->tch = NULL;
 578   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == tcc->task);
 579   tcc->task =
 580       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
 581                                     (GNUNET_TIME_UNIT_MILLISECONDS,
 582                                      500 + pow (2, ++tcc->retries)),
 583                                     &try_connect_task, tcc);
 584 }
 585
 586
 587 /**
 588  * Task to ask transport of a peer to connect to another peer
 589  *
 590  * @param cls the TryConnectContext
 591  * @param tc the scheduler task context
 592  */
 593 static void
 594 try_connect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 595 {
 596   struct TryConnectContext *tcc = cls;
 597
 598   tcc->task = GNUNET_SCHEDULER_NO_TASK;
 599   if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
 600     return;
 601   GNUNET_assert (NULL == tcc->tch);
 602   GNUNET_assert (NULL != tcc->pid);
 603   GNUNET_assert (NULL != tcc->th_);
 604   GNUNET_assert (NULL != tcc->cgh_th);
 605   LOG_DEBUG ("0x%llx: Trail %u to connect to peer %4s\n", tcc->op_id,
 606              tcc->retries, GNUNET_i2s (tcc->pid));
 607   tcc->tch =
 608       GNUNET_TRANSPORT_try_connect (tcc->th_, tcc->pid, &try_connect_cb, tcc);
 609 }
 610
 611
 612 /**
 613  * Task to offer HELLO of peer 1 to peer 2 and try to make peer 2 to connect to
 614  * peer 1.
 615  *
 616  * @param cls the OverlayConnectContext
 617  * @param tc the TaskContext from scheduler
 618  */
 619 static void
 620 send_hello (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 621
 622
 623 /**
 624  * Task that is run when hello has been sent
 625  *
 626  * @param cls the overlay connect context
 627  * @param tc the scheduler task context; if tc->reason =
 628  *          GNUNET_SCHEDULER_REASON_TIMEOUT then sending HELLO failed; if
 629  *          GNUNET_SCHEDULER_REASON_READ_READY is succeeded
 630  */
 631 static void
 632 occ_hello_sent_cb (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 633 {
 634   struct OverlayConnectContext *occ = cls;
 635
 636   occ->ohh = NULL;
 637   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == occ->send_hello_task);
 638   if (GNUNET_SCHEDULER_REASON_TIMEOUT == tc->reason)
 639   {
 640     GNUNET_free_non_null (occ->emsg);
 641     GNUNET_asprintf (&occ->emsg,
 642                      "0x%llx: Timeout while offering HELLO to other peer",
 643                      occ->op_id);
 644     occ->send_hello_task = GNUNET_SCHEDULER_add_now (&send_hello, occ);
 645     return;
 646   }
 647   if (GNUNET_SCHEDULER_REASON_READ_READY != tc->reason)
 648     return;
 649   GNUNET_free_non_null (occ->emsg);
 650   GNUNET_asprintf (&occ->emsg,
 651                    "0x%llx: Timeout during TRANSPORT_try_connect() "
 652                    "at peer %4s", occ->op_id,
 653                    GNUNET_i2s(&occ->peer_identity));
 654   occ->tcc.pid = &occ->peer_identity;
 655   occ->tcc.op_id = occ->op_id;
 656   occ->tcc.task = GNUNET_SCHEDULER_add_now (&try_connect_task, &occ->tcc);
 657 }
 658
 659
 660 /**
 661  * Task to offer HELLO of peer 1 to peer 2 and try to make peer 2 to connect to
 662  * peer 1.
 663  *
 664  * @param cls the OverlayConnectContext
 665  * @param tc the TaskContext from scheduler
 666  */
 667 static void
 668 send_hello (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 669 {
 670   struct OverlayConnectContext *occ = cls;
 671   char *other_peer_str;
 672
 673   occ->send_hello_task = GNUNET_SCHEDULER_NO_TASK;
 674   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
 675     return;
 676   GNUNET_assert (NULL != occ->hello);
 677   other_peer_str = GNUNET_strdup (GNUNET_i2s (&occ->other_peer_identity));
 678   if (NULL != occ->peer2_controller)
 679   {
 680     struct GNUNET_TESTBED_RemoteOverlayConnectMessage *msg;
 681     uint16_t msize;
 682     uint16_t hello_size;
 683
 684     LOG_DEBUG ("0x%llx: Offering HELLO of %s (size: %u) to %s via Remote "
 685                "Overlay Request\n", occ->op_id,
 686                GNUNET_i2s (&occ->peer_identity), ntohs (occ->hello->size),
 687                other_peer_str);
 688     hello_size = ntohs (occ->hello->size);
 689     msize =
 690         sizeof (struct GNUNET_TESTBED_RemoteOverlayConnectMessage) + hello_size;
 691     msg = GNUNET_malloc (msize);
 692     msg->header.type =
 693         htons (GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT);
 694     msg->header.size = htons (msize);
 695     msg->peer = htonl (occ->other_peer_id);
 696     msg->operation_id = GNUNET_htonll (occ->op_id);
 697     (void) memcpy (&msg->peer_identity, &occ->peer_identity,
 698                    sizeof (struct GNUNET_PeerIdentity));
 699     memcpy (msg->hello, occ->hello, hello_size);
 700     GNUNET_TESTBED_queue_message_ (occ->peer2_controller, &msg->header);
 701   }
 702   else
 703   {
 704     LOG_DEBUG ("0x%llx: Offering HELLO of %s to %s\n", occ->op_id,
 705                GNUNET_i2s (&occ->peer_identity), other_peer_str);
 706     occ->ohh =
 707         GNUNET_TRANSPORT_offer_hello (occ->tcc.th_, occ->hello,
 708                                       occ_hello_sent_cb, occ);
 709     if (NULL == occ->ohh)
 710     {
 711       GNUNET_break (0);
 712       occ->send_hello_task =
 713           GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
 714                                         (GNUNET_TIME_UNIT_MILLISECONDS,
 715                                          100 +
 716                                          GNUNET_CRYPTO_random_u32
 717                                          (GNUNET_CRYPTO_QUALITY_WEAK, 500)),
 718                                         &send_hello, occ);
 719     }
 720   }
 721   GNUNET_free (other_peer_str);
 722 }
 723
 724
 725 /**
 726  * Callback from cache with needed handles set
 727  *
 728  * @param cls the closure passed to GST_cache_get_handle_transport()
 729  * @param ch the handle to CORE. Can be NULL if it is not requested
 730  * @param th the handle to TRANSPORT. Can be NULL if it is not requested
 731  * @param ignore_ peer identity which is ignored in this callback
 732  */
 733 static void
 734 p2_transport_connect_cache_callback (void *cls, struct GNUNET_CORE_Handle *ch,
 735                                      struct GNUNET_TRANSPORT_Handle *th,
 736                                      const struct GNUNET_PeerIdentity *ignore_)
 737 {
 738   struct OverlayConnectContext *occ = cls;
 739
 740   if (NULL == th)
 741   {
 742     GNUNET_asprintf (&occ->emsg, "0x%llx: Cannot connect to TRANSPORT of %s",
 743                      occ->op_id, GNUNET_i2s (&occ->other_peer_identity));
 744     GNUNET_SCHEDULER_cancel (occ->timeout_task);
 745     occ->timeout_task =
 746         GNUNET_SCHEDULER_add_now (&timeout_overlay_connect, occ);
 747     return;
 748   }
 749   occ->tcc.th_ = th;
 750   GNUNET_asprintf (&occ->emsg, "0x%llx: Timeout while offering HELLO to %s",
 751                    occ->op_id, GNUNET_i2s (&occ->other_peer_identity));
 752   occ->send_hello_task = GNUNET_SCHEDULER_add_now (&send_hello, occ);
 753 }
 754
 755
 756 /**
 757  * Connects to the transport of the other peer if it is a local peer and
 758  * schedules the send hello task
 759  *
 760  * @param occ the overlay connect context
 761  */
 762 static void
 763 p2_transport_connect (struct OverlayConnectContext *occ)
 764 {
 765   GNUNET_assert (NULL == occ->emsg);
 766   GNUNET_assert (NULL != occ->hello);
 767   GNUNET_assert (NULL == occ->ghh);
 768   GNUNET_assert (NULL == occ->p1th_);
 769   GNUNET_assert (NULL == occ->cgh_p1th);
 770   if (NULL == occ->peer2_controller)
 771   {
 772     GNUNET_assert (NULL != GST_peer_list[occ->other_peer_id]);
 773     occ->tcc.cgh_th =
 774         GST_cache_get_handle_transport (occ->other_peer_id,
 775                                         GST_peer_list[occ->other_peer_id]
 776                                         ->details.local.cfg,
 777                                         &p2_transport_connect_cache_callback,
 778                                         occ, NULL, NULL, NULL);
 779     return;
 780   }
 781   GNUNET_asprintf (&occ->emsg, "0x%llx: Timeout while offering HELLO to %s",
 782                    occ->op_id, GNUNET_i2s (&occ->other_peer_identity));
 783   occ->send_hello_task = GNUNET_SCHEDULER_add_now (&send_hello, occ);
 784 }
 785
 786
 787 /**
 788  * Test for checking whether HELLO message is empty
 789  *
 790  * @param cls empty flag to set
 791  * @param address the HELLO
 792  * @param expiration expiration of the HELLO
 793  * @return
 794  */
 795 static int
 796 test_address (void *cls, const struct GNUNET_HELLO_Address *address,
 797               struct GNUNET_TIME_Absolute expiration)
 798 {
 799   int *empty = cls;
 800
 801   *empty = GNUNET_NO;
 802   return GNUNET_OK;
 803 }
 804
 805
 806 /**
 807  * Function called whenever there is an update to the HELLO of peers in the
 808  * OverlayConnectClosure. If we have a valid HELLO, we connect to the peer 2's
 809  * transport and offer peer 1's HELLO and ask peer 2 to connect to peer 1
 810  *
 811  * @param cls closure
 812  * @param hello our updated HELLO
 813  */
 814 static void
 815 hello_update_cb (void *cls, const struct GNUNET_MessageHeader *hello)
 816 {
 817   struct OverlayConnectContext *occ = cls;
 818   int empty;
 819   uint16_t msize;
 820
 821   msize = ntohs (hello->size);
 822   empty = GNUNET_YES;
 823   (void) GNUNET_HELLO_iterate_addresses ((const struct GNUNET_HELLO_Message *)
 824                                          hello, GNUNET_NO, &test_address,
 825                                          &empty);
 826   if (GNUNET_YES == empty)
 827   {
 828     LOG_DEBUG ("0x%llx: HELLO of %s is empty\n", occ->op_id,
 829                GNUNET_i2s (&occ->peer_identity));
 830     return;
 831   }
 832   LOG_DEBUG ("0x%llx: Received HELLO of %s\n", occ->op_id,
 833              GNUNET_i2s (&occ->peer_identity));
 834   occ->hello = GNUNET_malloc (msize);
 835   GST_cache_add_hello (occ->peer->id, hello);
 836   memcpy (occ->hello, hello, msize);
 837   GNUNET_TRANSPORT_get_hello_cancel (occ->ghh);
 838   occ->ghh = NULL;
 839   GST_cache_get_handle_done (occ->cgh_p1th);
 840   occ->cgh_p1th = NULL;
 841   occ->p1th_ = NULL;
 842   GNUNET_free_non_null (occ->emsg);
 843   occ->emsg = NULL;
 844   p2_transport_connect (occ);
 845 }
 846
 847
 848 /**
 849  * Callback from cache with needed handles set
 850  *
 851  * @param cls the closure passed to GST_cache_get_handle_transport()
 852  * @param ch the handle to CORE. Can be NULL if it is not requested
 853  * @param th the handle to TRANSPORT. Can be NULL if it is not requested
 854  * @param ignore_ peer identity which is ignored in this callback
 855  */
 856 static void
 857 p1_transport_connect_cache_callback (void *cls, struct GNUNET_CORE_Handle *ch,
 858                                      struct GNUNET_TRANSPORT_Handle *th,
 859                                      const struct GNUNET_PeerIdentity *ignore_)
 860 {
 861   struct OverlayConnectContext *occ = cls;
 862
 863   GNUNET_free_non_null (occ->emsg);
 864   occ->emsg = NULL;
 865   if (NULL == th)
 866   {
 867     GNUNET_asprintf (&occ->emsg, "0x%llx: Cannot connect to TRANSPORT of %s",
 868                      occ->op_id, GNUNET_i2s (&occ->peer_identity));
 869     GNUNET_SCHEDULER_cancel (occ->timeout_task);
 870     occ->timeout_task =
 871         GNUNET_SCHEDULER_add_now (&timeout_overlay_connect, occ);
 872     return;
 873   }
 874   GNUNET_assert (NULL == occ->p1th_);
 875   GNUNET_assert (NULL != occ->cgh_p1th);
 876   occ->p1th_ = th;
 877   GNUNET_asprintf (&occ->emsg,
 878                    "0x%llx: Timeout while acquiring HELLO of peer %4s",
 879                    occ->op_id, GNUNET_i2s (&occ->peer_identity));
 880   occ->ghh = GNUNET_TRANSPORT_get_hello (occ->p1th_, &hello_update_cb, occ);
 881 }
 882
 883
 884 /**
 885  * Callback from cache with needed handles set
 886  *
 887  * @param cls the closure passed to GST_cache_get_handle_transport()
 888  * @param ch the handle to CORE. Can be NULL if it is not requested
 889  * @param th the handle to TRANSPORT. Can be NULL if it is not requested
 890  * @param my_identity the identity of our peer
 891  */
 892 static void
 893 occ_cache_get_handle_core_cb (void *cls, struct GNUNET_CORE_Handle *ch,
 894                               struct GNUNET_TRANSPORT_Handle *th,
 895                               const struct GNUNET_PeerIdentity *my_identity)
 896 {
 897   struct OverlayConnectContext *occ = cls;
 898   const struct GNUNET_MessageHeader *hello;
 899
 900   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != occ->timeout_task);
 901   GNUNET_free_non_null (occ->emsg);
 902   if ((NULL == ch) || (NULL == my_identity))
 903   {
 904     (void) GNUNET_asprintf (&occ->emsg,
 905                             "0x%llx: Failed to connect to CORE of peer with "
 906                             "id: %u", occ->op_id, occ->peer->id);
 907     GNUNET_SCHEDULER_cancel (occ->timeout_task);
 908     occ->timeout_task =
 909         GNUNET_SCHEDULER_add_now (&timeout_overlay_connect, occ);
 910     return;
 911   }
 912   //occ->ch_ = ch;
 913   occ->emsg = NULL;
 914   if (GNUNET_YES ==
 915       GNUNET_CORE_is_peer_connected_sync (ch, &occ->other_peer_identity))
 916   {
 917     LOG_DEBUG ("0x%llx: Target peer already connected\n", occ->op_id);
 918     GNUNET_SCHEDULER_cancel (occ->timeout_task);
 919     occ->timeout_task = GNUNET_SCHEDULER_NO_TASK;
 920     send_overlay_connect_success_msg (occ);
 921     occ->cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup_occ, occ);
 922     return;
 923   }
 924   memcpy (&occ->peer_identity, my_identity,
 925           sizeof (struct GNUNET_PeerIdentity));
 926   LOG_DEBUG ("0x%llx: Acquiring HELLO of peer %s\n", occ->op_id,
 927              GNUNET_i2s (&occ->peer_identity));
 928   /* Lookup for HELLO in hello cache */
 929   if (NULL != (hello = GST_cache_lookup_hello (occ->peer->id)))
 930   {
 931     LOG_DEBUG ("0x%llx: HELLO of peer %s found in cache\n", occ->op_id,
 932                GNUNET_i2s (&occ->peer_identity));
 933     occ->hello = GNUNET_copy_message (hello);
 934     p2_transport_connect (occ);
 935     return;
 936   }
 937   GNUNET_asprintf (&occ->emsg,
 938                    "0x%llx: Timeout while acquiring TRANSPORT of %s from cache",
 939                    occ->op_id, GNUNET_i2s (&occ->peer_identity));
 940   occ->cgh_p1th =
 941       GST_cache_get_handle_transport (occ->peer->id,
 942                                       occ->peer->details.local.cfg,
 943                                       p1_transport_connect_cache_callback, occ,
 944                                       NULL, NULL, NULL);
 945 }
 946
 947
 948 /**
 949  * Callback to be called when forwarded get peer config operation as part of
 950  * overlay connect is successfull. Connection to Peer 1's core is made and is
 951  * checked for new connection from peer 2
 952  *
 953  * @param cls ForwardedOperationContext
 954  * @param msg the peer create success message
 955  */
 956 static void
 957 overlay_connect_get_config (void *cls, const struct GNUNET_MessageHeader *msg)
 958 {
 959   struct OverlayConnectContext *occ = cls;
 960   const struct GNUNET_TESTBED_PeerConfigurationInformationMessage *cmsg;
 961
 962   occ->opc = NULL;
 963   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != occ->timeout_task);
 964   if (GNUNET_MESSAGE_TYPE_TESTBED_PEER_CONFIGURATION != ntohs (msg->type))
 965   {
 966     GNUNET_SCHEDULER_cancel (occ->timeout_task);
 967     occ->timeout_task =
 968         GNUNET_SCHEDULER_add_now (&timeout_overlay_connect, occ);
 969   }
 970   cmsg =
 971       (const struct GNUNET_TESTBED_PeerConfigurationInformationMessage *) msg;
 972   memcpy (&occ->other_peer_identity, &cmsg->peer_identity,
 973           sizeof (struct GNUNET_PeerIdentity));
 974   GNUNET_free_non_null (occ->emsg);
 975   GNUNET_asprintf (&occ->emsg,
 976                    "0x%llx: Timeout while connecting to CORE of peer with "
 977                    "id: %u", occ->op_id, occ->peer->id);
 978   occ->cgh_ch =
 979       GST_cache_get_handle_core (occ->peer->id, occ->peer->details.local.cfg,
 980                                  occ_cache_get_handle_core_cb, occ,
 981                                  &occ->other_peer_identity,
 982                                  &overlay_connect_notify, occ);
 983   return;
 984 }
 985
 986
 987 /**
 988  * Callback which will be called after a host registration succeeded or failed
 989  *
 990  * @param cls the RegisteredHostContext
 991  * @param emsg the error message; NULL if host registration is successful
 992  */
 993 static void
 994 registeredhost_registration_completion (void *cls, const char *emsg)
 995 {
 996   struct RegisteredHostContext *rhc = cls;
 997   const struct GNUNET_CONFIGURATION_Handle *cfg;
 998   uint32_t peer2_host_id;
 999
1000   peer2_host_id = GNUNET_TESTBED_host_get_id_ (rhc->reg_host);
1001   GNUNET_assert (RHC_INIT == rhc->state);
1002   GNUNET_assert (NULL == rhc->sub_op);
1003   if ((NULL == rhc->gateway2) ||
1004       ( (peer2_host_id < GST_host_list_size) /* Check if we have the needed config */
1005         && (NULL != GST_host_list[peer2_host_id]) )  )
1006   {
1007     rhc->state = RHC_LINK;
1008     cfg =
1009         (NULL ==
1010          rhc->gateway2) ? our_config
1011         : GNUNET_TESTBED_host_get_cfg_ (GST_host_list[peer2_host_id]);
1012     rhc->sub_op =
1013         GNUNET_TESTBED_controller_link (rhc, rhc->gateway->controller,
1014                                         rhc->reg_host, rhc->host, cfg,
1015                                         GNUNET_NO);
1016     return;
1017   }
1018   rhc->state = RHC_GET_CFG;
1019   rhc->sub_op =
1020       GNUNET_TESTBED_get_slave_config (rhc, rhc->gateway2->controller,
1021                                        rhc->reg_host);
1022 }
1023
1024
1025 /**
1026  * Iterator to match a registered host context
1027  *
1028  * @param cls pointer 2 pointer of RegisteredHostContext
1029  * @param key current key code
1030  * @param value value in the hash map
1031  * @return GNUNET_YES if we should continue to
1032  *         iterate,
1033  *         GNUNET_NO if not.
1034  */
1035 static int
1036 reghost_match_iterator (void *cls, const struct GNUNET_HashCode *key,
1037                         void *value)
1038 {
1039   struct RegisteredHostContext **rh = cls;
1040   struct RegisteredHostContext *rh_val = value;
1041
1042   if ((rh_val->host == (*rh)->host) && (rh_val->reg_host == (*rh)->reg_host))
1043   {
1044     GNUNET_free (*rh);
1045     *rh = rh_val;
1046     return GNUNET_NO;
1047   }
1048   return GNUNET_YES;
1049 }
1050
1051
1052 /**
1053  * Function to generate the hashcode corresponding to a RegisteredHostContext
1054  *
1055  * @param reg_host the host which is being registered in RegisteredHostContext
1056  * @param host the host of the controller which has to connect to the above rhost
1057  * @return the hashcode
1058  */
1059 static struct GNUNET_HashCode
1060 hash_hosts (struct GNUNET_TESTBED_Host *reg_host,
1061             struct GNUNET_TESTBED_Host *host)
1062 {
1063   struct GNUNET_HashCode hash;
1064   uint32_t host_ids[2];
1065
1066   host_ids[0] = GNUNET_TESTBED_host_get_id_ (reg_host);
1067   host_ids[1] = GNUNET_TESTBED_host_get_id_ (host);
1068   GNUNET_CRYPTO_hash (host_ids, sizeof (host_ids), &hash);
1069   return hash;
1070 }
1071
1072
1073 /**
1074  * Handler for GNUNET_MESSAGE_TYPE_TESTBED_OLCONNECT messages
1075  *
1076  * @param cls NULL
1077  * @param client identification of the client
1078  * @param message the actual message
1079  */
1080 void
1081 GST_handle_overlay_connect (void *cls, struct GNUNET_SERVER_Client *client,
1082                             const struct GNUNET_MessageHeader *message)
1083 {
1084   const struct GNUNET_TESTBED_OverlayConnectMessage *msg;
1085   struct Peer *peer;
1086   struct OverlayConnectContext *occ;
1087   struct GNUNET_TESTBED_Controller *peer2_controller;
1088   uint64_t operation_id;
1089   uint32_t p1;
1090   uint32_t p2;
1091   uint32_t peer2_host_id;
1092
1093   if (sizeof (struct GNUNET_TESTBED_OverlayConnectMessage) !=
1094       ntohs (message->size))
1095   {
1096     GNUNET_break (0);
1097     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1098     return;
1099   }
1100   msg = (const struct GNUNET_TESTBED_OverlayConnectMessage *) message;
1101   p1 = ntohl (msg->peer1);
1102   p2 = ntohl (msg->peer2);
1103   if ((p1 >= GST_peer_list_size) || (NULL == GST_peer_list[p1]))
1104   {
1105     GNUNET_break (0);
1106     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1107     return;
1108   }
1109   peer = GST_peer_list[p1];
1110   peer2_host_id = ntohl (msg->peer2_host_id);
1111   operation_id = GNUNET_ntohll (msg->operation_id);
1112   LOG_DEBUG
1113       ("Received overlay connect for peers %u and %u with op id: 0x%llx\n", p1,
1114        p2, operation_id);
1115   if (GNUNET_YES == peer->is_remote)
1116   {
1117     struct ForwardedOperationContext *fopc;
1118     struct Route *route_to_peer2_host;
1119     struct Route *route_to_peer1_host;
1120
1121     LOG_DEBUG ("0x%llx: Forwarding overlay connect\n", operation_id);
1122     route_to_peer2_host = NULL;
1123     route_to_peer1_host = NULL;
1124     route_to_peer2_host = GST_find_dest_route (peer2_host_id);
1125     if ((NULL != route_to_peer2_host) ||
1126         (peer2_host_id == GST_context->host_id))
1127     {
1128       /* Peer 2 either below us OR with us */
1129       route_to_peer1_host =
1130           GST_find_dest_route (GST_peer_list[p1]->details.
1131                                remote.remote_host_id);
1132       /* Because we get this message only if we know where peer 1 is */
1133       GNUNET_assert (NULL != route_to_peer1_host);
1134       if ((peer2_host_id == GST_context->host_id) ||
1135           (route_to_peer2_host->dest != route_to_peer1_host->dest))
1136       {
1137         /* Peer2 is either with us OR peer1 and peer2 can be reached through
1138          * different gateways */
1139         struct GNUNET_HashCode hash;
1140         struct RegisteredHostContext *rhc;
1141         int skip_focc;
1142
1143         rhc = GNUNET_malloc (sizeof (struct RegisteredHostContext));
1144         rhc->type = CLOSURE_TYPE_RHC;
1145         if (NULL != route_to_peer2_host)
1146           rhc->reg_host = GST_host_list[route_to_peer2_host->dest];
1147         else
1148           rhc->reg_host = GST_host_list[GST_context->host_id];
1149         rhc->host = GST_host_list[route_to_peer1_host->dest];
1150         GNUNET_assert (NULL != rhc->reg_host);
1151         GNUNET_assert (NULL != rhc->host);
1152         rhc->gateway = peer->details.remote.slave;
1153         rhc->gateway2 =
1154             (NULL ==
1155              route_to_peer2_host) ? NULL :
1156             GST_slave_list[route_to_peer2_host->dest];
1157         rhc->state = RHC_INIT;
1158         GNUNET_SERVER_client_keep (client);
1159         rhc->client = client;
1160         hash = hash_hosts (rhc->reg_host, rhc->host);
1161         skip_focc = GNUNET_NO;
1162         if ((GNUNET_NO ==
1163              GNUNET_CONTAINER_multihashmap_contains (peer->details.
1164                                                      remote.slave->reghost_map,
1165                                                      &hash)) ||
1166             (GNUNET_SYSERR !=
1167              GNUNET_CONTAINER_multihashmap_get_multiple (peer->details.remote.
1168                                                          slave->reghost_map,
1169                                                          &hash,
1170                                                          reghost_match_iterator,
1171                                                          &rhc)))
1172         {
1173           /* create and add a new registerd host context */
1174           /* add the focc to its queue */
1175           GNUNET_CONTAINER_multihashmap_put (peer->details.remote.
1176                                              slave->reghost_map, &hash, rhc,
1177                                              GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
1178           GNUNET_assert (NULL != GST_host_list[peer2_host_id]);
1179           GST_queue_host_registration (peer->details.remote.slave,
1180                                        registeredhost_registration_completion,
1181                                        rhc, GST_host_list[peer2_host_id]);
1182         }
1183         else
1184         {
1185           /* rhc is now set to the existing one from the hash map by
1186            * reghost_match_iterator() */
1187           /* if queue is empty then ignore creating focc and proceed with
1188            * normal forwarding */
1189           if (RHC_OL_CONNECT == rhc->state)
1190             skip_focc = GNUNET_YES;
1191         }
1192         if (GNUNET_NO == skip_focc)
1193         {
1194           struct ForwardedOverlayConnectContext *focc;
1195
1196           focc = GNUNET_malloc (sizeof (struct ForwardedOverlayConnectContext));
1197           focc->peer1 = p1;
1198           focc->peer2 = p2;
1199           focc->peer2_host_id = peer2_host_id;
1200           focc->orig_msg = GNUNET_copy_message (message);
1201           focc->operation_id = operation_id;
1202           GNUNET_CONTAINER_DLL_insert_tail (rhc->focc_dll_head,
1203                                             rhc->focc_dll_tail, focc);
1204           GNUNET_SERVER_receive_done (client, GNUNET_OK);
1205           return;
1206         }
1207       }
1208     }
1209     fopc = GNUNET_malloc (sizeof (struct ForwardedOperationContext));
1210     GNUNET_SERVER_client_keep (client);
1211     fopc->client = client;
1212     fopc->operation_id = operation_id;
1213     fopc->type = OP_OVERLAY_CONNECT;
1214     fopc->opc =
1215         GNUNET_TESTBED_forward_operation_msg_ (peer->details.remote.
1216                                                slave->controller, operation_id,
1217                                                message,
1218                                                &GST_forwarded_operation_reply_relay,
1219                                                fopc);
1220     fopc->timeout_task =
1221         GNUNET_SCHEDULER_add_delayed (GST_timeout, &GST_forwarded_operation_timeout,
1222                                       fopc);
1223     GNUNET_CONTAINER_DLL_insert_tail (fopcq_head, fopcq_tail, fopc);
1224     GNUNET_SERVER_receive_done (client, GNUNET_OK);
1225     return;
1226   }
1227
1228   peer2_controller = NULL;
1229   if ((p2 >= GST_peer_list_size) || (NULL == GST_peer_list[p2]))
1230   {
1231     if ((peer2_host_id >= GST_slave_list_size) ||
1232         (NULL == GST_slave_list[peer2_host_id]))
1233     {
1234       GNUNET_break (0);
1235       LOG (GNUNET_ERROR_TYPE_WARNING,
1236            "0x%llx: Configuration of peer2's controller missing for connecting peers"
1237            "%u and %u\n", operation_id, p1, p2);
1238       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1239       return;
1240     }
1241     peer2_controller = GST_slave_list[peer2_host_id]->controller;
1242     if (NULL == peer2_controller)
1243     {
1244       GNUNET_break (0);         /* What's going on? */
1245       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1246       return;
1247     }
1248   }
1249   else
1250   {
1251     if (GNUNET_YES == GST_peer_list[p2]->is_remote)
1252       peer2_controller = GST_peer_list[p2]->details.remote.slave->controller;
1253   }
1254   occ = GNUNET_malloc (sizeof (struct OverlayConnectContext));
1255   GNUNET_CONTAINER_DLL_insert_tail (occq_head, occq_tail, occ);
1256   GNUNET_SERVER_client_keep (client);
1257   occ->client = client;
1258   occ->other_peer_id = p2;
1259   GST_peer_list[p1]->reference_cnt++;
1260   occ->peer = GST_peer_list[p1];
1261   occ->op_id = GNUNET_ntohll (msg->operation_id);
1262   occ->peer2_controller = peer2_controller;
1263   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == occ->timeout_task);
1264   occ->timeout_task =
1265       GNUNET_SCHEDULER_add_delayed (GST_timeout, &timeout_overlay_connect, occ);
1266   /* Get the identity of the second peer */
1267   if (NULL != occ->peer2_controller)
1268   {
1269     struct GNUNET_TESTBED_PeerGetConfigurationMessage cmsg;
1270
1271     cmsg.header.size =
1272         htons (sizeof (struct GNUNET_TESTBED_PeerGetConfigurationMessage));
1273     cmsg.header.type =
1274         htons (GNUNET_MESSAGE_TYPE_TESTBED_GET_PEER_CONFIGURATION);
1275     cmsg.peer_id = msg->peer2;
1276     cmsg.operation_id = msg->operation_id;
1277     occ->opc =
1278         GNUNET_TESTBED_forward_operation_msg_ (occ->peer2_controller,
1279                                                occ->op_id, &cmsg.header,
1280                                                &overlay_connect_get_config,
1281                                                occ);
1282     GNUNET_asprintf (&occ->emsg,
1283                      "0x%llx: Timeout while getting peer identity of peer "
1284                      "with id: %u", occ->op_id, occ->other_peer_id);
1285     GNUNET_SERVER_receive_done (client, GNUNET_OK);
1286     return;
1287   }
1288   GST_peer_list[occ->other_peer_id]->reference_cnt++;
1289   GNUNET_TESTING_peer_get_identity (GST_peer_list[occ->other_peer_id]->
1290                                     details.local.peer,
1291                                     &occ->other_peer_identity);
1292   GNUNET_asprintf (&occ->emsg,
1293                    "0x%llx: Timeout while connecting to CORE of peer with "
1294                    "id: %u", occ->op_id, occ->peer->id);
1295   occ->cgh_ch =
1296       GST_cache_get_handle_core (occ->peer->id, occ->peer->details.local.cfg,
1297                                  occ_cache_get_handle_core_cb, occ,
1298                                  &occ->other_peer_identity,
1299                                  &overlay_connect_notify, occ);
1300   GNUNET_SERVER_receive_done (client, GNUNET_OK);
1301 }
1302
1303
1304 /**
1305  * Function to cleanup RemoteOverlayConnectCtx and any associated tasks
1306  * with it
1307  *
1308  * @param rocc the RemoteOverlayConnectCtx
1309  */
1310 static void
1311 cleanup_rocc (struct RemoteOverlayConnectCtx *rocc)
1312 {
1313   LOG_DEBUG ("0x%llx: Cleaning up rocc\n", rocc->op_id);
1314   if (GNUNET_SCHEDULER_NO_TASK != rocc->attempt_connect_task_id)
1315     GNUNET_SCHEDULER_cancel (rocc->attempt_connect_task_id);
1316   if (GNUNET_SCHEDULER_NO_TASK != rocc->timeout_rocc_task_id)
1317     GNUNET_SCHEDULER_cancel (rocc->timeout_rocc_task_id);
1318   if (NULL != rocc->ohh)
1319     GNUNET_TRANSPORT_offer_hello_cancel (rocc->ohh);
1320   if (NULL != rocc->tcc.tch)
1321     GNUNET_TRANSPORT_try_connect_cancel (rocc->tcc.tch);
1322   if (GNUNET_SCHEDULER_NO_TASK != rocc->tcc.task)
1323     GNUNET_SCHEDULER_cancel (rocc->tcc.task);
1324   //GNUNET_TRANSPORT_disconnect (rocc->tcc.th_);
1325   GST_cache_get_handle_done (rocc->tcc.cgh_th);
1326   GNUNET_assert (rocc->peer->reference_cnt > 0);
1327   rocc->peer->reference_cnt--;
1328   if ((GNUNET_YES == rocc->peer->destroy_flag) &&
1329       (0 == rocc->peer->reference_cnt))
1330     GST_destroy_peer (rocc->peer);
1331   GNUNET_free_non_null (rocc->hello);
1332   GNUNET_CONTAINER_DLL_remove (roccq_head, roccq_tail, rocc);
1333   GNUNET_free (rocc);
1334 }
1335
1336
1337 /**
1338  * Task to timeout rocc and cleanit up
1339  *
1340  * @param cls the RemoteOverlayConnectCtx
1341  * @param tc the TaskContext from scheduler
1342  */
1343 static void
1344 timeout_rocc_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1345 {
1346   struct RemoteOverlayConnectCtx *rocc = cls;
1347
1348   GNUNET_assert (rocc->timeout_rocc_task_id != GNUNET_SCHEDULER_NO_TASK);
1349   rocc->timeout_rocc_task_id = GNUNET_SCHEDULER_NO_TASK;
1350   LOG_DEBUG ("0x%llx: rocc timed out\n", rocc->op_id);
1351   cleanup_rocc (rocc);
1352 }
1353
1354
1355 /**
1356  * Function called to notify transport users that another
1357  * peer connected to us.
1358  *
1359  * @param cls the RemoteOverlayConnectContext
1360  * @param new_peer the peer that connected
1361  */
1362 static void
1363 cache_transport_peer_connect_notify (void *cls,
1364                                      const struct GNUNET_PeerIdentity *new_peer)
1365 {
1366   struct RemoteOverlayConnectCtx *rocc = cls;
1367
1368   LOG_DEBUG ("0x%llx: Request Overlay connect notify\n", rocc->op_id);
1369   GNUNET_assert (0 ==
1370                  memcmp (new_peer, &rocc->a_id,
1371                          sizeof (struct GNUNET_PeerIdentity)));
1372   LOG_DEBUG ("0x%llx: Peer %4s connected\n", rocc->op_id,
1373              GNUNET_i2s (&rocc->a_id));
1374   cleanup_rocc (rocc);
1375 }
1376
1377
1378 /**
1379  * Task to offer the HELLO message to the peer and ask it to connect to the peer
1380  * whose identity is in RemoteOverlayConnectCtx
1381  *
1382  * @param cls the RemoteOverlayConnectCtx
1383  * @param tc the TaskContext from scheduler
1384  */
1385 static void
1386 attempt_connect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
1387
1388
1389 /**
1390  * Task that is run when hello has been sent
1391  *
1392  * @param cls the overlay connect context
1393  * @param tc the scheduler task context; if tc->reason =
1394  *          GNUNET_SCHEDULER_REASON_TIMEOUT then sending HELLO failed; if
1395  *          GNUNET_SCHEDULER_REASON_READ_READY is succeeded
1396  */
1397 static void
1398 rocc_hello_sent_cb (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1399 {
1400   struct RemoteOverlayConnectCtx *rocc = cls;
1401
1402   rocc->ohh = NULL;
1403   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == rocc->attempt_connect_task_id);
1404   LOG_DEBUG ("0x%llx: HELLO of peer %4s sent to local peer with id: %u\n",
1405              rocc->op_id, GNUNET_i2s (&rocc->a_id), rocc->peer->id);
1406   if (GNUNET_SCHEDULER_REASON_TIMEOUT == tc->reason)
1407   {
1408     GNUNET_break (0);
1409     rocc->attempt_connect_task_id =
1410         GNUNET_SCHEDULER_add_now (&attempt_connect_task, rocc);
1411     return;
1412   }
1413   if (GNUNET_SCHEDULER_REASON_READ_READY != tc->reason)
1414   {
1415     GNUNET_break (0);
1416     return;
1417   }
1418   rocc->tcc.task = GNUNET_SCHEDULER_add_now (&try_connect_task, &rocc->tcc);
1419 }
1420
1421
1422 /**
1423  * Task to offer the HELLO message to the peer and ask it to connect to the peer
1424  * whose identity is in RemoteOverlayConnectCtx
1425  *
1426  * @param cls the RemoteOverlayConnectCtx
1427  * @param tc the TaskContext from scheduler
1428  */
1429 static void
1430 attempt_connect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1431 {
1432   struct RemoteOverlayConnectCtx *rocc = cls;
1433
1434   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != rocc->attempt_connect_task_id);
1435   rocc->attempt_connect_task_id = GNUNET_SCHEDULER_NO_TASK;
1436   LOG_DEBUG ("0x%llx: Offering HELLO of peer %4s to local peer with id: %u\n",
1437              rocc->op_id, GNUNET_i2s (&rocc->a_id), rocc->peer->id);
1438   rocc->ohh =
1439       GNUNET_TRANSPORT_offer_hello (rocc->tcc.th_, rocc->hello,
1440                                     rocc_hello_sent_cb, rocc);
1441   if (NULL == rocc->ohh)
1442     rocc->attempt_connect_task_id =
1443         GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
1444                                       (GNUNET_TIME_UNIT_MILLISECONDS,
1445                                        100 +
1446                                        GNUNET_CRYPTO_random_u32
1447                                        (GNUNET_CRYPTO_QUALITY_WEAK, 500)),
1448                                       &attempt_connect_task, rocc);
1449 }
1450
1451
1452 /**
1453  * Callback from cache with needed handles set
1454  *
1455  * @param cls the closure passed to GST_cache_get_handle_transport()
1456  * @param ch the handle to CORE. Can be NULL if it is not requested
1457  * @param th the handle to TRANSPORT. Can be NULL if it is not requested
1458  * @param ignore_ peer identity which is ignored in this callback
1459  */
1460 static void
1461 rocc_cache_get_handle_transport_cb (void *cls, struct GNUNET_CORE_Handle *ch,
1462                                     struct GNUNET_TRANSPORT_Handle *th,
1463                                     const struct GNUNET_PeerIdentity *ignore_)
1464 {
1465   struct RemoteOverlayConnectCtx *rocc = cls;
1466
1467   if (NULL == th)
1468   {
1469     rocc->timeout_rocc_task_id =
1470         GNUNET_SCHEDULER_add_now (&timeout_rocc_task, rocc);
1471     return;
1472   }
1473   rocc->tcc.th_ = th;
1474   rocc->tcc.pid = &rocc->a_id;
1475   if (GNUNET_YES ==
1476       GNUNET_TRANSPORT_check_neighbour_connected (rocc->tcc.th_, rocc->tcc.pid))
1477   {
1478     LOG_DEBUG ("0x%llx: Target peer %4s already connected to local peer: %u\n",
1479                rocc->op_id, GNUNET_i2s (&rocc->a_id), rocc->peer->id);
1480     cleanup_rocc (rocc);
1481     return;
1482   }
1483   rocc->attempt_connect_task_id =
1484       GNUNET_SCHEDULER_add_now (&attempt_connect_task, rocc);
1485 }
1486
1487
1488 /**
1489  * Handler for GNUNET_MESSAGE_TYPE_TESTBED_REQUESTCONNECT messages
1490  *
1491  * @param cls NULL
1492  * @param client identification of the client
1493  * @param message the actual message
1494  */
1495 void
1496 GST_handle_remote_overlay_connect (void *cls,
1497                                    struct GNUNET_SERVER_Client *client,
1498                                    const struct GNUNET_MessageHeader *message)
1499 {
1500   const struct GNUNET_TESTBED_RemoteOverlayConnectMessage *msg;
1501   struct RemoteOverlayConnectCtx *rocc;
1502   struct Peer *peer;
1503   uint32_t peer_id;
1504   uint16_t msize;
1505   uint16_t hsize;
1506
1507   msize = ntohs (message->size);
1508   if (sizeof (struct GNUNET_TESTBED_RemoteOverlayConnectMessage) >= msize)
1509   {
1510     GNUNET_break (0);
1511     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1512     return;
1513   }
1514   msg = (const struct GNUNET_TESTBED_RemoteOverlayConnectMessage *) message;
1515   if ((NULL == msg->hello) ||
1516       ((GNUNET_MESSAGE_TYPE_HELLO != ntohs (msg->hello->type))))
1517   {
1518     GNUNET_break (0);
1519     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1520     return;
1521   }
1522   hsize = ntohs (msg->hello->size);
1523   if ((sizeof (struct GNUNET_TESTBED_RemoteOverlayConnectMessage) + hsize) !=
1524       msize)
1525   {
1526     GNUNET_break (0);
1527     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1528     return;
1529   }
1530   peer_id = ntohl (msg->peer);
1531   if ((peer_id >= GST_peer_list_size) ||
1532       (NULL == (peer = GST_peer_list[peer_id])))
1533   {
1534     GNUNET_break_op (0);
1535     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1536     return;
1537   }
1538   if (GNUNET_YES == peer->is_remote)
1539   {
1540     struct GNUNET_MessageHeader *msg2;
1541
1542     msg2 = GNUNET_copy_message (message);
1543     GNUNET_TESTBED_queue_message_ (peer->details.remote.slave->controller,
1544                                    msg2);
1545     GNUNET_SERVER_receive_done (client, GNUNET_OK);
1546     return;
1547   }
1548   rocc = GNUNET_malloc (sizeof (struct RemoteOverlayConnectCtx));
1549   rocc->op_id = GNUNET_ntohll (msg->operation_id);
1550   GNUNET_CONTAINER_DLL_insert_tail (roccq_head, roccq_tail, rocc);
1551   memcpy (&rocc->a_id, &msg->peer_identity,
1552           sizeof (struct GNUNET_PeerIdentity));
1553   LOG_DEBUG ("Received request for overlay connection with op_id: 0x%llx "
1554              "from local peer %u to peer %4s with hello size: %u\n",
1555              rocc->op_id, peer_id, GNUNET_i2s (&rocc->a_id), hsize);
1556   rocc->peer = peer;
1557   rocc->peer->reference_cnt++;
1558   rocc->hello = GNUNET_malloc (hsize);
1559   memcpy (rocc->hello, msg->hello, hsize);
1560   rocc->tcc.cgh_th =
1561       GST_cache_get_handle_transport (peer_id, rocc->peer->details.local.cfg,
1562                                       &rocc_cache_get_handle_transport_cb, rocc,
1563                                       &rocc->a_id,
1564                                       &cache_transport_peer_connect_notify,
1565                                       rocc);
1566   rocc->timeout_rocc_task_id =
1567       GNUNET_SCHEDULER_add_delayed (GST_timeout, &timeout_rocc_task, rocc);
1568   GNUNET_SERVER_receive_done (client, GNUNET_OK);
1569 }
1570
1571
1572 /**
1573  * Clears all pending overlay connect contexts in queue
1574  */
1575 void
1576 GST_free_occq ()
1577 {
1578   struct OverlayConnectContext *occ;
1579
1580   while (NULL != (occ = occq_head))
1581     cleanup_occ (occ);
1582 }
1583
1584
1585 /**
1586  * Clears all pending remote overlay connect contexts in queue
1587  */
1588 void
1589 GST_free_roccq ()
1590 {
1591   struct RemoteOverlayConnectCtx *rocc;
1592
1593   while (NULL != (rocc = roccq_head))
1594     cleanup_rocc (rocc);
1595 }