src/set/gnunet-service-set.c

   1 /*
   2       This file is part of GNUnet
   3       (C) 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 set/gnunet-service-set.c
  23  * @brief two-peer set operations
  24  * @author Florian Dold
  25  */
  26 #include "gnunet-service-set.h"
  27 #include "set_protocol.h"
  28
  29
  30 /**
  31  * State of an operation where the peer has connected to us, but is not yet
  32  * evaluating a set operation.  Once the peer has sent a concrete request, and
  33  * the client has accepted or rejected it, this information will be deleted
  34  * and replaced by the real set operation state.
  35  */
  36 struct OperationState
  37 {
  38   /**
  39    * The identity of the requesting peer.  Needs to
  40    * be stored here as the op spec might not have been created yet.
  41    */
  42   struct GNUNET_PeerIdentity peer;
  43
  44   /**
  45    * Timeout task, if the incoming peer has not been accepted
  46    * after the timeout, it will be disconnected.
  47    */
  48   GNUNET_SCHEDULER_TaskIdentifier timeout_task;
  49
  50   /**
  51    * Unique request id for the request from a remote peer, sent to the
  52    * client, which will accept or reject the request.  Set to '0' iff
  53    * the request has not been suggested yet.
  54    */
  55   uint32_t suggest_id;
  56
  57 };
  58
  59
  60 /**
  61  * A listener is inhabited by a client, and waits for evaluation
  62  * requests from remote peers.
  63  */
  64 struct Listener
  65 {
  66   /**
  67    * Listeners are held in a doubly linked list.
  68    */
  69   struct Listener *next;
  70
  71   /**
  72    * Listeners are held in a doubly linked list.
  73    */
  74   struct Listener *prev;
  75
  76   /**
  77    * Client that owns the listener.
  78    * Only one client may own a listener.
  79    */
  80   struct GNUNET_SERVER_Client *client;
  81
  82   /**
  83    * Message queue for the client
  84    */
  85   struct GNUNET_MQ_Handle *client_mq;
  86
  87   /**
  88    * Application ID for the operation, used to distinguish
  89    * multiple operations of the same type with the same peer.
  90    */
  91   struct GNUNET_HashCode app_id;
  92
  93   /**
  94    * The type of the operation.
  95    */
  96   enum GNUNET_SET_OperationType operation;
  97 };
  98
  99
 100 /**
 101  * Configuration of our local peer.
 102  */
 103 static const struct GNUNET_CONFIGURATION_Handle *configuration;
 104
 105 /**
 106  * Handle to the cadet service, used to listen for and connect to
 107  * remote peers.
 108  */
 109 static struct GNUNET_CADET_Handle *cadet;
 110
 111 /**
 112  * Sets are held in a doubly linked list.
 113  */
 114 static struct Set *sets_head;
 115
 116 /**
 117  * Sets are held in a doubly linked list.
 118  */
 119 static struct Set *sets_tail;
 120
 121 /**
 122  * Listeners are held in a doubly linked list.
 123  */
 124 static struct Listener *listeners_head;
 125
 126 /**
 127  * Listeners are held in a doubly linked list.
 128  */
 129 static struct Listener *listeners_tail;
 130
 131 /**
 132  * Incoming sockets from remote peers are held in a doubly linked
 133  * list.
 134  */
 135 static struct Operation *incoming_head;
 136
 137 /**
 138  * Incoming sockets from remote peers are held in a doubly linked
 139  * list.
 140  */
 141 static struct Operation *incoming_tail;
 142
 143 /**
 144  * Counter for allocating unique IDs for clients, used to identify
 145  * incoming operation requests from remote peers, that the client can
 146  * choose to accept or refuse.
 147  */
 148 static uint32_t suggest_id = 1;
 149
 150
 151 /**
 152  * Get set that is owned by the given client, if any.
 153  *
 154  * @param client client to look for
 155  * @return set that the client owns, NULL if the client
 156  *         does not own a set
 157  */
 158 static struct Set *
 159 set_get (struct GNUNET_SERVER_Client *client)
 160 {
 161   struct Set *set;
 162
 163   for (set = sets_head; NULL != set; set = set->next)
 164     if (set->client == client)
 165       return set;
 166   return NULL;
 167 }
 168
 169
 170 /**
 171  * Get the listener associated with the given client, if any.
 172  *
 173  * @param client the client
 174  * @return listener associated with the client, NULL
 175  *         if there isn't any
 176  */
 177 static struct Listener *
 178 listener_get (struct GNUNET_SERVER_Client *client)
 179 {
 180   struct Listener *listener;
 181
 182   for (listener = listeners_head; NULL != listener; listener = listener->next)
 183     if (listener->client == client)
 184       return listener;
 185   return NULL;
 186 }
 187
 188
 189 /**
 190  * Get the incoming socket associated with the given id.
 191  *
 192  * @param id id to look for
 193  * @return the incoming socket associated with the id,
 194  *         or NULL if there is none
 195  */
 196 static struct Operation *
 197 get_incoming (uint32_t id)
 198 {
 199   struct Operation *op;
 200
 201   for (op = incoming_head; NULL != op; op = op->next)
 202     if (op->state->suggest_id == id)
 203     {
 204       // FIXME: remove this assertion once the corresponding bug is gone!
 205       GNUNET_assert (GNUNET_YES == op->is_incoming);
 206       return op;
 207     }
 208   return NULL;
 209 }
 210
 211
 212 /**
 213  * Destroy a listener, free all resources associated with it.
 214  *
 215  * @param listener listener to destroy
 216  */
 217 static void
 218 listener_destroy (struct Listener *listener)
 219 {
 220   /* If the client is not dead yet, destroy it.
 221    * The client's destroy callback will destroy the listener again. */
 222   if (NULL != listener->client)
 223   {
 224     struct GNUNET_SERVER_Client *client = listener->client;
 225
 226     listener->client = NULL;
 227     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 228                 "disconnecting listener client\n");
 229     GNUNET_SERVER_client_disconnect (client);
 230     return;
 231   }
 232   if (NULL != listener->client_mq)
 233   {
 234     GNUNET_MQ_destroy (listener->client_mq);
 235     listener->client_mq = NULL;
 236   }
 237   GNUNET_CONTAINER_DLL_remove (listeners_head,
 238                                listeners_tail,
 239                                listener);
 240   GNUNET_free (listener);
 241 }
 242
 243
 244 /**
 245  * Context for the #garbage_collect_cb().
 246  */
 247 struct GarbageContext
 248 {
 249
 250   /**
 251    * Map for which we are garbage collecting removed elements.
 252    */
 253   struct GNUNET_CONTAINER_MultiHashMap *map;
 254
 255   /**
 256    * Lowest generation for which an operation is still pending.
 257    */
 258   unsigned int min_op_generation;
 259
 260   /**
 261    * Largest generation for which an operation is still pending.
 262    */
 263   unsigned int max_op_generation;
 264
 265 };
 266
 267
 268 /**
 269  * Function invoked to check if an element can be removed from
 270  * the set's history because it is no longer needed.
 271  *
 272  * @param cls the `struct GarbageContext *`
 273  * @param key key of the element in the map
 274  * @param value the `struct ElementEntry *`
 275  * @return #GNUNET_OK (continue to iterate)
 276  */
 277 static int
 278 garbage_collect_cb (void *cls,
 279                     const struct GNUNET_HashCode *key,
 280                     void *value)
 281 {
 282   struct GarbageContext *gc = cls;
 283   struct ElementEntry *ee = value;
 284
 285   if (GNUNET_YES != ee->removed)
 286     return GNUNET_OK;
 287   if ( (gc->max_op_generation < ee->generation_added) ||
 288        (ee->generation_removed > gc->min_op_generation) )
 289   {
 290     GNUNET_assert (GNUNET_YES ==
 291                    GNUNET_CONTAINER_multihashmap_remove (gc->map,
 292                                                          key,
 293                                                          ee));
 294     GNUNET_free (ee);
 295   }
 296   return GNUNET_OK;
 297 }
 298
 299
 300 /**
 301  * Collect and destroy elements that are not needed anymore, because
 302  * their lifetime (as determined by their generation) does not overlap
 303  * with any active set operation.
 304  *
 305  * @param set set to garbage collect
 306  */
 307 static void
 308 collect_generation_garbage (struct Set *set)
 309 {
 310   struct Operation *op;
 311   struct GarbageContext gc;
 312
 313   gc.min_op_generation = UINT_MAX;
 314   gc.max_op_generation = 0;
 315   for (op = set->ops_head; NULL != op; op = op->next)
 316   {
 317     gc.min_op_generation = GNUNET_MIN (gc.min_op_generation,
 318                                        op->generation_created);
 319     gc.max_op_generation = GNUNET_MAX (gc.max_op_generation,
 320                                        op->generation_created);
 321   }
 322   gc.map = set->elements;
 323   GNUNET_CONTAINER_multihashmap_iterate (set->elements,
 324                                          &garbage_collect_cb,
 325                                          &gc);
 326 }
 327
 328
 329 /**
 330  * Destroy the given operation.  Call the implementation-specific
 331  * cancel function of the operation.  Disconnects from the remote
 332  * peer.  Does not disconnect the client, as there may be multiple
 333  * operations per set.
 334  *
 335  * @param op operation to destroy
 336  * @param gc #GNUNET_YES to perform garbage collection on the set
 337  */
 338 void
 339 _GSS_operation_destroy (struct Operation *op,
 340                         int gc)
 341 {
 342   struct Set *set;
 343   struct GNUNET_CADET_Channel *channel;
 344
 345   if (NULL == op->vt)
 346   {
 347     /* already in #_GSS_operation_destroy() */
 348     return;
 349   }
 350   GNUNET_assert (GNUNET_NO == op->is_incoming);
 351   GNUNET_assert (NULL != op->spec);
 352   set = op->spec->set;
 353   GNUNET_CONTAINER_DLL_remove (op->spec->set->ops_head,
 354                                op->spec->set->ops_tail,
 355                                op);
 356   op->vt->cancel (op);
 357   op->vt = NULL;
 358   if (NULL != op->spec)
 359   {
 360     if (NULL != op->spec->context_msg)
 361     {
 362       GNUNET_free (op->spec->context_msg);
 363       op->spec->context_msg = NULL;
 364     }
 365     GNUNET_free (op->spec);
 366     op->spec = NULL;
 367   }
 368   if (NULL != op->mq)
 369   {
 370     GNUNET_MQ_destroy (op->mq);
 371     op->mq = NULL;
 372   }
 373   if (NULL != (channel = op->channel))
 374   {
 375     op->channel = NULL;
 376     GNUNET_CADET_channel_destroy (channel);
 377   }
 378   if (GNUNET_YES == gc)
 379     collect_generation_garbage (set);
 380   /* We rely on the channel end handler to free 'op'. When 'op->channel' was NULL,
 381    * there was a channel end handler that will free 'op' on the call stack. */
 382 }
 383
 384
 385 /**
 386  * Iterator over hash map entries to free element entries.
 387  *
 388  * @param cls closure
 389  * @param key current key code
 390  * @param value a `struct ElementEntry *` to be free'd
 391  * @return #GNUNET_YES (continue to iterate)
 392  */
 393 static int
 394 destroy_elements_iterator (void *cls,
 395                            const struct GNUNET_HashCode *key,
 396                            void *value)
 397 {
 398   struct ElementEntry *ee = value;
 399
 400   GNUNET_free (ee);
 401   return GNUNET_YES;
 402 }
 403
 404
 405 /**
 406  * Destroy a set, and free all resources and operations associated with it.
 407  *
 408  * @param set the set to destroy
 409  */
 410 static void
 411 set_destroy (struct Set *set)
 412 {
 413   if (NULL != set->client)
 414   {
 415     /* If the client is not dead yet, destroy it.  The client's destroy
 416      * callback will call `set_destroy()` again in this case.  We do
 417      * this so that the channel end handler still has a valid set handle
 418      * to destroy. */
 419     struct GNUNET_SERVER_Client *client = set->client;
 420
 421     set->client = NULL;
 422     GNUNET_SERVER_client_disconnect (client);
 423     return;
 424   }
 425   GNUNET_assert (NULL != set->state);
 426   while (NULL != set->ops_head)
 427     _GSS_operation_destroy (set->ops_head, GNUNET_NO);
 428   set->vt->destroy_set (set->state);
 429   set->state = NULL;
 430   if (NULL != set->client_mq)
 431   {
 432     GNUNET_MQ_destroy (set->client_mq);
 433     set->client_mq = NULL;
 434   }
 435   if (NULL != set->iter)
 436   {
 437     GNUNET_CONTAINER_multihashmap_iterator_destroy (set->iter);
 438     set->iter = NULL;
 439   }
 440   if (NULL != set->elements)
 441   {
 442     GNUNET_CONTAINER_multihashmap_iterate (set->elements,
 443                                            &destroy_elements_iterator,
 444                                            NULL);
 445     GNUNET_CONTAINER_multihashmap_destroy (set->elements);
 446     set->elements = NULL;
 447   }
 448   GNUNET_CONTAINER_DLL_remove (sets_head,
 449                                sets_tail,
 450                                set);
 451   GNUNET_free (set);
 452 }
 453
 454
 455 /**
 456  * Clean up after a client has disconnected
 457  *
 458  * @param cls closure, unused
 459  * @param client the client to clean up after
 460  */
 461 static void
 462 handle_client_disconnect (void *cls,
 463                           struct GNUNET_SERVER_Client *client)
 464 {
 465   struct Set *set;
 466   struct Listener *listener;
 467
 468   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 469               "client disconnected, cleaning up\n");
 470   set = set_get (client);
 471   if (NULL != set)
 472   {
 473     set->client = NULL;
 474     set_destroy (set);
 475     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 476                 "Client's set destroyed\n");
 477   }
 478   listener = listener_get (client);
 479   if (NULL != listener)
 480   {
 481     listener->client = NULL;
 482     listener_destroy (listener);
 483     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 484                 "Client's listener destroyed\n");
 485   }
 486 }
 487
 488
 489 /**
 490  * Destroy an incoming request from a remote peer
 491  *
 492  * @param incoming remote request to destroy
 493  */
 494 static void
 495 incoming_destroy (struct Operation *incoming)
 496 {
 497   GNUNET_assert (GNUNET_YES == incoming->is_incoming);
 498   GNUNET_CONTAINER_DLL_remove (incoming_head,
 499                                incoming_tail,
 500                                incoming);
 501   if (GNUNET_SCHEDULER_NO_TASK != incoming->state->timeout_task)
 502   {
 503     GNUNET_SCHEDULER_cancel (incoming->state->timeout_task);
 504     incoming->state->timeout_task = GNUNET_SCHEDULER_NO_TASK;
 505   }
 506   GNUNET_assert (NULL != incoming->state);
 507   GNUNET_free (incoming->state);
 508   /* make sure that the tunnel end handler will not destroy us again */
 509   incoming->vt = NULL;
 510   incoming->state = NULL;
 511   if (NULL != incoming->mq)
 512   {
 513     GNUNET_MQ_destroy (incoming->mq);
 514     incoming->mq = NULL;
 515   }
 516   if (NULL != incoming->channel)
 517   {
 518     GNUNET_CADET_channel_destroy (incoming->channel);
 519     incoming->channel = NULL;
 520   }
 521 }
 522
 523
 524 /**
 525  * Find a listener that is interested in the given operation type
 526  * and application id.
 527  *
 528  * @param op operation type to look for
 529  * @param app_id application id to look for
 530  * @return a matching listener, or NULL if no listener matches the
 531  *         given operation and application id
 532  */
 533 static struct Listener *
 534 listener_get_by_target (enum GNUNET_SET_OperationType op,
 535                         const struct GNUNET_HashCode *app_id)
 536 {
 537   struct Listener *l;
 538
 539   for (l = listeners_head; NULL != l; l = l->next)
 540     if ( (l->operation == op) &&
 541          (0 == GNUNET_CRYPTO_hash_cmp (app_id, &l->app_id)) )
 542       return l;
 543   return NULL;
 544 }
 545
 546
 547 // ----------------------
 548 /**
 549  * Suggest the given request to the listener. The listening client can
 550  * then accept or reject the remote request.
 551  *
 552  * @param incoming the incoming peer with the request to suggest
 553  * @param listener the listener to suggest the request to
 554  */
 555 static void
 556 incoming_suggest (struct Operation *incoming,
 557                   struct Listener *listener)
 558 {
 559   struct GNUNET_MQ_Envelope *mqm;
 560   struct GNUNET_SET_RequestMessage *cmsg;
 561
 562   GNUNET_assert (GNUNET_YES == incoming->is_incoming);
 563   GNUNET_assert (NULL != incoming->state);
 564   GNUNET_assert (NULL != incoming->spec);
 565   GNUNET_assert (0 == incoming->state->suggest_id);
 566   incoming->state->suggest_id = suggest_id++;
 567
 568   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != incoming->state->timeout_task);
 569   GNUNET_SCHEDULER_cancel (incoming->state->timeout_task);
 570   incoming->state->timeout_task = GNUNET_SCHEDULER_NO_TASK;
 571
 572   mqm = GNUNET_MQ_msg_nested_mh (cmsg, GNUNET_MESSAGE_TYPE_SET_REQUEST,
 573                                  incoming->spec->context_msg);
 574   GNUNET_assert (NULL != mqm);
 575   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "suggesting request with accept id %u\n",
 576               incoming->state->suggest_id);
 577   cmsg->accept_id = htonl (incoming->state->suggest_id);
 578   cmsg->peer_id = incoming->spec->peer;
 579   GNUNET_MQ_send (listener->client_mq, mqm);
 580 }
 581
 582
 583 /**
 584  * Handle a request for a set operation from
 585  * another peer.
 586  *
 587  * This msg is expected as the first and only msg handled through the
 588  * non-operation bound virtual table, acceptance of this operation replaces
 589  * our virtual table and subsequent msgs would be routed differently.
 590  *
 591  * @param op the operation state
 592  * @param mh the received message
 593  * @return #GNUNET_OK if the channel should be kept alive,
 594  *         #GNUNET_SYSERR to destroy the channel
 595  */
 596 static int
 597 handle_incoming_msg (struct Operation *op,
 598                      const struct GNUNET_MessageHeader *mh)
 599 {
 600   const struct OperationRequestMessage *msg = (const struct OperationRequestMessage *) mh;
 601   struct Listener *listener;
 602   struct OperationSpecification *spec;
 603
 604   GNUNET_assert (GNUNET_YES == op->is_incoming);
 605
 606   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 607               "got op request\n");
 608
 609   if (GNUNET_MESSAGE_TYPE_SET_P2P_OPERATION_REQUEST != ntohs (mh->type))
 610   {
 611     GNUNET_break_op (0);
 612     return GNUNET_SYSERR;
 613   }
 614
 615   /* double operation request */
 616   if (NULL != op->spec)
 617   {
 618     GNUNET_break_op (0);
 619     return GNUNET_SYSERR;
 620   }
 621
 622   spec = GNUNET_new (struct OperationSpecification);
 623   spec->context_msg = GNUNET_MQ_extract_nested_mh (msg);
 624   // for simplicity we just backup the context msg instead of rebuilding it later on
 625   if (NULL != spec->context_msg)
 626     spec->context_msg = GNUNET_copy_message (spec->context_msg);
 627   spec->operation = ntohl (msg->operation);
 628   spec->app_id = msg->app_id;
 629   spec->salt = ntohl (msg->salt);
 630   spec->peer = op->state->peer;
 631   spec->remote_element_count = ntohl (msg->element_count);
 632
 633   op->spec = spec;
 634
 635   if ( (NULL != spec->context_msg) &&
 636        (ntohs (spec->context_msg->size) > GNUNET_SET_CONTEXT_MESSAGE_MAX_SIZE) )
 637   {
 638     GNUNET_break_op (0);
 639     return GNUNET_SYSERR;
 640   }
 641
 642   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 643               "received P2P operation request (op %u, app %s)\n",
 644               ntohl (msg->operation),
 645               GNUNET_h2s (&msg->app_id));
 646   listener = listener_get_by_target (ntohl (msg->operation),
 647                                      &msg->app_id);
 648   if (NULL == listener)
 649   {
 650     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 651                 "no listener matches incoming request, waiting with timeout\n");
 652     return GNUNET_OK;
 653   }
 654   incoming_suggest (op, listener);
 655   return GNUNET_OK;
 656 }
 657
 658
 659 /**
 660  * Send the next element of a set to the set's client.  The next element is given by
 661  * the set's current hashmap iterator.  The set's iterator will be set to NULL if there
 662  * are no more elements in the set.  The caller must ensure that the set's iterator is
 663  * valid.
 664  *
 665  * @param set set that should send its next element to its client
 666  */
 667 static void
 668 send_client_element (struct Set *set)
 669 {
 670   int ret;
 671   struct ElementEntry *ee;
 672   struct GNUNET_MQ_Envelope *ev;
 673
 674   GNUNET_assert (NULL != set->iter);
 675   ret = GNUNET_CONTAINER_multihashmap_iterator_next (set->iter,
 676                                                      NULL,
 677                                                      (const void **) &ee);
 678   if (GNUNET_NO == ret)
 679   {
 680     ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SET_ITER_DONE);
 681     GNUNET_CONTAINER_multihashmap_iterator_destroy (set->iter);
 682     set->iter = NULL;
 683   }
 684   else
 685   {
 686     struct GNUNET_SET_IterResponseMessage *msg;
 687
 688     GNUNET_assert (NULL != ee);
 689     ev = GNUNET_MQ_msg_extra (msg,
 690                               ee->element.size,
 691                               GNUNET_MESSAGE_TYPE_SET_ITER_ELEMENT);
 692     memcpy (&msg[1], ee->element.data, ee->element.size);
 693     msg->element_type = ee->element.type;
 694   }
 695   GNUNET_MQ_send (set->client_mq, ev);
 696 }
 697
 698
 699 /**
 700  * Called when a client wants to iterate the elements of a set.
 701  *
 702  * @param cls unused
 703  * @param client client that sent the message
 704  * @param m message sent by the client
 705  */
 706 static void
 707 handle_client_iterate (void *cls,
 708                        struct GNUNET_SERVER_Client *client,
 709                        const struct GNUNET_MessageHeader *m)
 710 {
 711   struct Set *set;
 712
 713   // iterate over a non existing set
 714   set = set_get (client);
 715   if (NULL == set)
 716   {
 717     GNUNET_break (0);
 718     GNUNET_SERVER_client_disconnect (client);
 719     return;
 720   }
 721
 722   // only one concurrent iterate-action per set
 723   if (NULL != set->iter)
 724   {
 725     GNUNET_break (0);
 726     GNUNET_SERVER_client_disconnect (client);
 727     return;
 728   }
 729   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "iterating union set with %u elements\n",
 730               GNUNET_CONTAINER_multihashmap_size (set->elements));
 731   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 732   set->iter = GNUNET_CONTAINER_multihashmap_iterator_create (set->elements);
 733   send_client_element (set);
 734 }
 735
 736
 737 /**
 738  * Called when a client wants to create a new set.
 739  *
 740  * @param cls unused
 741  * @param client client that sent the message
 742  * @param m message sent by the client
 743  */
 744 static void
 745 handle_client_create_set (void *cls,
 746                           struct GNUNET_SERVER_Client *client,
 747                           const struct GNUNET_MessageHeader *m)
 748 {
 749   const struct GNUNET_SET_CreateMessage *msg;
 750   struct Set *set;
 751
 752   msg = (const struct GNUNET_SET_CreateMessage *) m;
 753   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 754               "client created new set (operation %u)\n",
 755               ntohs (msg->operation));
 756
 757   // max. one set per client!
 758   if (NULL != set_get (client))
 759   {
 760     GNUNET_break (0);
 761     GNUNET_SERVER_client_disconnect (client);
 762     return;
 763   }
 764
 765   set = GNUNET_new (struct Set);
 766
 767   switch (ntohs (msg->operation))
 768   {
 769   case GNUNET_SET_OPERATION_INTERSECTION:
 770     set->vt = _GSS_intersection_vt ();
 771     break;
 772   case GNUNET_SET_OPERATION_UNION:
 773     set->vt = _GSS_union_vt ();
 774     break;
 775   default:
 776     GNUNET_free (set);
 777     GNUNET_break (0);
 778     GNUNET_SERVER_client_disconnect (client);
 779     return;
 780   }
 781
 782   set->state = set->vt->create ();
 783   set->elements = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_YES);
 784   set->client = client;
 785   set->client_mq = GNUNET_MQ_queue_for_server_client (client);
 786   GNUNET_CONTAINER_DLL_insert (sets_head, sets_tail, set);
 787   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 788 }
 789
 790
 791 /**
 792  * Called when a client wants to create a new listener.
 793  *
 794  * @param cls unused
 795  * @param client client that sent the message
 796  * @param m message sent by the client
 797  */
 798 static void
 799 handle_client_listen (void *cls,
 800                       struct GNUNET_SERVER_Client *client,
 801                       const struct GNUNET_MessageHeader *m)
 802 {
 803   const struct GNUNET_SET_ListenMessage *msg;
 804   struct Listener *listener;
 805   struct Operation *op;
 806
 807   msg = (const struct GNUNET_SET_ListenMessage *) m;
 808   /* max. one per client! */
 809   if (NULL != listener_get (client))
 810   {
 811     GNUNET_break (0);
 812     GNUNET_SERVER_client_disconnect (client);
 813     return;
 814   }
 815
 816   listener = GNUNET_new (struct Listener);
 817   listener->client = client;
 818   listener->client_mq = GNUNET_MQ_queue_for_server_client (client);
 819   listener->app_id = msg->app_id;
 820   listener->operation = ntohl (msg->operation);
 821   GNUNET_CONTAINER_DLL_insert_tail (listeners_head,
 822                                     listeners_tail,
 823                                     listener);
 824   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 825               "new listener created (op %u, app %s)\n",
 826               listener->operation,
 827               GNUNET_h2s (&listener->app_id));
 828
 829   /* check for incoming requests the listener is interested in */
 830   for (op = incoming_head; NULL != op; op = op->next)
 831   {
 832     if (NULL == op->spec)
 833     {
 834       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 835                   "request has no spec yet\n");
 836       continue;
 837     }
 838     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 839                 "considering (op: %u, app: %s, suggest: %u)\n",
 840                 op->spec->operation,
 841                 GNUNET_h2s (&op->spec->app_id),
 842                 op->state->suggest_id);
 843
 844     /* don't consider the incoming request if it has been already suggested to a listener */
 845     if (0 != op->state->suggest_id)
 846       continue;
 847     if (listener->operation != op->spec->operation)
 848       continue;
 849     if (0 != GNUNET_CRYPTO_hash_cmp (&listener->app_id, &op->spec->app_id))
 850       continue;
 851     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 852                 "request suggested\n");
 853     incoming_suggest (op, listener);
 854   }
 855   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 856               "considered all incoming requests\n");
 857   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 858 }
 859
 860
 861 /**
 862  * Called when the listening client rejects an operation
 863  * request by another peer.
 864  *
 865  * @param cls unused
 866  * @param client client that sent the message
 867  * @param m message sent by the client
 868  */
 869 static void
 870 handle_client_reject (void *cls,
 871                       struct GNUNET_SERVER_Client *client,
 872                       const struct GNUNET_MessageHeader *m)
 873 {
 874   struct Operation *incoming;
 875   const struct GNUNET_SET_AcceptRejectMessage *msg;
 876
 877   msg = (const struct GNUNET_SET_AcceptRejectMessage *) m;
 878   GNUNET_break (0 == ntohl (msg->request_id));
 879
 880   // no matching incoming operation for this reject
 881   incoming = get_incoming (ntohl (msg->accept_reject_id));
 882   if (NULL == incoming)
 883   {
 884     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 885     return;
 886   }
 887   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 888               "peer request rejected by client\n");
 889
 890   GNUNET_CADET_channel_destroy (incoming->channel);
 891   //channel destruction handler called immediately upon destruction
 892   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 893 }
 894
 895
 896 /**
 897  * Called when a client wants to add/remove an element to/from a
 898  * set it inhabits.
 899  *
 900  * @param cls unused
 901  * @param client client that sent the message
 902  * @param m message sent by the client
 903  */
 904 static void
 905 handle_client_add_remove (void *cls,
 906                           struct GNUNET_SERVER_Client *client,
 907                           const struct GNUNET_MessageHeader *m)
 908 {
 909   struct Set *set;
 910   const struct GNUNET_SET_ElementMessage *msg;
 911   struct GNUNET_SET_Element el;
 912   struct ElementEntry *ee;
 913
 914   // client without a set requested an operation
 915   set = set_get (client);
 916   if (NULL == set)
 917   {
 918     GNUNET_break (0);
 919     GNUNET_SERVER_client_disconnect (client);
 920     return;
 921   }
 922   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 923   msg = (const struct GNUNET_SET_ElementMessage *) m;
 924   el.size = ntohs (m->size) - sizeof *msg;
 925   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 926               "client ins/rem element of size %u\n", el.size);
 927   el.data = &msg[1];
 928   if (GNUNET_MESSAGE_TYPE_SET_REMOVE == ntohs (m->type))
 929   {
 930     struct GNUNET_HashCode hash;
 931
 932     GNUNET_CRYPTO_hash (el.data, el.size, &hash);
 933     ee = GNUNET_CONTAINER_multihashmap_get (set->elements, &hash);
 934     if (NULL == ee)
 935     {
 936       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 937                   "client tried to remove non-existing element\n");
 938       return;
 939     }
 940     if (GNUNET_YES == ee->removed)
 941     {
 942       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 943                   "client tried to remove element twice\n");
 944       return;
 945     }
 946     ee->removed = GNUNET_YES;
 947     ee->generation_removed = set->current_generation;
 948     set->vt->remove (set->state, ee);
 949   }
 950   else
 951   {
 952     struct ElementEntry *ee_dup;
 953
 954     ee = GNUNET_malloc (el.size + sizeof *ee);
 955     ee->element.size = el.size;
 956     memcpy (&ee[1], el.data, el.size);
 957     ee->element.data = &ee[1];
 958     ee->generation_added = set->current_generation;
 959     ee->remote = GNUNET_NO;
 960     GNUNET_CRYPTO_hash (ee->element.data, el.size, &ee->element_hash);
 961     ee_dup = GNUNET_CONTAINER_multihashmap_get (set->elements,
 962                                                 &ee->element_hash);
 963     if (NULL != ee_dup)
 964     {
 965       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 966                   "element inserted twice, ignoring\n");
 967       GNUNET_free (ee);
 968       return;
 969     }
 970     GNUNET_CONTAINER_multihashmap_put (set->elements, &ee->element_hash, ee,
 971                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
 972     set->vt->add (set->state, ee);
 973   }
 974 }
 975
 976
 977 /**
 978  * Called when a client wants to evaluate a set operation with another peer.
 979  *
 980  * @param cls unused
 981  * @param client client that sent the message
 982  * @param m message sent by the client
 983  */
 984 static void
 985 handle_client_evaluate (void *cls,
 986                         struct GNUNET_SERVER_Client *client,
 987                         const struct GNUNET_MessageHeader *m)
 988 {
 989   struct Set *set;
 990   const struct GNUNET_SET_EvaluateMessage *msg;
 991   struct OperationSpecification *spec;
 992   struct Operation *op;
 993
 994   set = set_get (client);
 995   if (NULL == set)
 996   {
 997     GNUNET_break (0);
 998     GNUNET_SERVER_client_disconnect (client);
 999     return;
1000   }
1001
1002   msg = (const struct GNUNET_SET_EvaluateMessage *) m;
1003   spec = GNUNET_new (struct OperationSpecification);
1004   spec->operation = set->operation;
1005   spec->app_id = msg->app_id;
1006   spec->salt = ntohl (msg->salt);
1007   spec->peer = msg->target_peer;
1008   spec->set = set;
1009   spec->result_mode = ntohs (msg->result_mode);
1010   spec->client_request_id = ntohl (msg->request_id);
1011   spec->context_msg = GNUNET_MQ_extract_nested_mh (msg);
1012
1013   // for simplicity we just backup the context msg instead of rebuilding it later on
1014   if (NULL != spec->context_msg)
1015     spec->context_msg = GNUNET_copy_message (spec->context_msg);
1016
1017   op = GNUNET_new (struct Operation);
1018   op->spec = spec;
1019   op->generation_created = set->current_generation++;
1020   op->vt = set->vt;
1021   GNUNET_CONTAINER_DLL_insert (set->ops_head, set->ops_tail, op);
1022
1023   op->channel = GNUNET_CADET_channel_create (cadet, op, &msg->target_peer,
1024                                             GNUNET_APPLICATION_TYPE_SET,
1025                                             GNUNET_CADET_OPTION_RELIABLE);
1026
1027   op->mq = GNUNET_CADET_mq_create (op->channel);
1028
1029   set->vt->evaluate (op);
1030   GNUNET_SERVER_receive_done (client, GNUNET_OK);
1031 }
1032
1033
1034 /**
1035  * Handle an ack from a client, and send the next element.
1036  *
1037  * @param cls unused
1038  * @param client the client
1039  * @param m the message
1040  */
1041 static void
1042 handle_client_iter_ack (void *cls,
1043                         struct GNUNET_SERVER_Client *client,
1044                         const struct GNUNET_MessageHeader *m)
1045 {
1046   struct Set *set;
1047
1048   // client without a set requested an operation
1049   set = set_get (client);
1050   if (NULL == set)
1051   {
1052     GNUNET_break (0);
1053     GNUNET_SERVER_client_disconnect (client);
1054     return;
1055   }
1056
1057   // client sent an ack, but we were not expecting one
1058   if (NULL == set->iter)
1059   {
1060     GNUNET_break (0);
1061     GNUNET_SERVER_client_disconnect (client);
1062     return;
1063   }
1064
1065   GNUNET_SERVER_receive_done (client, GNUNET_OK);
1066   send_client_element (set);
1067 }
1068
1069
1070 /**
1071  * Handle a request from the client to
1072  * cancel a running set operation.
1073  *
1074  * @param cls unused
1075  * @param client the client
1076  * @param mh the message
1077  */
1078 static void
1079 handle_client_cancel (void *cls,
1080                       struct GNUNET_SERVER_Client *client,
1081                       const struct GNUNET_MessageHeader *mh)
1082 {
1083   const struct GNUNET_SET_CancelMessage *msg =
1084       (const struct GNUNET_SET_CancelMessage *) mh;
1085   struct Set *set;
1086   struct Operation *op;
1087   int found;
1088
1089   // client without a set requested an operation
1090   set = set_get (client);
1091   if (NULL == set)
1092   {
1093     GNUNET_break (0);
1094     GNUNET_SERVER_client_disconnect (client);
1095     return;
1096   }
1097
1098   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1099               "client requested cancel for op %u\n",
1100               ntohl (msg->request_id));
1101
1102   found = GNUNET_NO;
1103   for (op = set->ops_head; NULL != op; op = op->next)
1104   {
1105     if (op->spec->client_request_id == ntohl (msg->request_id))
1106     {
1107       found = GNUNET_YES;
1108       break;
1109     }
1110   }
1111
1112   /* It may happen that the operation was destroyed due to
1113    * the other peer disconnecting.  The client may not know about this
1114    * yet and try to cancel the (non non-existent) operation.
1115    */
1116   if (GNUNET_NO != found)
1117     _GSS_operation_destroy (op,
1118                             GNUNET_YES);
1119   else
1120     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1121                 "client canceled non-existent op\n");
1122
1123
1124   GNUNET_SERVER_receive_done (client, GNUNET_OK);
1125 }
1126
1127
1128 /**
1129  * Handle a request from the client to accept
1130  * a set operation that came from a remote peer.
1131  * We forward the accept to the associated operation for handling
1132  *
1133  * @param cls unused
1134  * @param client the client
1135  * @param mh the message
1136  */
1137 static void
1138 handle_client_accept (void *cls,
1139                       struct GNUNET_SERVER_Client *client,
1140                       const struct GNUNET_MessageHeader *mh)
1141 {
1142   struct Set *set;
1143   const struct GNUNET_SET_AcceptRejectMessage *msg;
1144   struct Operation *op;
1145
1146   msg = (const struct GNUNET_SET_AcceptRejectMessage *) mh;
1147
1148   // client without a set requested an operation
1149   set = set_get (client);
1150
1151   if (NULL == set)
1152   {
1153     GNUNET_break (0);
1154     GNUNET_SERVER_client_disconnect (client);
1155     return;
1156   }
1157
1158   op = get_incoming (ntohl (msg->accept_reject_id));
1159
1160   /* it is not an error if the set op does not exist -- it may
1161    * have been destroyed when the partner peer disconnected. */
1162   if (NULL == op)
1163   {
1164     struct GNUNET_SET_ResultMessage *result_message;
1165     struct GNUNET_MQ_Envelope *ev;
1166     ev = GNUNET_MQ_msg (result_message, GNUNET_MESSAGE_TYPE_SET_RESULT);
1167     result_message->request_id = msg->request_id;
1168     result_message->element_type = 0;
1169     result_message->result_status = htons (GNUNET_SET_STATUS_FAILURE);
1170     GNUNET_MQ_send (set->client_mq, ev);
1171     GNUNET_SERVER_receive_done (client, GNUNET_OK);
1172     return;
1173   }
1174
1175   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1176               "client accepting %u\n",
1177               ntohl (msg->accept_reject_id));
1178
1179   GNUNET_assert (GNUNET_YES == op->is_incoming);
1180
1181
1182   op->spec->set = set;
1183
1184   GNUNET_assert (GNUNET_YES == op->is_incoming);
1185   op->is_incoming = GNUNET_NO;
1186   GNUNET_assert (NULL != op->state);
1187   GNUNET_free (op->state);
1188   op->state = NULL;
1189   GNUNET_CONTAINER_DLL_remove (incoming_head,
1190                                incoming_tail,
1191                                op);
1192
1193   GNUNET_assert (NULL != op->spec->set);
1194   GNUNET_assert (NULL != op->spec->set->vt);
1195
1196   GNUNET_CONTAINER_DLL_insert (set->ops_head,
1197                                set->ops_tail,
1198                                op);
1199
1200   op->spec->client_request_id = ntohl (msg->request_id);
1201   op->spec->result_mode = ntohs (msg->result_mode);
1202   op->generation_created = set->current_generation++;
1203   op->vt = op->spec->set->vt;
1204   GNUNET_assert (NULL != op->vt->accept);
1205   set->vt->accept (op);
1206   GNUNET_SERVER_receive_done (client, GNUNET_OK);
1207 }
1208
1209
1210 /**
1211  * Called to clean up, after a shutdown has been requested.
1212  *
1213  * @param cls closure
1214  * @param tc context information (why was this task triggered now)
1215  */
1216 static void
1217 shutdown_task (void *cls,
1218                const struct GNUNET_SCHEDULER_TaskContext *tc)
1219 {
1220   while (NULL != incoming_head)
1221     incoming_destroy (incoming_head);
1222
1223   while (NULL != listeners_head)
1224     listener_destroy (listeners_head);
1225
1226   while (NULL != sets_head)
1227     set_destroy (sets_head);
1228
1229   /* it's important to destroy cadet at the end, as all channels
1230    * must be destroyed before the cadet handle! */
1231   if (NULL != cadet)
1232   {
1233     GNUNET_CADET_disconnect (cadet);
1234     cadet = NULL;
1235   }
1236   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1237               "handled shutdown request\n");
1238 }
1239
1240
1241 /**
1242  * Timeout happens iff:
1243  *  - we suggested an operation to our listener,
1244  *    but did not receive a response in time
1245  *  - we got the channel from a peer but no #GNUNET_MESSAGE_TYPE_SET_P2P_OPERATION_REQUEST
1246  *  - shutdown (obviously)
1247  *
1248  * @param cls channel context
1249  * @param tc context information (why was this task triggered now)
1250  */
1251 static void
1252 incoming_timeout_cb (void *cls,
1253                      const struct GNUNET_SCHEDULER_TaskContext *tc)
1254 {
1255   struct Operation *incoming = cls;
1256
1257   incoming->state->timeout_task = GNUNET_SCHEDULER_NO_TASK;
1258   GNUNET_assert (GNUNET_YES == incoming->is_incoming);
1259   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
1260     return;
1261   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1262               "remote peer timed out\n");
1263   incoming_destroy (incoming);
1264 }
1265
1266
1267 /**
1268  * Terminates an incoming operation in case we have not yet received an
1269  * operation request. Called by the channel destruction handler.
1270  *
1271  * @param op the channel context
1272  */
1273 static void
1274 handle_incoming_disconnect (struct Operation *op)
1275 {
1276   GNUNET_assert (GNUNET_YES == op->is_incoming);
1277   /* channel is already dead, incoming_destroy must not
1278    * destroy it ... */
1279   op->channel = NULL;
1280   incoming_destroy (op);
1281   op->vt = NULL;
1282 }
1283
1284
1285 /**
1286  * Method called whenever another peer has added us to a channel
1287  * the other peer initiated.
1288  * Only called (once) upon reception of data with a message type which was
1289  * subscribed to in GNUNET_CADET_connect().
1290  *
1291  * The channel context represents the operation itself and gets added to a DLL,
1292  * from where it gets looked up when our local listener client responds
1293  * to a proposed/suggested operation or connects and associates with this operation.
1294  *
1295  * @param cls closure
1296  * @param channel new handle to the channel
1297  * @param initiator peer that started the channel
1298  * @param port Port this channel is for.
1299  * @param options Unused.
1300  * @return initial channel context for the channel
1301  *         (can be NULL -- that's not an error)
1302  */
1303 static void *
1304 channel_new_cb (void *cls,
1305                struct GNUNET_CADET_Channel *channel,
1306                const struct GNUNET_PeerIdentity *initiator,
1307                uint32_t port, enum GNUNET_CADET_ChannelOption options)
1308 {
1309   struct Operation *incoming;
1310   static const struct SetVT incoming_vt = {
1311     .msg_handler = handle_incoming_msg,
1312     .peer_disconnect = handle_incoming_disconnect
1313   };
1314
1315   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1316               "new incoming channel\n");
1317
1318   if (GNUNET_APPLICATION_TYPE_SET != port)
1319   {
1320     GNUNET_break (0);
1321     GNUNET_CADET_channel_destroy (channel);
1322     return NULL;
1323   }
1324
1325   incoming = GNUNET_new (struct Operation);
1326   incoming->is_incoming = GNUNET_YES;
1327   incoming->state = GNUNET_new (struct OperationState);
1328   incoming->state->peer = *initiator;
1329   incoming->channel = channel;
1330   incoming->mq = GNUNET_CADET_mq_create (incoming->channel);
1331   incoming->vt = &incoming_vt;
1332   incoming->state->timeout_task =
1333       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
1334                                     &incoming_timeout_cb,
1335                                     incoming);
1336   GNUNET_CONTAINER_DLL_insert_tail (incoming_head,
1337                                     incoming_tail,
1338                                     incoming);
1339
1340   return incoming;
1341 }
1342
1343
1344 /**
1345  * Function called whenever a channel is destroyed.  Should clean up
1346  * any associated state.  It must NOT call
1347  * GNUNET_CADET_channel_destroy() on the channel.
1348  *
1349  * The peer_disconnect function is part of a a virtual table set initially either
1350  * when a peer creates a new channel with us (channel_new_cb), or once we create
1351  * a new channel ourselves (evaluate).
1352  *
1353  * Once we know the exact type of operation (union/intersection), the vt is
1354  * replaced with an operation specific instance (_GSS_[op]_vt).
1355  *
1356  * @param cls closure (set from GNUNET_CADET_connect())
1357  * @param channel connection to the other end (henceforth invalid)
1358  * @param channel_ctx place where local state associated
1359  *                   with the channel is stored
1360  */
1361 static void
1362 channel_end_cb (void *cls,
1363                 const struct GNUNET_CADET_Channel *channel,
1364                 void *channel_ctx)
1365 {
1366   struct Operation *op = channel_ctx;
1367
1368   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1369               "channel end cb called\n");
1370   op->channel = NULL;
1371   /* the vt can be null if a client already requested canceling op. */
1372   if (NULL != op->vt)
1373   {
1374     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1375                 "calling peer disconnect due to channel end\n");
1376     op->vt->peer_disconnect (op);
1377   }
1378
1379   if (GNUNET_YES == op->keep)
1380     return;
1381
1382   /* cadet will never call us with the context again! */
1383   GNUNET_free (channel_ctx);
1384   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1385               "channel end cb finished\n");
1386 }
1387
1388
1389 /**
1390  * Functions with this signature are called whenever a message is
1391  * received via a cadet channel.
1392  *
1393  * The msg_handler is a virtual table set in initially either when a peer
1394  * creates a new channel with us (channel_new_cb), or once we create a new channel
1395  * ourselves (evaluate).
1396  *
1397  * Once we know the exact type of operation (union/intersection), the vt is
1398  * replaced with an operation specific instance (_GSS_[op]_vt).
1399  *
1400  * @param cls Closure (set from GNUNET_CADET_connect()).
1401  * @param channel Connection to the other end.
1402  * @param channel_ctx Place to store local state associated with the channel.
1403  * @param message The actual message.
1404  * @return #GNUNET_OK to keep the channel open,
1405  *         #GNUNET_SYSERR to close it (signal serious error).
1406  */
1407 static int
1408 dispatch_p2p_message (void *cls,
1409                       struct GNUNET_CADET_Channel *channel,
1410                       void **channel_ctx,
1411                       const struct GNUNET_MessageHeader *message)
1412 {
1413   struct Operation *op = *channel_ctx;
1414   int ret;
1415
1416   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1417               "dispatching cadet message (type: %u)\n",
1418               ntohs (message->type));
1419   /* do this before the handler, as the handler might kill the channel */
1420   GNUNET_CADET_receive_done (channel);
1421   if (NULL != op->vt)
1422     ret = op->vt->msg_handler (op, message);
1423   else
1424     ret = GNUNET_SYSERR;
1425   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1426               "handled cadet message (type: %u)\n",
1427               ntohs (message->type));
1428   return ret;
1429 }
1430
1431
1432 /**
1433  * Function called by the service's run
1434  * method to run service-specific setup code.
1435  *
1436  * @param cls closure
1437  * @param server the initialized server
1438  * @param cfg configuration to use
1439  */
1440 static void
1441 run (void *cls, struct GNUNET_SERVER_Handle *server,
1442      const struct GNUNET_CONFIGURATION_Handle *cfg)
1443 {
1444   static const struct GNUNET_SERVER_MessageHandler server_handlers[] = {
1445     {handle_client_accept, NULL, GNUNET_MESSAGE_TYPE_SET_ACCEPT,
1446         sizeof (struct GNUNET_SET_AcceptRejectMessage)},
1447     {handle_client_iter_ack, NULL, GNUNET_MESSAGE_TYPE_SET_ITER_ACK, 0},
1448     {handle_client_add_remove, NULL, GNUNET_MESSAGE_TYPE_SET_ADD, 0},
1449     {handle_client_create_set, NULL, GNUNET_MESSAGE_TYPE_SET_CREATE,
1450         sizeof (struct GNUNET_SET_CreateMessage)},
1451     {handle_client_iterate, NULL, GNUNET_MESSAGE_TYPE_SET_ITER_REQUEST,
1452         sizeof (struct GNUNET_MessageHeader)},
1453     {handle_client_evaluate, NULL, GNUNET_MESSAGE_TYPE_SET_EVALUATE, 0},
1454     {handle_client_listen, NULL, GNUNET_MESSAGE_TYPE_SET_LISTEN,
1455         sizeof (struct GNUNET_SET_ListenMessage)},
1456     {handle_client_reject, NULL, GNUNET_MESSAGE_TYPE_SET_REJECT,
1457         sizeof (struct GNUNET_SET_AcceptRejectMessage)},
1458     {handle_client_add_remove, NULL, GNUNET_MESSAGE_TYPE_SET_REMOVE, 0},
1459     {handle_client_cancel, NULL, GNUNET_MESSAGE_TYPE_SET_CANCEL,
1460         sizeof (struct GNUNET_SET_CancelMessage)},
1461     {NULL, NULL, 0, 0}
1462   };
1463   static const struct GNUNET_CADET_MessageHandler cadet_handlers[] = {
1464     {dispatch_p2p_message, GNUNET_MESSAGE_TYPE_SET_P2P_OPERATION_REQUEST, 0},
1465     {dispatch_p2p_message, GNUNET_MESSAGE_TYPE_SET_UNION_P2P_IBF, 0},
1466     {dispatch_p2p_message, GNUNET_MESSAGE_TYPE_SET_P2P_ELEMENTS, 0},
1467     {dispatch_p2p_message, GNUNET_MESSAGE_TYPE_SET_P2P_DONE, 0},
1468     {dispatch_p2p_message, GNUNET_MESSAGE_TYPE_SET_P2P_ELEMENT_REQUESTS, 0},
1469     {dispatch_p2p_message, GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SE, 0},
1470     {dispatch_p2p_message, GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_ELEMENT_INFO, 0},
1471     {dispatch_p2p_message, GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_BF, 0},
1472     {dispatch_p2p_message, GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_BF_PART, 0},
1473     {NULL, 0, 0}
1474   };
1475   static const uint32_t cadet_ports[] = {GNUNET_APPLICATION_TYPE_SET, 0};
1476
1477   configuration = cfg;
1478   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
1479                                 &shutdown_task, NULL);
1480   GNUNET_SERVER_disconnect_notify (server, &handle_client_disconnect, NULL);
1481   GNUNET_SERVER_add_handlers (server, server_handlers);
1482
1483   cadet = GNUNET_CADET_connect (cfg, NULL, channel_new_cb, channel_end_cb,
1484                               cadet_handlers, cadet_ports);
1485   if (NULL == cadet)
1486   {
1487     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1488                 _("Could not connect to cadet service\n"));
1489     return;
1490   }
1491 }
1492
1493
1494 /**
1495  * The main function for the set service.
1496  *
1497  * @param argc number of arguments from the command line
1498  * @param argv command line arguments
1499  * @return 0 ok, 1 on error
1500  */
1501 int
1502 main (int argc, char *const *argv)
1503 {
1504   int ret;
1505
1506   ret = GNUNET_SERVICE_run (argc, argv, "set",
1507                             GNUNET_SERVICE_OPTION_NONE, &run, NULL);
1508   return (GNUNET_OK == ret) ? 0 : 1;
1509 }
1510
1511 /* end of gnunet-service-set.c */
1512