src/testbed/gnunet-service-testbed.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.c
  23  * @brief implementation of the TESTBED service
  24  * @author Sree Harsha Totakura
  25  */
  26
  27 #include "platform.h"
  28 #include "gnunet_service_lib.h"
  29 #include "gnunet_server_lib.h"
  30 #include <zlib.h>
  31
  32 #include "testbed.h"
  33 #include "gnunet_testbed_service.h"
  34 #include "testbed_api_hosts.h"
  35 #include "gnunet_testing_lib-new.h"
  36
  37 /**
  38  * Generic logging
  39  */
  40 #define LOG(kind,...)                           \
  41   GNUNET_log (kind, __VA_ARGS__)
  42
  43 /**
  44  * Debug logging
  45  */
  46 #define LOG_DEBUG(...)                          \
  47   LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
  48
  49
  50 #define LIST_GROW_STEP 10
  51
  52 struct Context
  53 {
  54   /**
  55    * The client handle associated with this context
  56    */
  57   struct GNUNET_SERVER_Client *client;
  58
  59   /**
  60    * The network address of the master controller
  61    */
  62   char *master_ip;
  63
  64   /**
  65    * The TESTING system handle for starting peers locally
  66    */
  67   struct GNUNET_TESTING_System *system;
  68
  69   /**
  70    * Event mask of event to be responded in this context
  71    */
  72   uint64_t event_mask;
  73
  74   /**
  75    * Our host id according to this context
  76    */
  77   uint32_t host_id;
  78 };
  79
  80
  81 /**
  82  * The message queue for sending messages to clients
  83  */
  84 struct MessageQueue
  85 {
  86   /**
  87    * The message to be sent
  88    */
  89   struct GNUNET_MessageHeader *msg;
  90
  91   /**
  92    * The client to send the message to
  93    */
  94   struct GNUNET_SERVER_Client *client;
  95
  96   /**
  97    * next pointer for DLL
  98    */
  99   struct MessageQueue *next;
 100
 101   /**
 102    * prev pointer for DLL
 103    */
 104   struct MessageQueue *prev;
 105 };
 106
 107
 108 /**
 109  * The structure for identifying a shared service
 110  */
 111 struct SharedService
 112 {
 113   /**
 114    * The name of the shared service
 115    */
 116   char *name;
 117
 118   /**
 119    * Number of shared peers per instance of the shared service
 120    */
 121   uint32_t num_shared;
 122
 123   /**
 124    * Number of peers currently sharing the service
 125    */
 126   uint32_t num_sharing;
 127 };
 128
 129
 130 /**
 131  * A routing entry
 132  */
 133 struct Route
 134 {
 135   /**
 136    * destination host
 137    */
 138   uint32_t dest;
 139
 140   /**
 141    * The host destination is reachable thru
 142    */
 143   uint32_t thru;
 144 };
 145
 146
 147 /**
 148  * Structure representing a connected(directly-linked) controller
 149  */
 150 struct Slave
 151 {
 152   /**
 153    * The controller process handle if we had started the controller
 154    */
 155   struct GNUNET_TESTBED_ControllerProc *controller_proc;
 156
 157   /**
 158    * The controller handle
 159    */
 160   struct GNUNET_TESTBED_Controller *controller;
 161
 162   /**
 163    * The id of the host this controller is running on
 164    */
 165   uint32_t host_id;
 166 };
 167
 168
 169 /**
 170  * Slave startup context
 171  */
 172 struct SlaveContext
 173 {
 174   /**
 175    * The slave corresponding to this context
 176    */
 177   struct Slave *slave;
 178
 179   /**
 180    * The configuration used as a template while startup
 181    */
 182   struct GNUNET_CONFIGURATION_Handle *cfg;
 183 };
 184
 185
 186 /**
 187  * States of LCFContext
 188  */
 189 enum LCFContextState
 190   {
 191     /**
 192      * The Context has been initialized; Nothing has been done on it
 193      */
 194     INIT,
 195
 196     /**
 197      * Delegated host has been registered at the forwarding controller
 198      */
 199     DELEGATED_HOST_REGISTERED,
 200
 201     /**
 202      * The context has been finished (may have error)
 203      */
 204     FINISHED
 205
 206   };
 207
 208
 209 /**
 210  * Link controllers request forwarding context
 211  */
 212 struct LCFContext
 213 {
 214   /**
 215    * The serialized and compressed configuration
 216    */
 217   char *sxcfg;
 218
 219   /**
 220    * The gateway which will pass the link message to delegated host
 221    */
 222   struct Slave *gateway;
 223
 224   /**
 225    * The host registration handle while registered hosts in this context
 226    */
 227   struct GNUNET_TESTBED_HostRegistrationHandle *rhandle;
 228
 229   /**
 230    * The size of the compressed serialized configuration
 231    */
 232   size_t sxcfg_size;
 233
 234   /**
 235    * The size of the uncompressed configuration
 236    */
 237   size_t scfg_size;
 238
 239   /**
 240    * Should the delegated host be started by the slave host?
 241    */
 242   int is_subordinate;
 243
 244   /**
 245    * The state of this context
 246    */
 247   enum LCFContextState state;
 248
 249   /**
 250    * The delegated host
 251    */
 252   uint32_t delegated_host_id;
 253
 254
 255 };
 256
 257
 258 /**
 259  * Structure of a queue entry in LCFContext request queue
 260  */
 261 struct LCFContextQueue
 262 {
 263   /**
 264    * The LCFContext
 265    */
 266   struct LCFContext *lcf;
 267
 268   /**
 269    * Head prt for DLL
 270    */
 271   struct LCFContextQueue *next;
 272
 273   /**
 274    * Tail ptr for DLL
 275    */
 276   struct LCFContextQueue *prev;
 277 };
 278
 279
 280 /**
 281  * A locally started peer
 282  */
 283 struct Peer
 284 {
 285   /**
 286    * The peer handle from testing API
 287    */
 288   struct GNUNET_TESTING_Peer *peer;
 289
 290   /**
 291    * The modified (by GNUNET_TESTING_peer_configure) configuration this peer is
 292    * configured with
 293    */
 294   struct GNUNET_CONFIGURATION_Handle *cfg;
 295
 296   /**
 297    * Our local reference id for this peer
 298    */
 299   uint32_t id;
 300
 301 };
 302
 303
 304 /**
 305  * The master context; generated with the first INIT message
 306  */
 307 static struct Context *master_context;
 308
 309 /***********/
 310 /* Handles */
 311 /***********/
 312
 313 /**
 314  * Wrapped stdin.
 315  */
 316 static struct GNUNET_DISK_FileHandle *fh;
 317
 318 /**
 319  * Current Transmit Handle; NULL if no notify transmit exists currently
 320  */
 321 static struct GNUNET_SERVER_TransmitHandle *transmit_handle;
 322
 323 /****************/
 324 /* Lists & Maps */
 325 /****************/
 326
 327 /**
 328  * The head for the LCF queue
 329  */
 330 static struct LCFContextQueue *lcfq_head;
 331
 332 /**
 333  * The tail for the LCF queue
 334  */
 335 static struct LCFContextQueue *lcfq_tail;
 336
 337 /**
 338  * The message queue head
 339  */
 340 static struct MessageQueue *mq_head;
 341
 342 /**
 343  * The message queue tail
 344  */
 345 static struct MessageQueue *mq_tail;
 346
 347 /**
 348  * Array of host list
 349  */
 350 static struct GNUNET_TESTBED_Host **host_list;
 351
 352 /**
 353  * A list of routes
 354  */
 355 static struct Route **route_list;
 356
 357 /**
 358  * A list of directly linked neighbours
 359  */
 360 static struct Slave **slave_list;
 361
 362 /**
 363  * A list of peers we own locally
 364  */
 365 static struct Peer **peer_list;
 366
 367 /**
 368  * The hashmap of shared services
 369  */
 370 static struct GNUNET_CONTAINER_MultiHashMap *ss_map;
 371
 372 /**
 373  * The size of the host list
 374  */
 375 static uint32_t host_list_size;
 376
 377 /**
 378  * The size of the route list
 379  */
 380 static uint32_t route_list_size;
 381
 382 /**
 383  * The size of directly linked neighbours list
 384  */
 385 static uint32_t slave_list_size;
 386
 387 /**
 388  * The size of the peer list
 389  */
 390 static uint32_t peer_list_size;
 391
 392 /*********/
 393 /* Tasks */
 394 /*********/
 395
 396 /**
 397  * The lcf_task handle
 398  */
 399 static GNUNET_SCHEDULER_TaskIdentifier lcf_proc_task_id;
 400
 401 /**
 402  * The shutdown task handle
 403  */
 404 static GNUNET_SCHEDULER_TaskIdentifier shutdown_task_id;
 405
 406 /******************/
 407 /* Testing System */
 408 /******************/
 409
 410 /**
 411  * Our configuration; we also use this as template for starting other controllers
 412  */
 413 static struct GNUNET_CONFIGURATION_Handle *config;
 414
 415
 416 /**
 417  * Function called to notify a client about the connection begin ready to queue
 418  * more data.  "buf" will be NULL and "size" zero if the connection was closed
 419  * for writing in the meantime.
 420  *
 421  * @param cls NULL
 422  * @param size number of bytes available in buf
 423  * @param buf where the callee should write the message
 424  * @return number of bytes written to buf
 425  */
 426 static size_t
 427 transmit_ready_notify (void *cls, size_t size, void *buf)
 428 {
 429   struct MessageQueue *mq_entry;
 430
 431   transmit_handle = NULL;
 432   mq_entry = mq_head;
 433   GNUNET_assert (NULL != mq_entry);
 434   if (0 == size)
 435     return 0;
 436   GNUNET_assert (ntohs (mq_entry->msg->size) <= size);
 437   size = ntohs (mq_entry->msg->size);
 438   memcpy (buf, mq_entry->msg, size);
 439   GNUNET_free (mq_entry->msg);
 440   GNUNET_CONTAINER_DLL_remove (mq_head, mq_tail, mq_entry);
 441   GNUNET_free (mq_entry);
 442   mq_entry = mq_head;
 443   if (NULL != mq_entry)
 444     transmit_handle =
 445       GNUNET_SERVER_notify_transmit_ready (mq_entry->client,
 446                                            ntohs (mq_entry->msg->size),
 447                                            GNUNET_TIME_UNIT_FOREVER_REL,
 448                                            &transmit_ready_notify, NULL);
 449   return size;
 450 }
 451
 452
 453 /**
 454  * Queues a message in send queue for sending to the service
 455  *
 456  * @param client the client to whom the queued message has to be sent
 457  * @param msg the message to queue
 458  */
 459 static void
 460 queue_message (struct GNUNET_SERVER_Client *client,
 461                struct GNUNET_MessageHeader *msg)
 462 {
 463   struct MessageQueue *mq_entry;
 464   uint16_t type;
 465   uint16_t size;
 466
 467   type = ntohs (msg->type);
 468   size = ntohs (msg->size);
 469   GNUNET_assert ((GNUNET_MESSAGE_TYPE_TESTBED_INIT <= type) &&
 470                  (GNUNET_MESSAGE_TYPE_TESTBED_MAX > type));
 471   mq_entry = GNUNET_malloc (sizeof (struct MessageQueue));
 472   mq_entry->msg = msg;
 473   mq_entry->client = client;
 474   LOG_DEBUG ( "Queueing message of type %u, size %u for sending\n", type,
 475               ntohs (msg->size));
 476   GNUNET_CONTAINER_DLL_insert_tail (mq_head, mq_tail, mq_entry);
 477   if (NULL == transmit_handle)
 478     transmit_handle =
 479       GNUNET_SERVER_notify_transmit_ready (client, size,
 480                                            GNUNET_TIME_UNIT_FOREVER_REL,
 481                                            &transmit_ready_notify, NULL);
 482 }
 483
 484
 485 /**
 486  * Similar to GNUNET_realloc; however clears tail part of newly allocated memory
 487  *
 488  * @param ptr the memory block to realloc
 489  * @param size the size of ptr
 490  * @param new_size the size to which ptr has to be realloc'ed
 491  * @return the newly reallocated memory block
 492  */
 493 static void *
 494 TESTBED_realloc (void *ptr, size_t size, size_t new_size)
 495 {
 496   ptr = GNUNET_realloc (ptr, new_size);
 497   if (new_size > size)
 498     ptr = memset (ptr + size, 0, new_size - size);
 499   return ptr;
 500 }
 501
 502
 503 /**
 504  * Function to add a host to the current list of known hosts
 505  *
 506  * @param host the host to add
 507  * @return GNUNET_OK on success; GNUNET_SYSERR on failure due to host-id
 508  *           already in use
 509  */
 510 static int
 511 host_list_add (struct GNUNET_TESTBED_Host *host)
 512 {
 513   uint32_t host_id;
 514
 515   host_id = GNUNET_TESTBED_host_get_id_ (host);
 516   if (host_list_size <= host_id)
 517   {
 518     host_list =
 519       TESTBED_realloc (host_list,
 520                        sizeof (struct GNUNET_TESTBED_Host *) * host_list_size,
 521                        sizeof (struct GNUNET_TESTBED_Host *) *
 522                        (host_list_size + LIST_GROW_STEP));
 523     host_list_size += LIST_GROW_STEP;
 524   }
 525   if (NULL != host_list[host_id])
 526   {
 527     LOG_DEBUG ("A host with id: %u already exists\n", host_id);
 528     return GNUNET_SYSERR;
 529   }
 530   host_list[host_id] = host;
 531   return GNUNET_OK;
 532 }
 533
 534
 535 /**
 536  * Adds a route to the route list
 537  *
 538  * @param route the route to add
 539  */
 540 static void
 541 route_list_add (struct Route *route)
 542 {
 543   if (route->dest >= route_list_size)
 544   {
 545     route_list =
 546       TESTBED_realloc (route_list,
 547                        sizeof (struct Route *) * route_list_size,
 548                        sizeof (struct Route *) *
 549                        (route_list_size + LIST_GROW_STEP));
 550     route_list_size += LIST_GROW_STEP;
 551   }
 552   GNUNET_assert (NULL == route_list[route->dest]);
 553   route_list[route->dest] = route;
 554 }
 555
 556
 557 /**
 558  * Adds a slave to the slave array
 559  *
 560  * @param route the route to add
 561  */
 562 static void
 563 slave_list_add (struct Slave *slave)
 564 {
 565   if (slave->host_id  >= slave_list_size)
 566   {
 567     slave_list = TESTBED_realloc (slave_list,
 568                                   sizeof (struct Slave *) *slave_list_size,
 569                                   sizeof (struct Slave *) *
 570                                   (slave_list_size + LIST_GROW_STEP));
 571     slave_list_size += LIST_GROW_STEP;
 572   }
 573   GNUNET_assert (NULL == slave_list[slave->host_id]);
 574   slave_list[slave->host_id] = slave;
 575 }
 576
 577
 578 /**
 579  * Adds a peer to the peer array
 580  *
 581  * @param route the route to add
 582  */
 583 static void
 584 peer_list_add (struct Peer *peer)
 585 {
 586   if (peer->id  >= peer_list_size)
 587   {
 588     peer_list = TESTBED_realloc (peer_list,
 589                                  sizeof (struct Peer *) * peer_list_size,
 590                                  sizeof (struct Peer *) *
 591                                  (peer_list_size + LIST_GROW_STEP));
 592     peer_list_size += LIST_GROW_STEP;
 593   }
 594   GNUNET_assert (NULL == peer_list[peer->id]);
 595   peer_list[peer->id] = peer;
 596 }
 597
 598
 599 /**
 600  * Routes message to a host given its host_id
 601  *
 602  * @param host_id the id of the destination host
 603  * @param msg the message to be routed
 604  */
 605 static void
 606 route_message (uint32_t host_id, const struct GNUNET_MessageHeader *msg)
 607 {
 608   GNUNET_break (0);
 609 }
 610
 611
 612 /**
 613  * The  Link Controller forwarding task
 614  *
 615  * @param cls the LCFContext
 616  * @param tc the Task context from scheduler
 617  */
 618 static void
 619 lcf_proc_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 620
 621
 622 /**
 623  * Completion callback for host registrations while forwarding Link Controller messages
 624  *
 625  * @param cls the LCFContext
 626  * @param emsg the error message; NULL if host registration is successful
 627  */
 628 static void
 629 lcf_proc_cc (void *cls, const char *emsg)
 630 {
 631   struct LCFContext *lcf = cls;
 632
 633   lcf->rhandle = NULL;
 634   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == lcf_proc_task_id);
 635   switch (lcf->state)
 636   {
 637   case INIT:
 638     if (NULL != emsg)
 639     {
 640       LOG (GNUNET_ERROR_TYPE_WARNING,
 641            "Host registration failed with message: %s\n", emsg);
 642       lcf->state = FINISHED;
 643       lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcf);
 644       return;
 645     }
 646     lcf->state = DELEGATED_HOST_REGISTERED;
 647     lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcf);
 648     break;
 649   default:
 650     GNUNET_assert (0);          /* Shouldn't reach here */
 651   }
 652 }
 653
 654
 655 /**
 656  * The  Link Controller forwarding task
 657  *
 658  * @param cls the LCFContext
 659  * @param tc the Task context from scheduler
 660  */
 661 static void
 662 lcf_proc_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 663 {
 664   struct LCFContext *lcf = cls;
 665   struct LCFContextQueue *lcfq;
 666
 667   lcf_proc_task_id = GNUNET_SCHEDULER_NO_TASK;
 668   switch (lcf->state)
 669   {
 670   case INIT:
 671     if (GNUNET_NO ==
 672         GNUNET_TESTBED_is_host_registered_ (host_list[lcf->delegated_host_id],
 673                                             lcf->gateway->controller))
 674     {
 675       lcf->rhandle =
 676         GNUNET_TESTBED_register_host (lcf->gateway->controller,
 677                                       host_list[lcf->delegated_host_id],
 678                                       lcf_proc_cc, lcf);
 679     }
 680     else
 681     {
 682       lcf->state = DELEGATED_HOST_REGISTERED;
 683       lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcf);
 684     }
 685     break;
 686   case DELEGATED_HOST_REGISTERED:
 687     GNUNET_TESTBED_controller_link_2 (lcf->gateway->controller,
 688                                       host_list[lcf->delegated_host_id],
 689                                       host_list[lcf->gateway->host_id],
 690                                       lcf->sxcfg, lcf->sxcfg_size,
 691                                       lcf->scfg_size,
 692                                       lcf->is_subordinate);
 693     lcf->state = FINISHED;
 694   case FINISHED:
 695     lcfq = lcfq_head;
 696     GNUNET_assert (lcfq->lcf == lcf);
 697     GNUNET_free (lcf->sxcfg);
 698     GNUNET_free (lcf);
 699     GNUNET_CONTAINER_DLL_remove (lcfq_head, lcfq_tail, lcfq);
 700     GNUNET_free (lcfq);
 701     if (NULL != lcfq_head)
 702       lcf_proc_task_id =
 703         GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcfq_head->lcf);
 704   }
 705 }
 706
 707
 708 /**
 709  * Callback for event from slave controllers
 710  *
 711  * @param cls struct Slave *
 712  * @param event information about the event
 713  */
 714 static void
 715 slave_event_callback(void *cls,
 716                      const struct GNUNET_TESTBED_EventInformation *event)
 717 {
 718   GNUNET_break (0);
 719 }
 720
 721
 722 /**
 723  * Callback to signal successfull startup of the controller process
 724  *
 725  * @param cls the closure from GNUNET_TESTBED_controller_start()
 726  * @param cfg the configuration with which the controller has been started;
 727  *          NULL if status is not GNUNET_OK
 728  * @param status GNUNET_OK if the startup is successfull; GNUNET_SYSERR if not,
 729  *          GNUNET_TESTBED_controller_stop() shouldn't be called in this case
 730  */
 731 static void
 732 slave_status_callback (void *cls,
 733                        const struct GNUNET_CONFIGURATION_Handle *cfg,
 734                        int status)
 735 {
 736   struct SlaveContext *sc = cls;
 737
 738   if (GNUNET_SYSERR == status)
 739   {
 740     sc->slave->controller_proc = NULL;
 741     LOG (GNUNET_ERROR_TYPE_WARNING,
 742          "Unexpected slave shutdown\n");
 743     GNUNET_SCHEDULER_shutdown ();       /* We too shutdown */
 744     return;
 745   }
 746   GNUNET_CONFIGURATION_destroy (sc->cfg);
 747   sc->slave->controller =
 748     GNUNET_TESTBED_controller_connect (cfg, host_list[sc->slave->host_id],
 749                                        master_context->event_mask,
 750                                        &slave_event_callback, sc->slave);
 751   GNUNET_free (sc);
 752 }
 753
 754
 755 /**
 756  * Message handler for GNUNET_MESSAGE_TYPE_TESTBED_INIT messages
 757  *
 758  * @param cls NULL
 759  * @param client identification of the client
 760  * @param message the actual message
 761  */
 762 static void
 763 handle_init (void *cls,
 764              struct GNUNET_SERVER_Client *client,
 765              const struct GNUNET_MessageHeader *message)
 766 {
 767   const struct GNUNET_TESTBED_InitMessage *msg;
 768   struct GNUNET_TESTBED_Host *host;
 769   void *addr;
 770   size_t addrlen;
 771
 772   if (NULL != master_context)
 773   {
 774     GNUNET_break (0);
 775     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 776     return;
 777   }
 778   msg = (const struct GNUNET_TESTBED_InitMessage *) message;
 779   master_context = GNUNET_malloc (sizeof (struct Context));
 780   master_context->client = client;
 781   master_context->host_id = ntohl (msg->host_id);
 782   GNUNET_assert (GNUNET_OK ==
 783                  GNUNET_SERVER_client_get_address (client, &addr, &addrlen));
 784   master_context->master_ip = GNUNET_malloc (NI_MAXHOST);
 785   if (0 != getnameinfo (addr, addrlen, master_context->master_ip, NI_MAXHOST,
 786                         NULL, 0, NI_NUMERICHOST))
 787   {
 788     LOG (GNUNET_ERROR_TYPE_WARNING,
 789          "Cannot determine the ip of master controller: %s\n", STRERROR (errno));
 790     GNUNET_assert (0);
 791   }
 792   master_context->system =
 793     GNUNET_TESTING_system_create ("testbed", master_context->master_ip);
 794   host = GNUNET_TESTBED_host_create_with_id (master_context->host_id,
 795                                              NULL, NULL, 0);
 796   host_list_add (host);
 797   master_context->event_mask = GNUNET_ntohll (msg->event_mask);
 798   GNUNET_SERVER_client_keep (client);
 799   LOG_DEBUG ("Created master context with host ID: %u\n",
 800              master_context->host_id);
 801   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 802 }
 803
 804
 805 /**
 806  * Message handler for GNUNET_MESSAGE_TYPE_TESTBED_ADDHOST messages
 807  *
 808  * @param cls NULL
 809  * @param client identification of the client
 810  * @param message the actual message
 811  */
 812 static void
 813 handle_add_host (void *cls,
 814                  struct GNUNET_SERVER_Client *client,
 815                  const struct GNUNET_MessageHeader *message)
 816 {
 817   struct GNUNET_TESTBED_Host *host;
 818   const struct GNUNET_TESTBED_AddHostMessage *msg;
 819   struct GNUNET_TESTBED_HostConfirmedMessage *reply;
 820   char *username;
 821   char *hostname;
 822   char *emsg;
 823   uint32_t host_id;
 824   uint16_t username_length;
 825   uint16_t hostname_length;
 826   uint16_t reply_size;
 827
 828   msg = (const struct GNUNET_TESTBED_AddHostMessage *) message;
 829   username_length = ntohs (msg->user_name_length);
 830   username_length = (0 == username_length) ? 0 : username_length + 1;
 831   username = (char *) &(msg[1]);
 832   hostname = username + username_length;
 833   if (ntohs (message->size) <=
 834       (sizeof (struct GNUNET_TESTBED_AddHostMessage) + username_length))
 835   {
 836     GNUNET_break (0);
 837     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 838     return;
 839   }
 840   hostname_length = ntohs (message->size)
 841     - (sizeof (struct GNUNET_TESTBED_AddHostMessage) + username_length);
 842   if (strlen (hostname) != hostname_length - 1)
 843   {
 844     GNUNET_break (0);
 845     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 846     return;
 847   }
 848   host_id = ntohl (msg->host_id);
 849   LOG_DEBUG ("Received ADDHOST message\n");
 850   LOG_DEBUG ("-------host id: %u\n", host_id);
 851   if (NULL != hostname) LOG_DEBUG ("-------hostname: %s\n", hostname);
 852   if (0 != username_length) LOG_DEBUG ("-------username: %s\n", username);
 853   else LOG_DEBUG ("-------username: NULL\n");
 854   LOG_DEBUG ("-------ssh port: %u\n", ntohs (msg->ssh_port));
 855   host = GNUNET_TESTBED_host_create_with_id (host_id, hostname, username,
 856                                              ntohs (msg->ssh_port));
 857   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 858   reply_size = sizeof (struct GNUNET_TESTBED_HostConfirmedMessage);
 859   if (GNUNET_OK != host_list_add (host))
 860   {
 861     /* We are unable to add a host */
 862     emsg = "A host exists with given host-id";
 863     LOG_DEBUG ("%s: %u", emsg, host_id);
 864     GNUNET_TESTBED_host_destroy (host);
 865     reply_size += strlen (emsg) + 1;
 866     reply = GNUNET_malloc (reply_size);
 867     memcpy (&reply[1], emsg, strlen (emsg) + 1);
 868   }
 869   else
 870     reply = GNUNET_malloc (reply_size);
 871   reply->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_ADDHOSTCONFIRM);
 872   reply->header.size = htons (reply_size);
 873   reply->host_id = htonl (host_id);
 874   queue_message (client, (struct GNUNET_MessageHeader *) reply);
 875 }
 876
 877
 878 /**
 879  * Iterator over hash map entries.
 880  *
 881  * @param cls closure
 882  * @param key current key code
 883  * @param value value in the hash map
 884  * @return GNUNET_YES if we should continue to
 885  *         iterate,
 886  *         GNUNET_NO if not.
 887  */
 888 int ss_exists_iterator (void *cls,
 889                         const struct GNUNET_HashCode * key,
 890                         void *value)
 891 {
 892   struct SharedService *queried_ss = cls;
 893   struct SharedService *ss = value;
 894
 895   if (0 == strcmp (ss->name, queried_ss->name))
 896     return GNUNET_NO;
 897   else
 898     return GNUNET_YES;
 899 }
 900
 901
 902 /**
 903  * Message handler for GNUNET_MESSAGE_TYPE_TESTBED_ADDHOST messages
 904  *
 905  * @param cls NULL
 906  * @param client identification of the client
 907  * @param message the actual message
 908  */
 909 static void
 910 handle_configure_shared_service (void *cls,
 911                                  struct GNUNET_SERVER_Client *client,
 912                                  const struct GNUNET_MessageHeader *message)
 913 {
 914   const struct GNUNET_TESTBED_ConfigureSharedServiceMessage *msg;
 915   struct SharedService *ss;
 916   char *service_name;
 917   struct GNUNET_HashCode hash;
 918   uint16_t msg_size;
 919   uint16_t service_name_size;
 920
 921   msg = (const struct GNUNET_TESTBED_ConfigureSharedServiceMessage *) message;
 922   msg_size = ntohs (message->size);
 923   if (msg_size <= sizeof (struct GNUNET_TESTBED_ConfigureSharedServiceMessage))
 924   {
 925     GNUNET_break (0);
 926     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 927     return;
 928   }
 929   service_name_size = msg_size -
 930     sizeof (struct GNUNET_TESTBED_ConfigureSharedServiceMessage);
 931   service_name = (char *) &msg[1];
 932   if ('\0' != service_name[service_name_size - 1])
 933   {
 934     GNUNET_break (0);
 935     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 936     return;
 937   }
 938   LOG_DEBUG ("Received service sharing request for %s, with %d peers\n",
 939              service_name, ntohl (msg->num_peers));
 940   if (ntohl (msg->host_id) != master_context->host_id)
 941   {
 942     route_message (ntohl (msg->host_id), message);
 943     GNUNET_SERVER_receive_done (client, GNUNET_OK);
 944     return;
 945   }
 946   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 947   ss = GNUNET_malloc (sizeof (struct SharedService));
 948   ss->name = strdup (service_name);
 949   ss->num_shared = ntohl (msg->num_peers);
 950   GNUNET_CRYPTO_hash (ss->name, service_name_size, &hash);
 951   if (GNUNET_SYSERR ==
 952       GNUNET_CONTAINER_multihashmap_get_multiple (ss_map, &hash,
 953                                                   &ss_exists_iterator, ss))
 954   {
 955     LOG (GNUNET_ERROR_TYPE_WARNING,
 956          "Service %s already configured as a shared service. "
 957          "Ignoring service sharing request \n", ss->name);
 958     GNUNET_free (ss->name);
 959     GNUNET_free (ss);
 960     return;
 961   }
 962   GNUNET_CONTAINER_multihashmap_put (ss_map, &hash, ss,
 963                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
 964 }
 965
 966
 967 /**
 968  * Message handler for GNUNET_MESSAGE_TYPE_TESTBED_LCONTROLLERS message
 969  *
 970  * @param cls NULL
 971  * @param client identification of the client
 972  * @param message the actual message
 973  */
 974 static void
 975 handle_link_controllers (void *cls,
 976                          struct GNUNET_SERVER_Client *client,
 977                          const struct GNUNET_MessageHeader *message)
 978 {
 979   const struct GNUNET_TESTBED_ControllerLinkMessage *msg;
 980   struct GNUNET_CONFIGURATION_Handle *cfg;
 981   struct SlaveContext *sc;
 982   struct LCFContextQueue *lcfq;
 983   struct Route *route;
 984   struct Route *new_route;
 985   char *config;
 986   uLongf dest_size;
 987   size_t config_size;
 988   uint32_t delegated_host_id;
 989   uint32_t slave_host_id;
 990   uint16_t msize;
 991
 992   if (NULL == master_context)
 993   {
 994     GNUNET_break (0);
 995     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 996     return;
 997   }
 998   msize = ntohs (message->size);
 999   if (sizeof (struct GNUNET_TESTBED_ControllerLinkMessage) >= msize)
1000   {
1001     GNUNET_break (0);
1002     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1003     return;
1004   }
1005   msg = (const struct GNUNET_TESTBED_ControllerLinkMessage *) message;
1006   delegated_host_id = ntohl (msg->delegated_host_id);
1007   if (delegated_host_id == master_context->host_id)
1008   {
1009     GNUNET_break (0);
1010     LOG (GNUNET_ERROR_TYPE_WARNING, "Trying to link ourselves\n");
1011     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1012     return;
1013   }
1014   if ((delegated_host_id >= host_list_size) ||
1015       (NULL == host_list[delegated_host_id]))
1016   {
1017     LOG (GNUNET_ERROR_TYPE_WARNING, "Delegated host not registered with us\n");
1018     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1019     return;
1020   }
1021   slave_host_id = ntohl (msg->slave_host_id);
1022   if ((slave_host_id >= host_list_size) || (NULL == host_list[slave_host_id]))
1023   {
1024     LOG (GNUNET_ERROR_TYPE_WARNING, "Slave host not registered with us\n");
1025     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1026     return;
1027   }
1028   if (slave_host_id == delegated_host_id)
1029   {
1030     LOG (GNUNET_ERROR_TYPE_WARNING, "Slave and delegated host are same\n");
1031     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1032     return;
1033   }
1034   msize -= sizeof (struct GNUNET_TESTBED_ControllerLinkMessage);
1035   config_size = ntohs (msg->config_size);
1036
1037   if (slave_host_id == master_context->host_id) /* Link from us */
1038   {
1039     struct Slave *slave;
1040
1041     if ((delegated_host_id < slave_list_size) &&
1042         (NULL != slave_list[delegated_host_id])) /* We have already added */
1043     {
1044       LOG (GNUNET_ERROR_TYPE_WARNING, "Host %u already connected\n",
1045            delegated_host_id);
1046       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1047       return;
1048     }
1049     config = GNUNET_malloc (config_size);
1050     dest_size = (uLongf) config_size;
1051     if (Z_OK != uncompress ((Bytef *) config, &dest_size,
1052                             (const Bytef *) &msg[1], (uLong) msize))
1053     {
1054       GNUNET_break (0);           /* Compression error */
1055       GNUNET_free (config);
1056       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1057       return;
1058     }
1059     if (config_size == dest_size)
1060     {
1061       LOG (GNUNET_ERROR_TYPE_WARNING, "Uncompressed config size mismatch\n");
1062       GNUNET_free (config);
1063       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1064     }
1065     cfg = GNUNET_CONFIGURATION_create (); /* Free here or in lcfcontext */
1066     if (GNUNET_OK != GNUNET_CONFIGURATION_deserialize (cfg, config, config_size,
1067                                                        GNUNET_NO))
1068     {
1069       GNUNET_break (0);           /* Configuration parsing error */
1070       GNUNET_free (config);
1071       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1072       return;
1073     }
1074     GNUNET_free (config);
1075     if ((delegated_host_id < slave_list_size) &&
1076         (NULL != slave_list[delegated_host_id]))
1077     {
1078       GNUNET_break (0);           /* Configuration parsing error */
1079       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1080       return;
1081     }
1082     slave = GNUNET_malloc (sizeof (struct Slave));
1083     slave->host_id = delegated_host_id;
1084     slave_list_add (slave);
1085     sc = GNUNET_malloc (sizeof (struct SlaveContext));
1086     sc->slave = slave;
1087     sc->cfg = cfg;
1088     if (1 == msg->is_subordinate)
1089     {
1090       slave->controller_proc =
1091         GNUNET_TESTBED_controller_start (master_context->master_ip,
1092                                          host_list[slave->host_id],
1093                                          cfg, &slave_status_callback,
1094                                          sc);
1095     }
1096     new_route = GNUNET_malloc (sizeof (struct Route));
1097     new_route->dest = delegated_host_id;
1098     new_route->thru = master_context->host_id;
1099     route_list_add (new_route);
1100     GNUNET_SERVER_receive_done (client, GNUNET_OK);
1101     return;
1102   }
1103
1104   /* Route the request */
1105   if (slave_host_id >= route_list_size)
1106   {
1107     LOG (GNUNET_ERROR_TYPE_WARNING, "No route towards slave host");
1108     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1109     return;
1110   }
1111   while (NULL != (route = route_list[slave_host_id]))
1112   {
1113     if (route->thru == master_context->host_id)
1114       break;
1115     slave_host_id = route->thru;
1116   }
1117   GNUNET_assert (NULL != route); /* because we add routes carefully */
1118   GNUNET_assert (route->dest < slave_list_size);
1119   GNUNET_assert (NULL != slave_list[route->dest]);
1120   lcfq = GNUNET_malloc (sizeof (struct LCFContextQueue));
1121   lcfq->lcf = GNUNET_malloc (sizeof (struct LCFContext));
1122   lcfq->lcf->delegated_host_id = delegated_host_id;
1123   lcfq->lcf->is_subordinate =
1124     (1 == msg->is_subordinate) ? GNUNET_YES : GNUNET_NO;
1125   lcfq->lcf->state = INIT;
1126   lcfq->lcf->gateway = slave_list[route->dest];
1127   lcfq->lcf->sxcfg_size = msize;
1128   lcfq->lcf->sxcfg = GNUNET_malloc (msize);
1129   lcfq->lcf->scfg_size = config_size;
1130   (void) memcpy (lcfq->lcf->sxcfg, &msg[1], msize);
1131   if (NULL == lcfq_head)
1132   {
1133     GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == lcf_proc_task_id);
1134     GNUNET_CONTAINER_DLL_insert_tail (lcfq_head, lcfq_tail, lcfq);
1135     lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcfq);
1136   }
1137   else
1138     GNUNET_CONTAINER_DLL_insert_tail (lcfq_head, lcfq_tail, lcfq);
1139   GNUNET_SERVER_receive_done (client, GNUNET_OK);
1140   new_route = GNUNET_malloc (sizeof (struct Route));
1141   new_route->dest = delegated_host_id;
1142   new_route->thru = route->dest;
1143   route_list_add (new_route);
1144 }
1145
1146
1147 /**
1148  * Handler for GNUNET_MESSAGE_TYPE_TESTBED_CREATEPEER messages
1149  *
1150  * @param cls NULL
1151  * @param client identification of the client
1152  * @param message the actual message
1153  */
1154 static void
1155 handle_peer_create (void *cls,
1156                     struct GNUNET_SERVER_Client *client,
1157                     const struct GNUNET_MessageHeader *message)
1158 {
1159   const struct GNUNET_TESTBED_PeerCreateMessage *msg;
1160   struct GNUNET_TESTBED_PeerCreateSuccessEventMessage *reply;
1161   struct GNUNET_CONFIGURATION_Handle *cfg;
1162   char *config;
1163   size_t dest_size;
1164   int ret;
1165   uint32_t config_size;
1166   uint16_t msize;
1167
1168
1169   msize = ntohs (message->size);
1170   if (msize <= sizeof (struct GNUNET_TESTBED_PeerCreateMessage))
1171   {
1172     GNUNET_break (0);           /* We need configuration */
1173     GNUNET_SERVER_receive_done (client, GNUNET_OK);
1174     return;
1175   }
1176   msg = (const struct GNUNET_TESTBED_PeerCreateMessage *) message;
1177   if (ntohl (msg->host_id) == master_context->host_id)
1178   {
1179     struct Peer *peer;
1180     char *emsg;
1181
1182     /* We are responsible for this peer */
1183     msize -= sizeof (struct GNUNET_TESTBED_PeerCreateMessage);
1184     config_size = ntohl (msg->config_size);
1185     config = GNUNET_malloc (config_size);
1186     dest_size = config_size;
1187     if (Z_OK != (ret = uncompress ((Bytef *) config, (uLongf *) &dest_size,
1188                                    (const Bytef *) &msg[1], (uLong) msize)))
1189     {
1190       GNUNET_break (0);           /* uncompression error */
1191       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1192       return;
1193     }
1194     if (config_size != dest_size)
1195     {
1196       GNUNET_break (0);/* Uncompressed config size mismatch */
1197       GNUNET_free (config);
1198       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1199       return;
1200     }
1201     cfg = GNUNET_CONFIGURATION_create ();
1202     if (GNUNET_OK != GNUNET_CONFIGURATION_deserialize (cfg, config, config_size,
1203                                                        GNUNET_NO))
1204     {
1205       GNUNET_break (0);           /* Configuration parsing error */
1206       GNUNET_free (config);
1207       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1208       return;
1209     }
1210     GNUNET_free (config);
1211     peer = GNUNET_malloc (sizeof (struct Peer));
1212     peer->cfg = cfg;
1213     peer->id = ntohl (msg->peer_id);
1214     LOG_DEBUG ("Creating peer with id: %u\n", peer->id);
1215     peer->peer = GNUNET_TESTING_peer_configure (master_context->system, peer->cfg,
1216                                                 peer->id,
1217                                                 NULL /* Peer id */,
1218                                                 &emsg);
1219     if (NULL == peer->peer)
1220     {
1221       LOG (GNUNET_ERROR_TYPE_WARNING, "Configuring peer failed: %s\n", emsg);
1222       GNUNET_free (emsg);
1223       GNUNET_break (0);
1224       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
1225       return;
1226     }
1227     peer_list_add (peer);
1228     reply = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_PeerCreateSuccessEventMessage));
1229     reply->header.size = htons (sizeof (struct GNUNET_TESTBED_PeerCreateSuccessEventMessage));
1230     reply->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_PEERCREATESUCCESS);
1231     reply->peer_id = msg->peer_id;
1232     reply->operation_id = msg->operation_id;
1233     queue_message (client, &reply->header);
1234     GNUNET_SERVER_receive_done (client, GNUNET_OK);
1235     return;
1236   }
1237
1238   /* FIXME: Forward the peer to other host */
1239   GNUNET_break (0);
1240   GNUNET_SERVER_receive_done (client, GNUNET_OK);
1241 }
1242
1243
1244 /**
1245  * Message handler for GNUNET_MESSAGE_TYPE_TESTBED_DESTROYPEER messages
1246  *
1247  * @param cls NULL
1248  * @param client identification of the client
1249  * @param message the actual message
1250  */
1251 static void
1252 handle_peer_destroy (void *cls,
1253                      struct GNUNET_SERVER_Client *client,
1254                      const struct GNUNET_MessageHeader *message)
1255 {
1256   const struct GNUNET_TESTBED_PeerDestroyMessage *msg;
1257   struct GNUNET_TESTBED_GenericOperationSuccessEventMessage *reply;
1258   uint32_t peer_id;
1259   uint32_t id;
1260   uint16_t reply_size;
1261
1262   msg = (const struct GNUNET_TESTBED_PeerDestroyMessage *) message;
1263   peer_id = ntohl (msg->peer_id);
1264   LOG_DEBUG ("Received peer destory on peer: %u and operation id: %ul\n",
1265              peer_id, GNUNET_ntohll (msg->operation_id));
1266   if ((peer_list_size <= peer_id) || (NULL == peer_list[peer_id]))
1267   {
1268     GNUNET_break (0);
1269     /* FIXME: Reply with failure event message or forward to slave controller */
1270     GNUNET_SERVER_receive_done (client, GNUNET_OK);
1271     return;
1272   }
1273   GNUNET_TESTING_peer_destroy (peer_list[peer_id]->peer);
1274   GNUNET_CONFIGURATION_destroy (peer_list[peer_id]->cfg);
1275   GNUNET_free (peer_list[peer_id]);
1276   peer_list[peer_id] = NULL;
1277   for (id = 0; id < LIST_GROW_STEP; id++)
1278   {
1279     if (((peer_id + id >= peer_list_size) ||
1280          (NULL != peer_list[peer_id])))
1281       break;
1282   }
1283   if (LIST_GROW_STEP == id)
1284   {
1285     peer_list_size -= LIST_GROW_STEP;
1286     peer_list = GNUNET_realloc (peer_list, peer_list_size);
1287   }
1288   reply_size =
1289     sizeof (struct GNUNET_TESTBED_GenericOperationSuccessEventMessage);
1290   reply = GNUNET_malloc (reply_size);
1291   reply->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_GENERICOPSUCCESS);
1292   reply->header.size = htons (reply_size);
1293   reply->operation_id = msg->operation_id;
1294   reply->event_type = htonl (GNUNET_TESTBED_ET_OPERATION_FINISHED);
1295   queue_message (client, &reply->header);
1296   GNUNET_SERVER_receive_done (client, GNUNET_OK);
1297 }
1298
1299
1300 /**
1301  * Message handler for GNUNET_MESSAGE_TYPE_TESTBED_DESTROYPEER messages
1302  *
1303  * @param cls NULL
1304  * @param client identification of the client
1305  * @param message the actual message
1306  */
1307 static void
1308 handle_peer_start (void *cls,
1309                    struct GNUNET_SERVER_Client *client,
1310                    const struct GNUNET_MessageHeader *message)
1311 {
1312   const struct GNUNET_TESTBED_PeerStartMessage *msg;
1313   struct GNUNET_TESTBED_PeerEventMessage *reply;
1314   uint32_t peer_id;
1315
1316   msg = (const struct GNUNET_TESTBED_PeerStartMessage *) message;
1317   peer_id = ntohl (msg->peer_id);
1318   if ((peer_id >= peer_list_size)
1319       || (NULL == peer_list[peer_id])
1320       || (GNUNET_OK != GNUNET_TESTING_peer_start (peer_list[peer_id]->peer)))
1321   {
1322     GNUNET_break (0);
1323     /* FIXME: reply with failure message or forward to slave controller */
1324     GNUNET_SERVER_receive_done (client, GNUNET_OK);
1325     return;
1326   }
1327   if (GNUNET_OK != GNUNET_TESTING_peer_start (peer_list[peer_id]->peer))
1328   {
1329     /* FIXME: return FAILURE message */
1330     GNUNET_break (0);
1331     GNUNET_SERVER_receive_done (client, GNUNET_OK);
1332     return;
1333   }
1334   reply = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_PeerEventMessage));
1335   reply->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_PEEREVENT);
1336   reply->header.size = htons (sizeof (struct GNUNET_TESTBED_PeerEventMessage));
1337   reply->event_type = htonl (GNUNET_TESTBED_ET_PEER_START);
1338   reply->host_id = htonl (master_context->host_id);
1339   reply->peer_id = msg->peer_id;
1340   reply->operation_id = msg->operation_id;
1341   queue_message (client, &reply->header);
1342   GNUNET_SERVER_receive_done (client, GNUNET_OK);
1343 }
1344
1345
1346 /**
1347  * Message handler for GNUNET_MESSAGE_TYPE_TESTBED_DESTROYPEER messages
1348  *
1349  * @param cls NULL
1350  * @param client identification of the client
1351  * @param message the actual message
1352  */
1353 static void
1354 handle_peer_stop (void *cls,
1355                   struct GNUNET_SERVER_Client *client,
1356                   const struct GNUNET_MessageHeader *message)
1357 {
1358   const struct GNUNET_TESTBED_PeerStopMessage *msg;
1359   struct GNUNET_TESTBED_PeerEventMessage *reply;
1360   uint32_t peer_id;
1361
1362   msg = (const struct GNUNET_TESTBED_PeerStopMessage *) message;
1363   peer_id = ntohl (msg->peer_id);
1364   if ((peer_id >= peer_list_size) || (NULL == peer_list[peer_id]))
1365   {
1366     GNUNET_break (0);           /* FIXME: route to slave? */
1367     GNUNET_SERVER_receive_done (client, GNUNET_OK);
1368     return;
1369   }
1370   if (GNUNET_OK != GNUNET_TESTING_peer_stop (peer_list[peer_id]->peer))
1371   {
1372     /* FIXME: return FAILURE message */
1373     GNUNET_break (0);
1374     GNUNET_SERVER_receive_done (client, GNUNET_OK);
1375     return;
1376   }
1377   reply = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_PeerEventMessage));
1378   reply->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_PEEREVENT);
1379   reply->header.size = htons (sizeof (struct GNUNET_TESTBED_PeerEventMessage));
1380   reply->event_type = htonl (GNUNET_TESTBED_ET_PEER_STOP);
1381   reply->host_id = htonl (master_context->host_id);
1382   reply->peer_id = msg->peer_id;
1383   reply->operation_id = msg->operation_id;
1384   queue_message (client, &reply->header);
1385   GNUNET_SERVER_receive_done (client, GNUNET_OK);
1386 }
1387
1388
1389 /**
1390  * Iterator over hash map entries.
1391  *
1392  * @param cls closure
1393  * @param key current key code
1394  * @param value value in the hash map
1395  * @return GNUNET_YES if we should continue to
1396  *         iterate,
1397  *         GNUNET_NO if not.
1398  */
1399 static int
1400 ss_map_free_iterator (void *cls,
1401                       const struct GNUNET_HashCode * key, void *value)
1402 {
1403   struct SharedService *ss = value;
1404
1405   GNUNET_assert (GNUNET_YES ==
1406                  GNUNET_CONTAINER_multihashmap_remove (ss_map, key, value));
1407   GNUNET_free (ss->name);
1408   GNUNET_free (ss);
1409   return GNUNET_YES;
1410 }
1411
1412
1413 /**
1414  * Task to clean up and shutdown nicely
1415  *
1416  * @param cls NULL
1417  * @param tc the TaskContext from scheduler
1418  */
1419 static void
1420 shutdown_task (void *cls,
1421                const struct GNUNET_SCHEDULER_TaskContext *tc)
1422 {
1423   struct LCFContextQueue *lcfq;
1424   uint32_t id;
1425
1426   shutdown_task_id = GNUNET_SCHEDULER_NO_TASK;
1427   LOG (GNUNET_ERROR_TYPE_DEBUG, "Shutting down testbed service\n");
1428   (void) GNUNET_CONTAINER_multihashmap_iterate (ss_map, &ss_map_free_iterator,
1429                                                 NULL);
1430   GNUNET_CONTAINER_multihashmap_destroy (ss_map);
1431   if (NULL != fh)
1432   {
1433     GNUNET_DISK_file_close (fh);
1434     fh = NULL;
1435   }
1436   if (NULL != lcfq_head)
1437   {
1438     if (GNUNET_SCHEDULER_NO_TASK != lcf_proc_task_id)
1439     {
1440       GNUNET_SCHEDULER_cancel (lcf_proc_task_id);
1441       lcf_proc_task_id = GNUNET_SCHEDULER_NO_TASK;
1442     }
1443     if (NULL != lcfq_head->lcf->rhandle)
1444       GNUNET_TESTBED_cancel_registration (lcfq_head->lcf->rhandle);
1445   }
1446   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == lcf_proc_task_id);
1447   for (lcfq = lcfq_head; NULL != lcfq; lcfq = lcfq_head)
1448   {
1449     GNUNET_free (lcfq->lcf->sxcfg);
1450     GNUNET_free (lcfq->lcf);
1451     GNUNET_CONTAINER_DLL_remove (lcfq_head, lcfq_tail, lcfq);
1452     GNUNET_free (lcfq);
1453   }
1454   /* Clear peer list */
1455   for (id = 0; id < peer_list_size; id++)
1456     if (NULL != peer_list[id])
1457     {
1458       GNUNET_TESTING_peer_destroy (peer_list[id]->peer);
1459       GNUNET_CONFIGURATION_destroy (peer_list[id]->cfg);
1460       GNUNET_free (peer_list[id]);
1461     }
1462   GNUNET_free_non_null (peer_list);
1463   /* Clear host list */
1464   for (id = 0; id < host_list_size; id++)
1465     if (NULL != host_list[id])
1466       GNUNET_TESTBED_host_destroy (host_list[id]);
1467   GNUNET_free_non_null (host_list);
1468   /* Clear route list */
1469   for (id = 0; id < route_list_size; id++)
1470     if (NULL != route_list[id])
1471       GNUNET_free (route_list[id]);
1472   GNUNET_free_non_null (route_list);
1473   /* Clear slave_list */
1474   for (id = 0; id < slave_list_size; id++)
1475     if (NULL != slave_list[id])
1476     {
1477       GNUNET_assert (NULL != slave_list[id]->controller);
1478       GNUNET_TESTBED_controller_disconnect (slave_list[id]->controller);
1479       if (NULL != slave_list[id]->controller_proc)
1480         GNUNET_TESTBED_controller_stop (slave_list[id]->controller_proc);
1481     }
1482   GNUNET_free_non_null (master_context->master_ip);
1483   if (NULL != master_context->system)
1484     GNUNET_TESTING_system_destroy (master_context->system, GNUNET_YES);
1485   GNUNET_free_non_null (master_context);
1486 }
1487
1488
1489 /**
1490  * Debug shutdown task in case of stdin getting closed
1491  *
1492  * @param cls NULL
1493  * @param tc the TaskContext from scheduler
1494  */
1495 static void
1496 shutdown_task_ (void *cls,
1497                 const struct GNUNET_SCHEDULER_TaskContext *tc)
1498 {
1499   LOG (GNUNET_ERROR_TYPE_DEBUG, "STDIN closed ...\n");
1500   shutdown_task (cls, tc);
1501 }
1502
1503
1504 /**
1505  * Callback for client disconnect
1506  *
1507  * @param cls NULL
1508  * @param client the client which has disconnected
1509  */
1510 static void
1511 client_disconnect_cb (void *cls, struct GNUNET_SERVER_Client *client)
1512 {
1513   if (NULL == master_context)
1514     return;
1515   if (client == master_context->client)
1516   {
1517     LOG (GNUNET_ERROR_TYPE_DEBUG, "Master client disconnected\n");
1518     GNUNET_SERVER_client_drop (client);
1519     /* should not be needed as we're terminated by failure to read
1520        from stdin, but if stdin fails for some reason, this shouldn't
1521        hurt for now --- might need to revise this later if we ever
1522        decide that master connections might be temporarily down
1523        for some reason */
1524     GNUNET_SCHEDULER_shutdown ();
1525   }
1526 }
1527
1528
1529 /**
1530  * Testbed setup
1531  *
1532  * @param cls closure
1533  * @param server the initialized server
1534  * @param cfg configuration to use
1535  */
1536 static void
1537 testbed_run (void *cls,
1538              struct GNUNET_SERVER_Handle *server,
1539              const struct GNUNET_CONFIGURATION_Handle *cfg)
1540 {
1541   static const struct GNUNET_SERVER_MessageHandler message_handlers[] =
1542     {
1543       {&handle_init, NULL, GNUNET_MESSAGE_TYPE_TESTBED_INIT,
1544        sizeof (struct GNUNET_TESTBED_InitMessage)},
1545       {&handle_add_host, NULL, GNUNET_MESSAGE_TYPE_TESTBED_ADDHOST, 0},
1546       {&handle_configure_shared_service, NULL,
1547        GNUNET_MESSAGE_TYPE_TESTBED_SERVICESHARE, 0},
1548       {&handle_link_controllers, NULL,
1549        GNUNET_MESSAGE_TYPE_TESTBED_LCONTROLLERS, 0},
1550       {&handle_peer_create, NULL, GNUNET_MESSAGE_TYPE_TESTBED_CREATEPEER, 0},
1551       {&handle_peer_destroy, NULL, GNUNET_MESSAGE_TYPE_TESTBED_DESTROYPEER,
1552        sizeof (struct GNUNET_TESTBED_PeerDestroyMessage)},
1553       {&handle_peer_start, NULL, GNUNET_MESSAGE_TYPE_TESTBED_STARTPEER,
1554        sizeof (struct GNUNET_TESTBED_PeerStartMessage)},
1555       {&handle_peer_stop, NULL, GNUNET_MESSAGE_TYPE_TESTBED_STOPPEER,
1556        sizeof (struct GNUNET_TESTBED_PeerStopMessage)},
1557       {NULL}
1558     };
1559
1560   config = GNUNET_CONFIGURATION_dup (cfg);
1561   GNUNET_SERVER_add_handlers (server,
1562                               message_handlers);
1563   GNUNET_SERVER_disconnect_notify (server,
1564                                    &client_disconnect_cb,
1565                                    NULL);
1566   ss_map = GNUNET_CONTAINER_multihashmap_create (5);
1567   fh = GNUNET_DISK_get_handle_from_native (stdin);
1568   if (NULL == fh)
1569     shutdown_task_id =
1570       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
1571                                     &shutdown_task,
1572                                     NULL);
1573   else
1574     shutdown_task_id =
1575       GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
1576                                       fh,
1577                                       &shutdown_task_,
1578                                       NULL);
1579   LOG_DEBUG ("Testbed startup complete\n");
1580 }
1581
1582
1583 /**
1584  * The starting point of execution
1585  */
1586 int main (int argc, char *const *argv)
1587 {
1588   return
1589     (GNUNET_OK ==
1590      GNUNET_SERVICE_run (argc,
1591                          argv,
1592                          "testbed",
1593                          GNUNET_SERVICE_OPTION_NONE,
1594                          &testbed_run,
1595                          NULL)) ? 0 : 1;
1596 }