src/multicast/gnunet-service-multicast.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2009 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 multicast/gnunet-service-multicast.c
  23  * @brief program that does multicast
  24  * @author Christian Grothoff
  25  */
  26 #include "platform.h"
  27 #include "gnunet_util_lib.h"
  28 #include "gnunet_signatures.h"
  29 #include "gnunet_statistics_service.h"
  30 #include "gnunet_core_service.h"
  31 #include "gnunet_multicast_service.h"
  32 #include "multicast.h"
  33
  34 /**
  35  * Handle to our current configuration.
  36  */
  37 static const struct GNUNET_CONFIGURATION_Handle *cfg;
  38
  39 /**
  40  * Server handle.
  41  */
  42 static struct GNUNET_SERVER_Handle *server;
  43
  44 /**
  45  * Core handle.
  46  * Only used during initialization.
  47  */
  48 static struct GNUNET_CORE_Handle *core;
  49
  50 /**
  51  * Identity of this peer.
  52  */
  53 static struct GNUNET_PeerIdentity this_peer;
  54
  55 /**
  56  * Handle to the statistics service.
  57  */
  58 static struct GNUNET_STATISTICS_Handle *stats;
  59 /**
  60  * Notification context, simplifies client broadcasts.
  61  */
  62 static struct GNUNET_SERVER_NotificationContext *nc;
  63
  64 /**
  65  * All connected origins.
  66  * Group's pub_key_hash -> struct Origin
  67  */
  68 static struct GNUNET_CONTAINER_MultiHashMap *origins;
  69
  70 /**
  71  * All connected members.
  72  * Group's pub_key_hash -> struct Member
  73  */
  74 static struct GNUNET_CONTAINER_MultiHashMap *members;
  75
  76 /**
  77  * Connected members per group.
  78  * Group's pub_key_hash -> Member's pub_key -> struct Member
  79  */
  80 static struct GNUNET_CONTAINER_MultiHashMap *group_members;
  81
  82 /**
  83  * List of connected clients.
  84  */
  85 struct ClientList
  86 {
  87   struct ClientList *prev;
  88   struct ClientList *next;
  89   struct GNUNET_SERVER_Client *client;
  90 };
  91
  92 /**
  93  * Common part of the client context for both an origin and member.
  94  */
  95 struct Group
  96 {
  97   struct ClientList *clients_head;
  98   struct ClientList *clients_tail;
  99
 100   /**
 101    * Public key of the group.
 102    */
 103   struct GNUNET_CRYPTO_EddsaPublicKey pub_key;
 104
 105   /**
 106    * Hash of @a pub_key.
 107    */
 108   struct GNUNET_HashCode pub_key_hash;
 109
 110   /**
 111    * Is this an origin (#GNUNET_YES), or member (#GNUNET_NO)?
 112    */
 113   uint8_t is_origin;
 114
 115   /**
 116    * Is the client disconnected? #GNUNET_YES or #GNUNET_NO
 117    */
 118   uint8_t disconnected;
 119 };
 120
 121
 122 /**
 123  * Client context for a group's origin.
 124  */
 125 struct Origin
 126 {
 127   struct Group grp;
 128
 129   /**
 130    * Private key of the group.
 131    */
 132   struct GNUNET_CRYPTO_EddsaPrivateKey priv_key;
 133
 134   /**
 135    * Last message fragment ID sent to the group.
 136    */
 137   uint64_t max_fragment_id;
 138 };
 139
 140
 141 /**
 142  * Client context for a group member.
 143  */
 144 struct Member
 145 {
 146   struct Group grp;
 147
 148   /**
 149    * Private key of the member.
 150    */
 151   struct GNUNET_CRYPTO_EcdsaPrivateKey priv_key;
 152
 153   /**
 154    * Public key of the member.
 155    */
 156   struct GNUNET_CRYPTO_EcdsaPublicKey pub_key;
 157
 158   /**
 159    * Hash of @a pub_key.
 160    */
 161   struct GNUNET_HashCode pub_key_hash;
 162
 163   /**
 164    * Join request sent to the origin / members.
 165    */
 166   struct MulticastJoinRequestMessage *join_req;
 167
 168   /**
 169    * Join decision sent in reply to our request.
 170    *
 171    * Only a positive decision is stored here, in case of a negative decision the
 172    * client is disconnected.
 173    */
 174   struct MulticastJoinDecisionMessageHeader *join_dcsn;
 175
 176   /**
 177    * Last request fragment ID sent to the origin.
 178    */
 179   uint64_t max_fragment_id;
 180 };
 181
 182
 183 /**
 184  * Task run during shutdown.
 185  *
 186  * @param cls unused
 187  * @param tc unused
 188  */
 189 static void
 190 shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 191 {
 192   if (NULL != core)
 193   {
 194     GNUNET_CORE_disconnect (core);
 195     core = NULL;
 196   }
 197   if (NULL != stats)
 198   {
 199     GNUNET_STATISTICS_destroy (stats, GNUNET_YES);
 200     stats = NULL;
 201   }
 202   /* FIXME: do more clean up here */
 203 }
 204
 205 /**
 206  * Clean up origin data structures after a client disconnected.
 207  */
 208 static void
 209 cleanup_origin (struct Origin *orig)
 210 {
 211   struct Group *grp = &orig->grp;
 212   GNUNET_CONTAINER_multihashmap_remove (origins, &grp->pub_key_hash, orig);
 213 }
 214
 215
 216 /**
 217  * Clean up member data structures after a client disconnected.
 218  */
 219 static void
 220 cleanup_member (struct Member *mem)
 221 {
 222   struct Group *grp = &mem->grp;
 223   struct GNUNET_CONTAINER_MultiHashMap *
 224     grp_mem = GNUNET_CONTAINER_multihashmap_get (group_members,
 225                                                  &grp->pub_key_hash);
 226   GNUNET_assert (NULL != grp_mem);
 227   GNUNET_CONTAINER_multihashmap_remove (grp_mem, &mem->pub_key_hash, mem);
 228
 229   if (0 == GNUNET_CONTAINER_multihashmap_size (grp_mem))
 230   {
 231     GNUNET_CONTAINER_multihashmap_remove (group_members, &grp->pub_key_hash,
 232                                           grp_mem);
 233     GNUNET_CONTAINER_multihashmap_destroy (grp_mem);
 234   }
 235   if (NULL != mem->join_dcsn)
 236   {
 237     GNUNET_free (mem->join_dcsn);
 238     mem->join_dcsn = NULL;
 239   }
 240   GNUNET_CONTAINER_multihashmap_remove (members, &grp->pub_key_hash, mem);
 241 }
 242
 243
 244 /**
 245  * Clean up group data structures after a client disconnected.
 246  */
 247 static void
 248 cleanup_group (struct Group *grp)
 249 {
 250   (GNUNET_YES == grp->is_origin)
 251     ? cleanup_origin ((struct Origin *) grp)
 252     : cleanup_member ((struct Member *) grp);
 253
 254   GNUNET_free (grp);
 255 }
 256
 257
 258 /**
 259  * Called whenever a client is disconnected.
 260  *
 261  * Frees our resources associated with that client.
 262  *
 263  * @param cls  Closure.
 264  * @param client  Client handle.
 265  */
 266 static void
 267 client_disconnect (void *cls, struct GNUNET_SERVER_Client *client)
 268 {
 269   if (NULL == client)
 270     return;
 271
 272   struct Group *grp
 273     = GNUNET_SERVER_client_get_user_context (client, struct Group);
 274
 275   if (NULL == grp)
 276   {
 277     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 278                 "%p User context is NULL in client_disconnect()\n", grp);
 279     GNUNET_assert (0);
 280     return;
 281   }
 282
 283   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 284               "%p Client (%s) disconnected from group %s\n",
 285               grp, (GNUNET_YES == grp->is_origin) ? "origin" : "member",
 286               GNUNET_h2s (&grp->pub_key_hash));
 287
 288   struct ClientList *cl = grp->clients_head;
 289   while (NULL != cl)
 290   {
 291     if (cl->client == client)
 292     {
 293       GNUNET_CONTAINER_DLL_remove (grp->clients_head, grp->clients_tail, cl);
 294       GNUNET_free (cl);
 295       break;
 296     }
 297     cl = cl->next;
 298   }
 299
 300   if (NULL == grp->clients_head)
 301   { /* Last client disconnected. */
 302 #if FIXME
 303     if (NULL != grp->tmit_head)
 304     { /* Send pending messages via CADET before cleanup. */
 305       transmit_message (grp);
 306     }
 307     else
 308 #endif
 309     {
 310       cleanup_group (grp);
 311     }
 312   }
 313 }
 314
 315
 316 /**
 317  * Send message to all clients connected to the group.
 318  */
 319 static void
 320 message_to_clients (const struct Group *grp,
 321                     const struct GNUNET_MessageHeader *msg)
 322 {
 323   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 324               "%p Sending message to clients.\n", grp);
 325
 326   struct ClientList *cl = grp->clients_head;
 327   while (NULL != cl)
 328   {
 329     GNUNET_SERVER_notification_context_add (nc, cl->client);
 330     GNUNET_SERVER_notification_context_unicast (nc, cl->client, msg, GNUNET_NO);
 331     cl = cl->next;
 332   }
 333 }
 334
 335
 336 /**
 337  * Iterator callback for sending a message to origin clients.
 338  */
 339 static int
 340 origin_message_cb (void *cls, const struct GNUNET_HashCode *pub_key_hash,
 341                    void *origin)
 342 {
 343   const struct GNUNET_MessageHeader *msg = cls;
 344   struct Member *orig = origin;
 345
 346   message_to_clients (&orig->grp, msg);
 347   return GNUNET_YES;
 348 }
 349
 350
 351 /**
 352  * Iterator callback for sending a message to member clients.
 353  */
 354 static int
 355 member_message_cb (void *cls, const struct GNUNET_HashCode *pub_key_hash,
 356                    void *member)
 357 {
 358   const struct GNUNET_MessageHeader *msg = cls;
 359   struct Member *mem = member;
 360
 361   if (NULL != mem->join_dcsn)
 362   { /* Only send message to admitted members */
 363     message_to_clients (&mem->grp, msg);
 364   }
 365   return GNUNET_YES;
 366 }
 367
 368
 369 /**
 370  * Send message to all origin and member clients connected to the group.
 371  *
 372  * @param grp  The group to send @a msg to.
 373  * @param msg  Message to send.
 374  */
 375 static void
 376 message_to_group (struct Group *grp, const struct GNUNET_MessageHeader *msg)
 377 {
 378   if (origins != NULL)
 379     GNUNET_CONTAINER_multihashmap_get_multiple (origins, &grp->pub_key_hash,
 380                                                 origin_message_cb, (void *) msg);
 381   if (members != NULL)
 382     GNUNET_CONTAINER_multihashmap_get_multiple (members, &grp->pub_key_hash,
 383                                                 member_message_cb, (void *) msg);
 384 }
 385
 386
 387 /**
 388  * Send message to all origin clients connected to the group.
 389  *
 390  * @param grp  The group to send @a msg to.
 391  * @param msg  Message to send.
 392  */
 393 static void
 394 message_to_origin (struct Group *grp, const struct GNUNET_MessageHeader *msg)
 395 {
 396   if (origins != NULL)
 397     GNUNET_CONTAINER_multihashmap_get_multiple (origins, &grp->pub_key_hash,
 398                                                 origin_message_cb, (void *) msg);
 399 }
 400
 401
 402 /**
 403  * Handle a connecting client starting an origin.
 404  */
 405 static void
 406 client_origin_start (void *cls, struct GNUNET_SERVER_Client *client,
 407                      const struct GNUNET_MessageHeader *m)
 408 {
 409   const struct MulticastOriginStartMessage *
 410     msg = (const struct MulticastOriginStartMessage *) m;
 411
 412   struct GNUNET_CRYPTO_EddsaPublicKey pub_key;
 413   struct GNUNET_HashCode pub_key_hash;
 414
 415   GNUNET_CRYPTO_eddsa_key_get_public (&msg->group_key, &pub_key);
 416   GNUNET_CRYPTO_hash (&pub_key, sizeof (pub_key), &pub_key_hash);
 417
 418   struct Origin *
 419     orig = GNUNET_CONTAINER_multihashmap_get (origins, &pub_key_hash);
 420   struct Group *grp;
 421
 422   if (NULL == orig)
 423   {
 424     orig = GNUNET_new (struct Origin);
 425     orig->priv_key = msg->group_key;
 426     grp = &orig->grp;
 427     grp->is_origin = GNUNET_YES;
 428     grp->pub_key = pub_key;
 429     grp->pub_key_hash = pub_key_hash;
 430
 431     GNUNET_CONTAINER_multihashmap_put (origins, &grp->pub_key_hash, orig,
 432                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
 433   }
 434   else
 435   {
 436     grp = &orig->grp;
 437   }
 438
 439   struct ClientList *cl = GNUNET_new (struct ClientList);
 440   cl->client = client;
 441   GNUNET_CONTAINER_DLL_insert (grp->clients_head, grp->clients_tail, cl);
 442
 443   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 444               "%p Client connected as origin to group %s.\n",
 445               orig, GNUNET_h2s (&grp->pub_key_hash));
 446
 447   GNUNET_SERVER_client_set_user_context (client, grp);
 448   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 449 }
 450
 451
 452 /**
 453  * Handle a connecting client joining a group.
 454  */
 455 static void
 456 client_member_join (void *cls, struct GNUNET_SERVER_Client *client,
 457                     const struct GNUNET_MessageHeader *m)
 458 {
 459   const struct MulticastMemberJoinMessage *
 460     msg = (const struct MulticastMemberJoinMessage *) m;
 461   uint16_t msg_size = ntohs (msg->header.size);
 462
 463   struct GNUNET_CRYPTO_EcdsaPublicKey mem_pub_key;
 464   struct GNUNET_HashCode pub_key_hash, mem_pub_key_hash;
 465
 466   GNUNET_CRYPTO_ecdsa_key_get_public (&msg->member_key, &mem_pub_key);
 467   GNUNET_CRYPTO_hash (&mem_pub_key, sizeof (mem_pub_key), &mem_pub_key_hash);
 468   GNUNET_CRYPTO_hash (&msg->group_key, sizeof (msg->group_key), &pub_key_hash);
 469
 470   struct GNUNET_CONTAINER_MultiHashMap *
 471     grp_mem = GNUNET_CONTAINER_multihashmap_get (group_members, &pub_key_hash);
 472   struct Member *mem = NULL;
 473   struct Group *grp;
 474
 475   if (NULL != grp_mem)
 476   {
 477     mem = GNUNET_CONTAINER_multihashmap_get (grp_mem, &mem_pub_key_hash);
 478   }
 479   if (NULL == mem)
 480   {
 481     mem = GNUNET_new (struct Member);
 482     mem->priv_key = msg->member_key;
 483     mem->pub_key = mem_pub_key;
 484     mem->pub_key_hash = mem_pub_key_hash;
 485
 486     grp = &mem->grp;
 487     grp->is_origin = GNUNET_NO;
 488     grp->pub_key = msg->group_key;
 489     grp->pub_key_hash = pub_key_hash;
 490
 491     if (NULL == grp_mem)
 492     {
 493       grp_mem = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_YES);
 494       GNUNET_CONTAINER_multihashmap_put (group_members, &grp->pub_key_hash, grp_mem,
 495                                          GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
 496     }
 497     GNUNET_CONTAINER_multihashmap_put (grp_mem, &mem->pub_key_hash, mem,
 498                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
 499     GNUNET_CONTAINER_multihashmap_put (members, &grp->pub_key_hash, mem,
 500                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
 501   }
 502   else
 503   {
 504     grp = &mem->grp;
 505   }
 506
 507   struct ClientList *cl = GNUNET_new (struct ClientList);
 508   cl->client = client;
 509   GNUNET_CONTAINER_DLL_insert (grp->clients_head, grp->clients_tail, cl);
 510
 511   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 512               "%p Client connected to group %s..\n",
 513               mem, GNUNET_h2s (&grp->pub_key_hash));
 514   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 515               "%p ..as member %s.\n",
 516               mem, GNUNET_h2s (&mem_pub_key_hash));
 517
 518   GNUNET_SERVER_client_set_user_context (client, grp);
 519
 520   if (NULL != mem->join_dcsn)
 521   { /* Already got a join decision, send it to client. */
 522     GNUNET_SERVER_notification_context_add (nc, client);
 523     GNUNET_SERVER_notification_context_unicast (nc, client,
 524                                                 (struct GNUNET_MessageHeader *)
 525                                                 mem->join_dcsn,
 526                                                 GNUNET_NO);
 527   }
 528   else if (grp->clients_head == grp->clients_tail)
 529   { /* First client of the group, send join request. */
 530     struct GNUNET_PeerIdentity *relays = (struct GNUNET_PeerIdentity *) &msg[1];
 531     uint32_t relay_count = ntohs (msg->relay_count);
 532     uint16_t relay_size = relay_count * sizeof (*relays);
 533     struct GNUNET_MessageHeader *join_msg = NULL;
 534     uint16_t join_msg_size = 0;
 535     if (sizeof (*msg) + relay_size + sizeof (struct GNUNET_MessageHeader)
 536         <= msg_size)
 537     {
 538       join_msg = (struct GNUNET_MessageHeader *)
 539         (((char *) &msg[1]) + relay_size);
 540       join_msg_size = ntohs (join_msg->size);
 541     }
 542     if (sizeof (*msg) + relay_size + join_msg_size != msg_size)
 543     {
 544       GNUNET_break (0);
 545       GNUNET_SERVER_client_disconnect (client);
 546       return;
 547     }
 548
 549     struct MulticastJoinRequestMessage *
 550       req = GNUNET_malloc (sizeof (*req) + join_msg_size);
 551     req->header.size = htons (sizeof (*req) + join_msg_size);
 552     req->header.type = htons (GNUNET_MESSAGE_TYPE_MULTICAST_JOIN_REQUEST);
 553     req->group_key = grp->pub_key;
 554     req->member_peer = this_peer;
 555     GNUNET_CRYPTO_ecdsa_key_get_public (&mem->priv_key, &req->member_key);
 556     if (0 < join_msg_size)
 557       memcpy (&req[1], join_msg, join_msg_size);
 558
 559     req->purpose.size = htonl (sizeof (*req) + join_msg_size
 560                                - sizeof (req->header)
 561                                - sizeof (req->signature));
 562     req->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_MULTICAST_REQUEST);
 563
 564     if (GNUNET_OK != GNUNET_CRYPTO_ecdsa_sign (&mem->priv_key, &req->purpose,
 565                                                &req->signature))
 566     {
 567       /* FIXME: handle error */
 568       GNUNET_assert (0);
 569     }
 570
 571     if (NULL != mem->join_req)
 572       GNUNET_free (mem->join_req);
 573     mem->join_req = req;
 574
 575     if (GNUNET_YES
 576         == GNUNET_CONTAINER_multihashmap_contains (origins, &grp->pub_key_hash))
 577     { /* Local origin */
 578       message_to_origin (grp, (struct GNUNET_MessageHeader *) mem->join_req);
 579     }
 580     else
 581     {
 582       /* FIXME: send join request to remote peers */
 583     }
 584   }
 585   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 586 }
 587
 588
 589 /**
 590  * Join decision from client.
 591  */
 592 static void
 593 client_join_decision (void *cls, struct GNUNET_SERVER_Client *client,
 594                       const struct GNUNET_MessageHeader *m)
 595 {
 596   struct Group *
 597     grp = GNUNET_SERVER_client_get_user_context (client, struct Group);
 598   const struct MulticastJoinDecisionMessageHeader *
 599     hdcsn = (const struct MulticastJoinDecisionMessageHeader *) m;
 600   const struct MulticastJoinDecisionMessage *
 601     dcsn = (const struct MulticastJoinDecisionMessage *) &hdcsn[1];
 602
 603   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 604               "%p Got join decision from client for group %s..\n",
 605               grp, GNUNET_h2s (&grp->pub_key_hash));
 606
 607   if (GNUNET_YES
 608       == GNUNET_CONTAINER_multihashmap_contains (origins, &grp->pub_key_hash))
 609   { /* Local origin */
 610     struct GNUNET_CONTAINER_MultiHashMap *
 611       grp_mem = GNUNET_CONTAINER_multihashmap_get (group_members,
 612                                                    &grp->pub_key_hash);
 613     if (NULL != grp_mem)
 614     {
 615       struct GNUNET_HashCode member_key_hash;
 616       GNUNET_CRYPTO_hash (&hdcsn->member_key, sizeof (hdcsn->member_key),
 617                           &member_key_hash);
 618       struct Member *
 619         mem = GNUNET_CONTAINER_multihashmap_get (grp_mem, &member_key_hash);
 620       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 621                   "%p ..and member %s: %p\n",
 622                   grp, GNUNET_h2s (&member_key_hash), mem);
 623       if (NULL != mem)
 624       {
 625         message_to_clients (&mem->grp, (struct GNUNET_MessageHeader *) hdcsn);
 626         if (GNUNET_YES == ntohl (dcsn->is_admitted))
 627         { /* Member admitted, store join_decision. */
 628           uint16_t dcsn_size = ntohs (dcsn->header.size);
 629           mem->join_dcsn = GNUNET_malloc (dcsn_size);
 630           memcpy (mem->join_dcsn, dcsn, dcsn_size);
 631         }
 632         else
 633         { /* Refused entry, disconnect clients. */
 634           struct ClientList *cl = mem->grp.clients_head;
 635           while (NULL != cl)
 636           {
 637             struct GNUNET_SERVER_Client *client = cl->client;
 638             cl = cl->next;
 639             GNUNET_SERVER_client_disconnect (client);
 640           }
 641         }
 642       }
 643     }
 644   }
 645   else
 646   {
 647     /* FIXME: send join decision to hdcsn->peer */
 648   }
 649   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 650 }
 651
 652 /**
 653  * Incoming message from a client.
 654  */
 655 static void
 656 client_multicast_message (void *cls, struct GNUNET_SERVER_Client *client,
 657                           const struct GNUNET_MessageHeader *m)
 658 {
 659   struct Group *
 660     grp = GNUNET_SERVER_client_get_user_context (client, struct Group);
 661   GNUNET_assert (GNUNET_YES == grp->is_origin);
 662   struct Origin *orig = (struct Origin *) grp;
 663   struct GNUNET_MULTICAST_MessageHeader *
 664     msg = (struct GNUNET_MULTICAST_MessageHeader *) m;
 665
 666   msg->fragment_id = GNUNET_htonll (orig->max_fragment_id++);
 667   msg->purpose.size = htonl (sizeof (*msg) + ntohs (m->size)
 668                              - sizeof (msg->header)
 669                              - sizeof (msg->hop_counter)
 670                              - sizeof (msg->signature));
 671   msg->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_MULTICAST_MESSAGE);
 672
 673   if (GNUNET_OK != GNUNET_CRYPTO_eddsa_sign (&orig->priv_key, &msg->purpose,
 674                                              &msg->signature))
 675   {
 676     /* FIXME: handle error */
 677     GNUNET_assert (0);
 678   }
 679
 680   /* FIXME: send to remote members */
 681
 682   message_to_group (grp, m);
 683   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 684 }
 685
 686
 687 /**
 688  * Incoming request from a client.
 689  */
 690 static void
 691 client_multicast_request (void *cls, struct GNUNET_SERVER_Client *client,
 692                           const struct GNUNET_MessageHeader *m)
 693 {
 694   struct Group *
 695     grp = GNUNET_SERVER_client_get_user_context (client, struct Group);
 696   GNUNET_assert (GNUNET_NO == grp->is_origin);
 697   struct Member *mem = (struct Member *) grp;
 698
 699   struct GNUNET_MULTICAST_RequestHeader *
 700     req = (struct GNUNET_MULTICAST_RequestHeader *) m;
 701
 702   req->fragment_id = GNUNET_ntohll (mem->max_fragment_id++);
 703
 704   req->purpose.size = htonl (sizeof (*req) + ntohs (m->size)
 705                              - sizeof (req->header)
 706                              - sizeof (req->member_key)
 707                              - sizeof (req->signature));
 708   req->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_MULTICAST_REQUEST);
 709
 710   if (GNUNET_OK != GNUNET_CRYPTO_ecdsa_sign (&mem->priv_key, &req->purpose,
 711                                              &req->signature))
 712   {
 713     /* FIXME: handle error */
 714     GNUNET_assert (0);
 715   }
 716
 717   if (GNUNET_YES
 718       == GNUNET_CONTAINER_multihashmap_contains (origins, &grp->pub_key_hash))
 719   { /* Local origin */
 720     message_to_origin (grp, m);
 721   }
 722   else
 723   {
 724     /* FIXME: send to remote origin */
 725   }
 726   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 727 }
 728
 729
 730 /**
 731  * Connected to core service.
 732  */
 733 static void
 734 core_connected_cb  (void *cls, const struct GNUNET_PeerIdentity *my_identity)
 735 {
 736   this_peer = *my_identity;
 737
 738   static const struct GNUNET_SERVER_MessageHandler handlers[] = {
 739     { &client_origin_start, NULL,
 740       GNUNET_MESSAGE_TYPE_MULTICAST_ORIGIN_START, 0 },
 741
 742     { &client_member_join, NULL,
 743       GNUNET_MESSAGE_TYPE_MULTICAST_MEMBER_JOIN, 0 },
 744
 745     { &client_join_decision, NULL,
 746       GNUNET_MESSAGE_TYPE_MULTICAST_JOIN_DECISION, 0 },
 747
 748     { &client_multicast_message, NULL,
 749       GNUNET_MESSAGE_TYPE_MULTICAST_MESSAGE, 0 },
 750
 751     { &client_multicast_request, NULL,
 752       GNUNET_MESSAGE_TYPE_MULTICAST_REQUEST, 0 },
 753
 754     {NULL, NULL, 0, 0}
 755   };
 756
 757   stats = GNUNET_STATISTICS_create ("multicast", cfg);
 758   origins = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_YES);
 759   members = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_YES);
 760   group_members = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_NO);
 761   nc = GNUNET_SERVER_notification_context_create (server, 1);
 762
 763   GNUNET_SERVER_add_handlers (server, handlers);
 764   GNUNET_SERVER_disconnect_notify (server, &client_disconnect, NULL);
 765   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
 766                                 NULL);
 767 }
 768
 769
 770 /**
 771  * Service started.
 772  *
 773  * @param cls closure
 774  * @param server the initialized server
 775  * @param cfg configuration to use
 776  */
 777 static void
 778 run (void *cls, struct GNUNET_SERVER_Handle *srv,
 779      const struct GNUNET_CONFIGURATION_Handle *c)
 780 {
 781   cfg = c;
 782   server = srv;
 783   core = GNUNET_CORE_connect (cfg, NULL, core_connected_cb, NULL, NULL,
 784                               NULL, GNUNET_NO, NULL, GNUNET_NO, NULL);
 785 }
 786
 787
 788 /**
 789  * The main function for the multicast service.
 790  *
 791  * @param argc number of arguments from the command line
 792  * @param argv command line arguments
 793  * @return 0 ok, 1 on error
 794  */
 795 int
 796 main (int argc, char *const *argv)
 797 {
 798   return (GNUNET_OK ==
 799           GNUNET_SERVICE_run (argc, argv, "multicast",
 800                               GNUNET_SERVICE_OPTION_NONE, &run, NULL)) ? 0 : 1;
 801 }
 802
 803 /* end of gnunet-service-multicast.c */