src/testbed/testbed_api_peers.c

   1 /*
   2       This file is part of GNUnet
   3       (C) 2008--2013 Christian Grothoff (and other contributing authors)
   4
   5       GNUnet is free software; you can redistribute it and/or modify
   6       it under the terms of the GNU General Public License as published
   7       by the Free Software Foundation; either version 3, or (at your
   8       option) any later version.
   9
  10       GNUnet is distributed in the hope that it will be useful, but
  11       WITHOUT ANY WARRANTY; without even the implied warranty of
  12       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13       General Public License for more details.
  14
  15       You should have received a copy of the GNU General Public License
  16       along with GNUnet; see the file COPYING.  If not, write to the
  17       Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18       Boston, MA 02111-1307, USA.
  19  */
  20
  21 /**
  22  * @file testbed/testbed_api_peers.c
  23  * @brief management of the knowledge about peers in this library
  24  *        (we know the peer ID, its host, pending operations, etc.)
  25  * @author Christian Grothoff
  26  * @author Sree Harsha Totakura
  27  */
  28
  29 #include "platform.h"
  30 #include "testbed_api_peers.h"
  31 #include "testbed_api.h"
  32 #include "testbed.h"
  33 #include "testbed_api_hosts.h"
  34 #include "testbed_api_operations.h"
  35
  36
  37 /**
  38  * Peer list DLL head
  39  */
  40 static struct GNUNET_TESTBED_Peer *peer_list_head;
  41
  42 /**
  43  * Peer list DLL tail
  44  */
  45 static struct GNUNET_TESTBED_Peer *peer_list_tail;
  46
  47
  48 /**
  49  * Adds a peer to the peer list
  50  *
  51  * @param peer the peer to add to the peer list
  52  */
  53 void
  54 GNUNET_TESTBED_peer_register_ (struct GNUNET_TESTBED_Peer *peer)
  55 {
  56   GNUNET_CONTAINER_DLL_insert_tail (peer_list_head, peer_list_tail, peer);
  57 }
  58
  59
  60 /**
  61  * Removes a peer from the peer list
  62  *
  63  * @param peer the peer to remove
  64  */
  65 void
  66 GNUNET_TESTBED_peer_deregister_ (struct GNUNET_TESTBED_Peer *peer)
  67 {
  68   GNUNET_CONTAINER_DLL_remove (peer_list_head, peer_list_tail, peer);
  69 }
  70
  71
  72 /**
  73  * Frees all peers
  74  */
  75 void
  76 GNUNET_TESTBED_cleanup_peers_ (void)
  77 {
  78   struct GNUNET_TESTBED_Peer *peer;
  79
  80   while (NULL != (peer = peer_list_head))
  81   {
  82     GNUNET_TESTBED_peer_deregister_ (peer);
  83     GNUNET_free (peer);
  84   }
  85 }
  86
  87
  88
  89 /**
  90  * Function to call to start a peer_create type operation once all
  91  * queues the operation is part of declare that the
  92  * operation can be activated.
  93  *
  94  * @param cls the closure from GNUNET_TESTBED_operation_create_()
  95  */
  96 static void
  97 opstart_peer_create (void *cls)
  98 {
  99   struct OperationContext *opc = cls;
 100   struct PeerCreateData *data = opc->data;
 101   struct GNUNET_TESTBED_PeerCreateMessage *msg;
 102   char *config;
 103   char *xconfig;
 104   size_t c_size;
 105   size_t xc_size;
 106   uint16_t msize;
 107
 108   GNUNET_assert (OP_PEER_CREATE == opc->type);
 109   GNUNET_assert (NULL != data);
 110   GNUNET_assert (NULL != data->peer);
 111   opc->state = OPC_STATE_STARTED;
 112   config = GNUNET_CONFIGURATION_serialize (data->cfg, &c_size);
 113   xc_size = GNUNET_TESTBED_compress_config_ (config, c_size, &xconfig);
 114   GNUNET_free (config);
 115   msize = xc_size + sizeof (struct GNUNET_TESTBED_PeerCreateMessage);
 116   msg = GNUNET_realloc (xconfig, msize);
 117   memmove (&msg[1], msg, xc_size);
 118   msg->header.size = htons (msize);
 119   msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER);
 120   msg->operation_id = GNUNET_htonll (opc->id);
 121   msg->host_id = htonl (GNUNET_TESTBED_host_get_id_ (data->peer->host));
 122   msg->peer_id = htonl (data->peer->unique_id);
 123   msg->config_size = htons ((uint16_t) c_size);
 124   GNUNET_TESTBED_insert_opc_ (opc->c, opc);
 125   GNUNET_TESTBED_queue_message_ (opc->c, &msg->header);
 126 }
 127
 128
 129 /**
 130  * Callback which will be called when peer_create type operation is released
 131  *
 132  * @param cls the closure from GNUNET_TESTBED_operation_create_()
 133  */
 134 static void
 135 oprelease_peer_create (void *cls)
 136 {
 137   struct OperationContext *opc = cls;
 138
 139   switch (opc->state)
 140   {
 141   case OPC_STATE_STARTED:
 142     GNUNET_TESTBED_remove_opc_ (opc->c, opc);
 143     /* No break we continue flow */
 144   case OPC_STATE_INIT:
 145     GNUNET_free (((struct PeerCreateData *) opc->data)->peer);
 146     GNUNET_free (opc->data);
 147     break;
 148   case OPC_STATE_FINISHED:
 149     break;
 150   }
 151   GNUNET_free (opc);
 152 }
 153
 154
 155 /**
 156  * Function called when a peer destroy operation is ready
 157  *
 158  * @param cls the closure from GNUNET_TESTBED_operation_create_()
 159  */
 160 static void
 161 opstart_peer_destroy (void *cls)
 162 {
 163   struct OperationContext *opc = cls;
 164   struct GNUNET_TESTBED_Peer *peer = opc->data;
 165   struct GNUNET_TESTBED_PeerDestroyMessage *msg;
 166
 167   GNUNET_assert (OP_PEER_DESTROY == opc->type);
 168   GNUNET_assert (NULL != peer);
 169   opc->state = OPC_STATE_STARTED;
 170   msg = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_PeerDestroyMessage));
 171   msg->header.size = htons (sizeof (struct GNUNET_TESTBED_PeerDestroyMessage));
 172   msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_DESTROY_PEER);
 173   msg->peer_id = htonl (peer->unique_id);
 174   msg->operation_id = GNUNET_htonll (opc->id);
 175   GNUNET_TESTBED_insert_opc_ (opc->c, opc);
 176   GNUNET_TESTBED_queue_message_ (peer->controller, &msg->header);
 177 }
 178
 179
 180 /**
 181  * Callback which will be called when peer_create type operation is released
 182  *
 183  * @param cls the closure from GNUNET_TESTBED_operation_create_()
 184  */
 185 static void
 186 oprelease_peer_destroy (void *cls)
 187 {
 188   struct OperationContext *opc = cls;
 189
 190   switch (opc->state)
 191   {
 192   case OPC_STATE_STARTED:
 193     GNUNET_TESTBED_remove_opc_ (opc->c, opc);
 194     /* no break; continue */
 195   case OPC_STATE_INIT:
 196     break;
 197   case OPC_STATE_FINISHED:
 198     break;
 199   }
 200   GNUNET_free (opc);
 201 }
 202
 203
 204 /**
 205  * Function called when a peer start operation is ready
 206  *
 207  * @param cls the closure from GNUNET_TESTBED_operation_create_()
 208  */
 209 static void
 210 opstart_peer_start (void *cls)
 211 {
 212   struct OperationContext *opc = cls;
 213   struct GNUNET_TESTBED_PeerStartMessage *msg;
 214   struct PeerEventData *data;
 215   struct GNUNET_TESTBED_Peer *peer;
 216
 217   GNUNET_assert (OP_PEER_START == opc->type);
 218   GNUNET_assert (NULL != (data = opc->data));
 219   GNUNET_assert (NULL != (peer = data->peer));
 220   GNUNET_assert ((PS_CREATED == peer->state) || (PS_STOPPED == peer->state));
 221   opc->state = OPC_STATE_STARTED;
 222   msg = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_PeerStartMessage));
 223   msg->header.size = htons (sizeof (struct GNUNET_TESTBED_PeerStartMessage));
 224   msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_START_PEER);
 225   msg->peer_id = htonl (peer->unique_id);
 226   msg->operation_id = GNUNET_htonll (opc->id);
 227   GNUNET_TESTBED_insert_opc_ (opc->c, opc);
 228   GNUNET_TESTBED_queue_message_ (peer->controller, &msg->header);
 229 }
 230
 231
 232 /**
 233  * Callback which will be called when peer start type operation is released
 234  *
 235  * @param cls the closure from GNUNET_TESTBED_operation_create_()
 236  */
 237 static void
 238 oprelease_peer_start (void *cls)
 239 {
 240   struct OperationContext *opc = cls;
 241
 242   switch (opc->state)
 243   {
 244   case OPC_STATE_STARTED:
 245     GNUNET_TESTBED_remove_opc_ (opc->c, opc);
 246     /* no break; continue */
 247   case OPC_STATE_INIT:
 248     GNUNET_free (opc->data);
 249     break;
 250   case OPC_STATE_FINISHED:
 251     break;
 252   }
 253   GNUNET_free (opc);
 254 }
 255
 256
 257 /**
 258  * Function called when a peer stop operation is ready
 259  *
 260  * @param cls the closure from GNUNET_TESTBED_operation_create_()
 261  */
 262 static void
 263 opstart_peer_stop (void *cls)
 264 {
 265   struct OperationContext *opc = cls;
 266   struct GNUNET_TESTBED_PeerStopMessage *msg;
 267   struct PeerEventData *data;
 268   struct GNUNET_TESTBED_Peer *peer;
 269
 270   GNUNET_assert (NULL != (data = opc->data));
 271   GNUNET_assert (NULL != (peer = data->peer));
 272   GNUNET_assert (PS_STARTED == peer->state);
 273   opc->state = OPC_STATE_STARTED;
 274   msg = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_PeerStopMessage));
 275   msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_STOP_PEER);
 276   msg->header.size = htons (sizeof (struct GNUNET_TESTBED_PeerStopMessage));
 277   msg->peer_id = htonl (peer->unique_id);
 278   msg->operation_id = GNUNET_htonll (opc->id);
 279   GNUNET_TESTBED_insert_opc_ (opc->c, opc);
 280   GNUNET_TESTBED_queue_message_ (peer->controller, &msg->header);
 281 }
 282
 283
 284 /**
 285  * Callback which will be called when peer stop type operation is released
 286  *
 287  * @param cls the closure from GNUNET_TESTBED_operation_create_()
 288  */
 289 static void
 290 oprelease_peer_stop (void *cls)
 291 {
 292   struct OperationContext *opc = cls;
 293
 294   switch (opc->state)
 295   {
 296   case OPC_STATE_STARTED:
 297     GNUNET_TESTBED_remove_opc_ (opc->c, opc);
 298     /* no break; continue */
 299   case OPC_STATE_INIT:
 300     GNUNET_free (opc->data);
 301     break;
 302   case OPC_STATE_FINISHED:
 303     break;
 304   }
 305   GNUNET_free (opc);
 306 }
 307
 308
 309 /**
 310  * Generate PeerGetConfigurationMessage
 311  *
 312  * @param peer_id the id of the peer whose information we have to get
 313  * @param operation_id the ip of the operation that should be represented in the
 314  *          message
 315  * @return the PeerGetConfigurationMessage
 316  */
 317 struct GNUNET_TESTBED_PeerGetConfigurationMessage *
 318 GNUNET_TESTBED_generate_peergetconfig_msg_ (uint32_t peer_id,
 319                                             uint64_t operation_id)
 320 {
 321   struct GNUNET_TESTBED_PeerGetConfigurationMessage *msg;
 322
 323   msg =
 324       GNUNET_malloc (sizeof
 325                      (struct GNUNET_TESTBED_PeerGetConfigurationMessage));
 326   msg->header.size =
 327       htons (sizeof (struct GNUNET_TESTBED_PeerGetConfigurationMessage));
 328   msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_GET_PEER_CONFIGURATION);
 329   msg->peer_id = htonl (peer_id);
 330   msg->operation_id = GNUNET_htonll (operation_id);
 331   return msg;
 332 }
 333
 334
 335 /**
 336  * Function called when a peer get information operation is ready
 337  *
 338  * @param cls the closure from GNUNET_TESTBED_operation_create_()
 339  */
 340 static void
 341 opstart_peer_getinfo (void *cls)
 342 {
 343   struct OperationContext *opc = cls;
 344   struct PeerInfoData *data = opc->data;
 345   struct GNUNET_TESTBED_PeerGetConfigurationMessage *msg;
 346
 347   GNUNET_assert (NULL != data);
 348   opc->state = OPC_STATE_STARTED;
 349   msg =
 350       GNUNET_TESTBED_generate_peergetconfig_msg_ (data->peer->unique_id,
 351                                                   opc->id);
 352   GNUNET_TESTBED_insert_opc_ (opc->c, opc);
 353   GNUNET_TESTBED_queue_message_ (opc->c, &msg->header);
 354 }
 355
 356
 357 /**
 358  * Callback which will be called when peer stop type operation is released
 359  *
 360  * @param cls the closure from GNUNET_TESTBED_operation_create_()
 361  */
 362 static void
 363 oprelease_peer_getinfo (void *cls)
 364 {
 365   struct OperationContext *opc = cls;
 366   struct GNUNET_TESTBED_PeerInformation *data;
 367
 368   switch (opc->state)
 369   {
 370   case OPC_STATE_STARTED:
 371     GNUNET_TESTBED_remove_opc_ (opc->c, opc);
 372     /* no break; continue */
 373   case OPC_STATE_INIT:
 374     GNUNET_free (opc->data);
 375     break;
 376   case OPC_STATE_FINISHED:
 377     data = opc->data;
 378     GNUNET_assert (NULL != data);
 379     switch (data->pit)
 380     {
 381     case GNUNET_TESTBED_PIT_CONFIGURATION:
 382       if (NULL != data->result.cfg)
 383         GNUNET_CONFIGURATION_destroy (data->result.cfg);
 384       break;
 385     case GNUNET_TESTBED_PIT_IDENTITY:
 386       GNUNET_free (data->result.id);
 387       break;
 388     default:
 389       GNUNET_assert (0);        /* We should never reach here */
 390     }
 391     GNUNET_free (data);
 392     break;
 393   }
 394   GNUNET_free (opc);
 395 }
 396
 397
 398 /**
 399  * Function called when a overlay connect operation is ready
 400  *
 401  * @param cls the closure from GNUNET_TESTBED_operation_create_()
 402  */
 403 static void
 404 opstart_overlay_connect (void *cls)
 405 {
 406   struct OperationContext *opc = cls;
 407   struct GNUNET_TESTBED_OverlayConnectMessage *msg;
 408   struct OverlayConnectData *data;
 409
 410   opc->state = OPC_STATE_STARTED;
 411   data = opc->data;
 412   GNUNET_assert (NULL != data);
 413   data->tslot_index = GNUNET_TESTBED_get_tslot_ (data->p1->host, data);
 414   data->tstart = GNUNET_TIME_absolute_get ();
 415   msg = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_OverlayConnectMessage));
 416   msg->header.size =
 417       htons (sizeof (struct GNUNET_TESTBED_OverlayConnectMessage));
 418   msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_OVERLAY_CONNECT);
 419   msg->peer1 = htonl (data->p1->unique_id);
 420   msg->peer2 = htonl (data->p2->unique_id);
 421   msg->operation_id = GNUNET_htonll (opc->id);
 422   msg->peer2_host_id = htonl (GNUNET_TESTBED_host_get_id_ (data->p2->host));
 423   GNUNET_TESTBED_insert_opc_ (opc->c, opc);
 424   GNUNET_TESTBED_queue_message_ (opc->c, &msg->header);
 425 }
 426
 427
 428 /**
 429  * Callback which will be called when overlay connect operation is released
 430  *
 431  * @param cls the closure from GNUNET_TESTBED_operation_create_()
 432  */
 433 static void
 434 oprelease_overlay_connect (void *cls)
 435 {
 436   struct OperationContext *opc = cls;
 437   struct GNUNET_TIME_Relative duration;
 438   struct OverlayConnectData *data;
 439
 440   data = opc->data;
 441   switch (opc->state)
 442   {
 443   case OPC_STATE_INIT:
 444     break;
 445   case OPC_STATE_STARTED:
 446     (void) GNUNET_TESTBED_release_time_slot_ (data->p1->host, data->tslot_index,
 447                                               data);
 448     GNUNET_TESTBED_remove_opc_ (opc->c, opc);
 449     break;
 450   case OPC_STATE_FINISHED:
 451     duration = GNUNET_TIME_absolute_get_duration (data->tstart);
 452     GNUNET_TESTBED_update_time_slot_ (data->p1->host, data->tslot_index, data,
 453                                       duration, data->failed);
 454   }
 455   GNUNET_free (data);
 456   GNUNET_free (opc);
 457 }
 458
 459
 460 /**
 461  * Function called when a peer reconfigure operation is ready
 462  *
 463  * @param cls the closure from GNUNET_TESTBED_operation_create_()
 464  */
 465 static void
 466 opstart_peer_reconfigure (void *cls)
 467 {
 468   struct OperationContext *opc = cls;
 469   struct PeerReconfigureData *data = opc->data;
 470   struct GNUNET_TESTBED_PeerReconfigureMessage *msg;
 471   char *xconfig;
 472   size_t xc_size;
 473   uint16_t msize;
 474
 475   opc->state = OPC_STATE_STARTED;
 476   GNUNET_assert (NULL != data);
 477   xc_size = GNUNET_TESTBED_compress_config_ (data->config, data->cfg_size,
 478                                              &xconfig);
 479   GNUNET_free (data->config);
 480   data->config = NULL;
 481   GNUNET_assert (xc_size <= UINT16_MAX);
 482   msize = (uint16_t) xc_size +
 483       sizeof (struct GNUNET_TESTBED_PeerReconfigureMessage);
 484   msg = GNUNET_realloc (xconfig, msize);
 485   (void) memmove (&msg[1], msg, xc_size);
 486   msg->header.size = htons (msize);
 487   msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_RECONFIGURE_PEER);
 488   msg->peer_id = htonl (data->peer->unique_id);
 489   msg->operation_id = GNUNET_htonll (opc->id);
 490   msg->config_size = htons (data->cfg_size);
 491   GNUNET_free (data);
 492   opc->data = NULL;
 493   GNUNET_TESTBED_insert_opc_ (opc->c, opc);
 494   GNUNET_TESTBED_queue_message_ (opc->c, &msg->header);
 495 }
 496
 497
 498 /**
 499  * Callback which will be called when a peer reconfigure operation is released
 500  *
 501  * @param cls the closure from GNUNET_TESTBED_operation_create_()
 502  */
 503 static void
 504 oprelease_peer_reconfigure (void *cls)
 505 {
 506   struct OperationContext *opc = cls;
 507   struct PeerReconfigureData *data = opc->data;
 508
 509   switch (opc->state)
 510   {
 511   case OPC_STATE_INIT:
 512     GNUNET_free (data->config);
 513     GNUNET_free (data);
 514     break;
 515   case OPC_STATE_STARTED:
 516     GNUNET_TESTBED_remove_opc_ (opc->c, opc);
 517     break;
 518   case OPC_STATE_FINISHED:
 519     break;
 520   }
 521   GNUNET_free (opc);
 522 }
 523
 524
 525 /**
 526  * Lookup a peer by ID.
 527  *
 528  * @param id global peer ID assigned to the peer
 529  * @return handle to the host, NULL on error
 530  */
 531 struct GNUNET_TESTBED_Peer *
 532 GNUNET_TESTBED_peer_lookup_by_id_ (uint32_t id)
 533 {
 534   GNUNET_break (0);
 535   return NULL;
 536 }
 537
 538
 539 /**
 540  * Create the given peer at the specified host using the given
 541  * controller.  If the given controller is not running on the target
 542  * host, it should find or create a controller at the target host and
 543  * delegate creating the peer.  Explicit delegation paths can be setup
 544  * using 'GNUNET_TESTBED_controller_link'.  If no explicit delegation
 545  * path exists, a direct link with a subordinate controller is setup
 546  * for the first delegated peer to a particular host; the subordinate
 547  * controller is then destroyed once the last peer that was delegated
 548  * to the remote host is stopped.
 549  *
 550  * Creating the peer only creates the handle to manipulate and further
 551  * configure the peer; use "GNUNET_TESTBED_peer_start" and
 552  * "GNUNET_TESTBED_peer_stop" to actually start/stop the peer's
 553  * processes.
 554  *
 555  * Note that the given configuration will be adjusted by the
 556  * controller to avoid port/path conflicts with other peers.
 557  * The "final" configuration can be obtained using
 558  * 'GNUNET_TESTBED_peer_get_information'.
 559  *
 560  * @param controller controller process to use
 561  * @param host host to run the peer on; cannot be NULL
 562  * @param cfg Template configuration to use for the peer. Should exist until
 563  *          operation is cancelled or GNUNET_TESTBED_operation_done() is called
 564  * @param cb the callback to call when the peer has been created
 565  * @param cls the closure to the above callback
 566  * @return the operation handle
 567  */
 568 struct GNUNET_TESTBED_Operation *
 569 GNUNET_TESTBED_peer_create (struct GNUNET_TESTBED_Controller *controller,
 570                             struct GNUNET_TESTBED_Host *host,
 571                             const struct GNUNET_CONFIGURATION_Handle *cfg,
 572                             GNUNET_TESTBED_PeerCreateCallback cb, void *cls)
 573 {
 574
 575   struct GNUNET_TESTBED_Peer *peer;
 576   struct PeerCreateData *data;
 577   struct OperationContext *opc;
 578   static uint32_t id_gen;
 579
 580   peer = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_Peer));
 581   peer->controller = controller;
 582   peer->host = host;
 583   peer->unique_id = id_gen++;
 584   peer->state = PS_INVALID;
 585   data = GNUNET_malloc (sizeof (struct PeerCreateData));
 586   data->host = host;
 587   data->cfg = cfg;
 588   data->cb = cb;
 589   data->cls = cls;
 590   data->peer = peer;
 591   opc = GNUNET_malloc (sizeof (struct OperationContext));
 592   opc->c = controller;
 593   opc->data = data;
 594   opc->id = GNUNET_TESTBED_get_next_op_id (controller);
 595   opc->type = OP_PEER_CREATE;
 596   opc->op =
 597       GNUNET_TESTBED_operation_create_ (opc, &opstart_peer_create,
 598                                         &oprelease_peer_create);
 599   GNUNET_TESTBED_operation_queue_insert_ (controller->opq_parallel_operations,
 600                                           opc->op);
 601   GNUNET_TESTBED_operation_begin_wait_ (opc->op);
 602   return opc->op;
 603 }
 604
 605
 606 /**
 607  * Start the given peer.
 608  *
 609  * @param op_cls the closure for this operation; will be set in
 610  *          event->details.operation_finished.op_cls when this operation fails.
 611  * @param peer peer to start
 612  * @param pcc function to call upon completion
 613  * @param pcc_cls closure for 'pcc'
 614  * @return handle to the operation
 615  */
 616 struct GNUNET_TESTBED_Operation *
 617 GNUNET_TESTBED_peer_start (void *op_cls, struct GNUNET_TESTBED_Peer *peer,
 618                            GNUNET_TESTBED_PeerChurnCallback pcc, void *pcc_cls)
 619 {
 620   struct OperationContext *opc;
 621   struct PeerEventData *data;
 622
 623   data = GNUNET_malloc (sizeof (struct PeerEventData));
 624   data->peer = peer;
 625   data->pcc = pcc;
 626   data->pcc_cls = pcc_cls;
 627   opc = GNUNET_malloc (sizeof (struct OperationContext));
 628   opc->c = peer->controller;
 629   opc->data = data;
 630   opc->op_cls = op_cls;
 631   opc->id = GNUNET_TESTBED_get_next_op_id (opc->c);
 632   opc->type = OP_PEER_START;
 633   opc->op =
 634       GNUNET_TESTBED_operation_create_ (opc, &opstart_peer_start,
 635                                         &oprelease_peer_start);
 636   GNUNET_TESTBED_operation_queue_insert_ (opc->c->opq_parallel_operations,
 637                                           opc->op);
 638   GNUNET_TESTBED_operation_begin_wait_ (opc->op);
 639   return opc->op;
 640 }
 641
 642
 643 /**
 644  * Stop the given peer.  The handle remains valid (use
 645  * "GNUNET_TESTBED_peer_destroy" to fully clean up the
 646  * state of the peer).
 647  *
 648  * @param op_cls the closure for this operation; will be set in the event
 649  *          information
 650  * @param peer peer to stop
 651  * @param pcc function to call upon completion
 652  * @param pcc_cls closure for 'pcc'
 653  * @return handle to the operation
 654  */
 655 struct GNUNET_TESTBED_Operation *
 656 GNUNET_TESTBED_peer_stop (void *op_cls,
 657                           struct GNUNET_TESTBED_Peer *peer,
 658                           GNUNET_TESTBED_PeerChurnCallback pcc, void *pcc_cls)
 659 {
 660   struct OperationContext *opc;
 661   struct PeerEventData *data;
 662
 663   data = GNUNET_malloc (sizeof (struct PeerEventData));
 664   data->peer = peer;
 665   data->pcc = pcc;
 666   data->pcc_cls = pcc_cls;
 667   opc = GNUNET_malloc (sizeof (struct OperationContext));
 668   opc->c = peer->controller;
 669   opc->data = data;
 670   opc->op_cls = op_cls;
 671   opc->id = GNUNET_TESTBED_get_next_op_id (opc->c);
 672   opc->type = OP_PEER_STOP;
 673   opc->op =
 674       GNUNET_TESTBED_operation_create_ (opc, &opstart_peer_stop,
 675                                         &oprelease_peer_stop);
 676   GNUNET_TESTBED_operation_queue_insert_ (opc->c->opq_parallel_operations,
 677                                           opc->op);
 678   GNUNET_TESTBED_operation_begin_wait_ (opc->op);
 679   return opc->op;
 680 }
 681
 682
 683 /**
 684  * Request information about a peer. The controller callback will not be called
 685  * with event type GNUNET_TESTBED_ET_OPERATION_FINISHED when result for this
 686  * operation is available. Instead, the GNUNET_TESTBED_PeerInfoCallback() will
 687  * be called.
 688  * The peer information in the callback is valid until the operation is canceled.
 689  *
 690  * @param peer peer to request information about
 691  * @param pit desired information
 692  * @param cb the convenience callback to be called when results for this
 693  *          operation are available
 694  * @param cb_cls the closure for the above callback
 695  * @return handle to the operation
 696  */
 697 struct GNUNET_TESTBED_Operation *
 698 GNUNET_TESTBED_peer_get_information (struct GNUNET_TESTBED_Peer *peer,
 699                                      enum GNUNET_TESTBED_PeerInformationType
 700                                      pit, GNUNET_TESTBED_PeerInfoCallback cb,
 701                                      void *cb_cls)
 702 {
 703   struct OperationContext *opc;
 704   struct PeerInfoData *data;
 705
 706   GNUNET_assert (GNUNET_TESTBED_PIT_GENERIC != pit);
 707   GNUNET_assert (NULL != cb);
 708   data = GNUNET_malloc (sizeof (struct PeerInfoData));
 709   data->peer = peer;
 710   data->pit = pit;
 711   data->cb = cb;
 712   data->cb_cls = cb_cls;
 713   opc = GNUNET_malloc (sizeof (struct OperationContext));
 714   opc->c = peer->controller;
 715   opc->data = data;
 716   opc->type = OP_PEER_INFO;
 717   opc->id = GNUNET_TESTBED_get_next_op_id (opc->c);
 718   opc->op =
 719       GNUNET_TESTBED_operation_create_ (opc, &opstart_peer_getinfo,
 720                                         &oprelease_peer_getinfo);
 721   GNUNET_TESTBED_operation_queue_insert_ (opc->c->opq_parallel_operations,
 722                                           opc->op);
 723   GNUNET_TESTBED_operation_begin_wait_ (opc->op);
 724   return opc->op;
 725 }
 726
 727
 728 /**
 729  * Change peer configuration.  Must only be called while the
 730  * peer is stopped.  Ports and paths cannot be changed this
 731  * way.
 732  *
 733  * @param peer peer to change configuration for
 734  * @param cfg new configuration (differences to existing
 735  *            configuration only)
 736  * @return handle to the operation
 737  */
 738 struct GNUNET_TESTBED_Operation *
 739 GNUNET_TESTBED_peer_update_configuration (struct GNUNET_TESTBED_Peer *peer,
 740                                           const struct
 741                                           GNUNET_CONFIGURATION_Handle *cfg)
 742 {
 743   struct OperationContext *opc;
 744   struct PeerReconfigureData *data;
 745   size_t csize;
 746
 747   data = GNUNET_malloc (sizeof (struct PeerReconfigureData));
 748   data->peer = peer;
 749   data->config = GNUNET_CONFIGURATION_serialize (cfg, &csize);
 750   if (NULL == data->config)
 751   {
 752     GNUNET_free (data);
 753     return NULL;
 754   }
 755   if (csize > UINT16_MAX)
 756   {
 757     GNUNET_break (0);
 758     GNUNET_free (data->config);
 759     GNUNET_free (data);
 760     return NULL;
 761   }
 762   data->cfg_size = (uint16_t) csize;
 763   opc = GNUNET_malloc (sizeof (struct OperationContext));
 764   opc->c = peer->controller;
 765   opc->data = data;
 766   opc->type = OP_PEER_RECONFIGURE;
 767   opc->id = GNUNET_TESTBED_get_next_op_id (opc->c);
 768   opc->op =
 769       GNUNET_TESTBED_operation_create_ (opc, &opstart_peer_reconfigure,
 770                                         &oprelease_peer_reconfigure);
 771   GNUNET_TESTBED_operation_queue_insert_ (opc->c->opq_parallel_operations,
 772                                           opc->op);
 773   GNUNET_TESTBED_operation_begin_wait_ (opc->op);
 774   return opc->op;
 775 }
 776
 777
 778 /**
 779  * Destroy the given peer; the peer should have been
 780  * stopped first (if it was started).
 781  *
 782  * @param peer peer to stop
 783  * @return handle to the operation
 784  */
 785 struct GNUNET_TESTBED_Operation *
 786 GNUNET_TESTBED_peer_destroy (struct GNUNET_TESTBED_Peer *peer)
 787 {
 788   struct OperationContext *opc;
 789
 790   opc = GNUNET_malloc (sizeof (struct OperationContext));
 791   opc->data = peer;
 792   opc->c = peer->controller;
 793   opc->id = GNUNET_TESTBED_get_next_op_id (peer->controller);
 794   opc->type = OP_PEER_DESTROY;
 795   opc->op =
 796       GNUNET_TESTBED_operation_create_ (opc, &opstart_peer_destroy,
 797                                         &oprelease_peer_destroy);
 798   GNUNET_TESTBED_operation_queue_insert_ (opc->c->opq_parallel_operations,
 799                                           opc->op);
 800   GNUNET_TESTBED_operation_begin_wait_ (opc->op);
 801   return opc->op;
 802 }
 803
 804
 805 /**
 806  * Manipulate the P2P underlay topology by configuring a link
 807  * between two peers.
 808  *
 809  * @param op_cls closure argument to give with the operation event
 810  * @param p1 first peer
 811  * @param p2 second peer
 812  * @param co option to change
 813  * @param ... option-specific values
 814  * @return handle to the operation, NULL if configuring the link at this
 815  *         time is not allowed
 816  */
 817 struct GNUNET_TESTBED_Operation *
 818 GNUNET_TESTBED_underlay_configure_link (void *op_cls,
 819                                         struct GNUNET_TESTBED_Peer *p1,
 820                                         struct GNUNET_TESTBED_Peer *p2,
 821                                         enum GNUNET_TESTBED_ConnectOption co,
 822                                         ...)
 823 {
 824   GNUNET_break (0);
 825   return NULL;
 826 }
 827
 828
 829 /**
 830  * Both peers must have been started before calling this function.
 831  * This function then obtains a HELLO from 'p1', gives it to 'p2'
 832  * and asks 'p2' to connect to 'p1'.
 833  *
 834  * @param op_cls closure argument to give with the operation event
 835  * @param cb the callback to call when this operation has finished
 836  * @param cb_cls the closure for the above callback
 837  * @param p1 first peer
 838  * @param p2 second peer
 839  * @return handle to the operation, NULL if connecting these two
 840  *         peers is fundamentally not possible at this time (peers
 841  *         not running or underlay disallows)
 842  */
 843 struct GNUNET_TESTBED_Operation *
 844 GNUNET_TESTBED_overlay_connect (void *op_cls,
 845                                 GNUNET_TESTBED_OperationCompletionCallback cb,
 846                                 void *cb_cls, struct GNUNET_TESTBED_Peer *p1,
 847                                 struct GNUNET_TESTBED_Peer *p2)
 848 {
 849   struct OperationContext *opc;
 850   struct OverlayConnectData *data;
 851
 852   GNUNET_assert ((PS_STARTED == p1->state) && (PS_STARTED == p2->state));
 853   data = GNUNET_malloc (sizeof (struct OverlayConnectData));
 854   data->p1 = p1;
 855   data->p2 = p2;
 856   data->cb = cb;
 857   data->cb_cls = cb_cls;
 858   opc = GNUNET_malloc (sizeof (struct OperationContext));
 859   opc->data = data;
 860   opc->c = p1->controller;
 861   opc->id = GNUNET_TESTBED_get_next_op_id (opc->c);
 862   opc->type = OP_OVERLAY_CONNECT;
 863   opc->op_cls = op_cls;
 864   opc->op =
 865       GNUNET_TESTBED_operation_create_ (opc, &opstart_overlay_connect,
 866                                         &oprelease_overlay_connect);
 867   GNUNET_TESTBED_host_queue_oc_ (p1->host, opc->op);
 868   GNUNET_TESTBED_operation_begin_wait_ (opc->op);
 869   return opc->op;
 870 }
 871
 872
 873 /**
 874  * Function called when a peer manage service operation is ready
 875  *
 876  * @param cls the closure from GNUNET_TESTBED_operation_create_()
 877  */
 878 static void
 879 opstart_manage_service (void *cls)
 880 {
 881   struct OperationContext *opc = cls;
 882   struct ManageServiceData *data = opc->data;
 883   struct GNUNET_TESTBED_ManagePeerServiceMessage *msg;
 884
 885   GNUNET_assert (NULL != data);
 886   msg = GNUNET_malloc (data->msize);
 887   msg->header.size = htons (data->msize);
 888   msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_MANAGE_PEER_SERVICE);
 889   msg->peer_id = htonl (data->peer->unique_id);
 890   msg->operation_id = GNUNET_htonll (opc->id);
 891   msg->start = (uint8_t) data->start;
 892   (void) memcpy (&msg[1], data->service_name, data->msize
 893                  - sizeof (struct GNUNET_TESTBED_ManagePeerServiceMessage));
 894   GNUNET_free (data->service_name);
 895   data->service_name = NULL;
 896   opc->state = OPC_STATE_STARTED;
 897   GNUNET_TESTBED_insert_opc_ (opc->c, opc);
 898   GNUNET_TESTBED_queue_message_ (opc->c, &msg->header);
 899 }
 900
 901
 902 /**
 903  * Callback which will be called when peer manage server operation is released
 904  *
 905  * @param cls the closure from GNUNET_TESTBED_operation_create_()
 906  */
 907 static void
 908 oprelease_manage_service (void *cls)
 909 {
 910   struct OperationContext *opc = cls;
 911   struct ManageServiceData *data;
 912
 913   data = opc->data;
 914   switch (opc->state)
 915   {
 916   case OPC_STATE_STARTED:
 917     GNUNET_TESTBED_remove_opc_ (opc->c, opc);
 918     break;
 919   case OPC_STATE_INIT:
 920     GNUNET_assert (NULL != data);
 921     GNUNET_free (data->service_name);
 922     break;
 923   case OPC_STATE_FINISHED:
 924     break;
 925   }
 926   GNUNET_free_non_null (data);
 927   GNUNET_free (opc);
 928 }
 929
 930
 931 /**
 932  * Start or stop given service at a peer.  This should not be called to
 933  * start/stop the peer's ARM service.  Use GNUNET_TESTBED_peer_start(),
 934  * GNUNET_TESTBED_peer_stop() for starting/stopping peer's ARM service.  Success
 935  * or failure of the generated operation is signalled through the controller
 936  * event callback and/or operation completion callback.
 937  *
 938  * @param op_cls the closure for the operation
 939  * @param peer the peer whose service is to be started/stopped
 940  * @param service_name the name of the service
 941  * @param cb the operation completion callback
 942  * @param cb_cls the closure for the operation completion callback
 943  * @param start 1 to start the service; 0 to stop the service
 944  * @return an operation handle; NULL upon error (peer not running)
 945  */
 946 struct GNUNET_TESTBED_Operation *
 947 GNUNET_TESTBED_peer_manage_service (void *op_cls,
 948                                     struct GNUNET_TESTBED_Peer *peer,
 949                                     const char *service_name,
 950                                     GNUNET_TESTBED_OperationCompletionCallback cb,
 951                                     void *cb_cls,
 952                                     unsigned int start)
 953 {
 954   struct ManageServiceData *data;
 955   struct OperationContext *opc;
 956   size_t msize;
 957
 958   GNUNET_assert (PS_STARTED == peer->state); /* peer is not running? */
 959   msize = strlen (service_name) + 1;
 960   msize += sizeof (struct GNUNET_TESTBED_ManagePeerServiceMessage);
 961   if (GNUNET_SERVER_MAX_MESSAGE_SIZE < msize)
 962     return NULL;
 963   data = GNUNET_malloc (sizeof (struct ManageServiceData));
 964   data->cb = cb;
 965   data->cb_cls = cb_cls;
 966   data->peer = peer;
 967   data->service_name = GNUNET_strdup (service_name);
 968   data->start = start;
 969   data->msize = (uint16_t) msize;
 970   opc = GNUNET_malloc (sizeof (struct OperationContext));
 971   opc->data = data;
 972   opc->c = peer->controller;
 973   opc->id = GNUNET_TESTBED_get_next_op_id (opc->c);
 974   opc->type = OP_MANAGE_SERVICE;
 975   opc->op_cls = op_cls;
 976   opc->op =
 977       GNUNET_TESTBED_operation_create_ (opc, &opstart_manage_service,
 978                                         &oprelease_manage_service);
 979   GNUNET_TESTBED_operation_queue_insert_ (opc->c->opq_parallel_operations,
 980                                           opc->op);
 981   GNUNET_TESTBED_operation_begin_wait_ (opc->op);
 982   return opc->op;
 983 }
 984
 985
 986
 987 /* end of testbed_api_peers.c */