452ded8a39e10969d40b9c3f882bc6bc3f2601b9
[oweals/gnunet.git] / src / set / gnunet-service-set.c
1 /*
2       This file is part of GNUnet
3       (C) 2013, 2014 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  * @file set/gnunet-service-set.c
22  * @brief two-peer set operations
23  * @author Florian Dold
24  * @author Christian Grothoff
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,
573                                  GNUNET_MESSAGE_TYPE_SET_REQUEST,
574                                  incoming->spec->context_msg);
575   GNUNET_assert (NULL != mqm);
576   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
577               "suggesting request with accept id %u\n",
578               incoming->state->suggest_id);
579   cmsg->accept_id = htonl (incoming->state->suggest_id);
580   cmsg->peer_id = incoming->spec->peer;
581   GNUNET_MQ_send (listener->client_mq, mqm);
582 }
583
584
585 /**
586  * Handle a request for a set operation from
587  * another peer.
588  *
589  * This msg is expected as the first and only msg handled through the
590  * non-operation bound virtual table, acceptance of this operation replaces
591  * our virtual table and subsequent msgs would be routed differently.
592  *
593  * @param op the operation state
594  * @param mh the received message
595  * @return #GNUNET_OK if the channel should be kept alive,
596  *         #GNUNET_SYSERR to destroy the channel
597  */
598 static int
599 handle_incoming_msg (struct Operation *op,
600                      const struct GNUNET_MessageHeader *mh)
601 {
602   const struct OperationRequestMessage *msg;
603   struct Listener *listener;
604   struct OperationSpecification *spec;
605
606   msg = (const struct OperationRequestMessage *) mh;
607   GNUNET_assert (GNUNET_YES == op->is_incoming);
608
609   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
610               "got op request\n");
611
612   if (GNUNET_MESSAGE_TYPE_SET_P2P_OPERATION_REQUEST != ntohs (mh->type))
613   {
614     GNUNET_break_op (0);
615     return GNUNET_SYSERR;
616   }
617
618   /* double operation request */
619   if (NULL != op->spec)
620   {
621     GNUNET_break_op (0);
622     return GNUNET_SYSERR;
623   }
624
625   spec = GNUNET_new (struct OperationSpecification);
626   spec->context_msg = GNUNET_MQ_extract_nested_mh (msg);
627   // for simplicity we just backup the context msg instead of rebuilding it later on
628   if (NULL != spec->context_msg)
629     spec->context_msg = GNUNET_copy_message (spec->context_msg);
630   spec->operation = ntohl (msg->operation);
631   spec->app_id = msg->app_id;
632   spec->salt = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
633                                          UINT32_MAX);
634   spec->peer = op->state->peer;
635   spec->remote_element_count = ntohl (msg->element_count);
636
637   op->spec = spec;
638
639   if ( (NULL != spec->context_msg) &&
640        (ntohs (spec->context_msg->size) > GNUNET_SET_CONTEXT_MESSAGE_MAX_SIZE) )
641   {
642     GNUNET_break_op (0);
643     return GNUNET_SYSERR;
644   }
645
646   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
647               "received P2P operation request (op %u, app %s)\n",
648               ntohl (msg->operation),
649               GNUNET_h2s (&msg->app_id));
650   listener = listener_get_by_target (ntohl (msg->operation),
651                                      &msg->app_id);
652   if (NULL == listener)
653   {
654     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
655                 "no listener matches incoming request, waiting with timeout\n");
656     return GNUNET_OK;
657   }
658   incoming_suggest (op, listener);
659   return GNUNET_OK;
660 }
661
662
663 /**
664  * Send the next element of a set to the set's client.  The next element is given by
665  * the set's current hashmap iterator.  The set's iterator will be set to NULL if there
666  * are no more elements in the set.  The caller must ensure that the set's iterator is
667  * valid.
668  *
669  * @param set set that should send its next element to its client
670  */
671 static void
672 send_client_element (struct Set *set)
673 {
674   int ret;
675   struct ElementEntry *ee;
676   struct GNUNET_MQ_Envelope *ev;
677
678   GNUNET_assert (NULL != set->iter);
679   ret = GNUNET_CONTAINER_multihashmap_iterator_next (set->iter,
680                                                      NULL,
681                                                      (const void **) &ee);
682   if (GNUNET_NO == ret)
683   {
684     ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SET_ITER_DONE);
685     GNUNET_CONTAINER_multihashmap_iterator_destroy (set->iter);
686     set->iter = NULL;
687   }
688   else
689   {
690     struct GNUNET_SET_IterResponseMessage *msg;
691
692     GNUNET_assert (NULL != ee);
693     ev = GNUNET_MQ_msg_extra (msg,
694                               ee->element.size,
695                               GNUNET_MESSAGE_TYPE_SET_ITER_ELEMENT);
696     memcpy (&msg[1], ee->element.data, ee->element.size);
697     msg->element_type = ee->element.type;
698   }
699   GNUNET_MQ_send (set->client_mq, ev);
700 }
701
702
703 /**
704  * Called when a client wants to iterate the elements of a set.
705  *
706  * @param cls unused
707  * @param client client that sent the message
708  * @param m message sent by the client
709  */
710 static void
711 handle_client_iterate (void *cls,
712                        struct GNUNET_SERVER_Client *client,
713                        const struct GNUNET_MessageHeader *m)
714 {
715   struct Set *set;
716
717   // iterate over a non existing set
718   set = set_get (client);
719   if (NULL == set)
720   {
721     GNUNET_break (0);
722     GNUNET_SERVER_client_disconnect (client);
723     return;
724   }
725
726   // only one concurrent iterate-action per set
727   if (NULL != set->iter)
728   {
729     GNUNET_break (0);
730     GNUNET_SERVER_client_disconnect (client);
731     return;
732   }
733   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
734               "iterating union set with %u elements\n",
735               GNUNET_CONTAINER_multihashmap_size (set->elements));
736   GNUNET_SERVER_receive_done (client, GNUNET_OK);
737   set->iter = GNUNET_CONTAINER_multihashmap_iterator_create (set->elements);
738   send_client_element (set);
739 }
740
741
742 /**
743  * Called when a client wants to create a new set.
744  *
745  * @param cls unused
746  * @param client client that sent the message
747  * @param m message sent by the client
748  */
749 static void
750 handle_client_create_set (void *cls,
751                           struct GNUNET_SERVER_Client *client,
752                           const struct GNUNET_MessageHeader *m)
753 {
754   const struct GNUNET_SET_CreateMessage *msg;
755   struct Set *set;
756
757   msg = (const struct GNUNET_SET_CreateMessage *) m;
758   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
759               "client created new set (operation %u)\n",
760               ntohs (msg->operation));
761
762   // max. one set per client!
763   if (NULL != set_get (client))
764   {
765     GNUNET_break (0);
766     GNUNET_SERVER_client_disconnect (client);
767     return;
768   }
769
770   set = GNUNET_new (struct Set);
771
772   switch (ntohl (msg->operation))
773   {
774   case GNUNET_SET_OPERATION_INTERSECTION:
775     set->vt = _GSS_intersection_vt ();
776     break;
777   case GNUNET_SET_OPERATION_UNION:
778     set->vt = _GSS_union_vt ();
779     break;
780   default:
781     GNUNET_free (set);
782     GNUNET_break (0);
783     GNUNET_SERVER_client_disconnect (client);
784     return;
785   }
786
787   set->state = set->vt->create ();
788   set->elements = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_YES);
789   set->client = client;
790   set->client_mq = GNUNET_MQ_queue_for_server_client (client);
791   GNUNET_CONTAINER_DLL_insert (sets_head, sets_tail, set);
792   GNUNET_SERVER_receive_done (client, GNUNET_OK);
793 }
794
795
796 /**
797  * Called when a client wants to create a new listener.
798  *
799  * @param cls unused
800  * @param client client that sent the message
801  * @param m message sent by the client
802  */
803 static void
804 handle_client_listen (void *cls,
805                       struct GNUNET_SERVER_Client *client,
806                       const struct GNUNET_MessageHeader *m)
807 {
808   const struct GNUNET_SET_ListenMessage *msg;
809   struct Listener *listener;
810   struct Operation *op;
811
812   msg = (const struct GNUNET_SET_ListenMessage *) m;
813   /* max. one per client! */
814   if (NULL != listener_get (client))
815   {
816     GNUNET_break (0);
817     GNUNET_SERVER_client_disconnect (client);
818     return;
819   }
820
821   listener = GNUNET_new (struct Listener);
822   listener->client = client;
823   listener->client_mq = GNUNET_MQ_queue_for_server_client (client);
824   listener->app_id = msg->app_id;
825   listener->operation = ntohl (msg->operation);
826   GNUNET_CONTAINER_DLL_insert_tail (listeners_head,
827                                     listeners_tail,
828                                     listener);
829   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
830               "new listener created (op %u, app %s)\n",
831               listener->operation,
832               GNUNET_h2s (&listener->app_id));
833
834   /* check for incoming requests the listener is interested in */
835   for (op = incoming_head; NULL != op; op = op->next)
836   {
837     if (NULL == op->spec)
838     {
839       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
840                   "request has no spec yet\n");
841       continue;
842     }
843     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
844                 "considering (op: %u, app: %s, suggest: %u)\n",
845                 op->spec->operation,
846                 GNUNET_h2s (&op->spec->app_id),
847                 op->state->suggest_id);
848
849     /* don't consider the incoming request if it has been already suggested to a listener */
850     if (0 != op->state->suggest_id)
851       continue;
852     if (listener->operation != op->spec->operation)
853       continue;
854     if (0 != GNUNET_CRYPTO_hash_cmp (&listener->app_id, &op->spec->app_id))
855       continue;
856     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
857                 "request suggested\n");
858     incoming_suggest (op, listener);
859   }
860   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
861               "considered all incoming requests\n");
862   GNUNET_SERVER_receive_done (client, GNUNET_OK);
863 }
864
865
866 /**
867  * Called when the listening client rejects an operation
868  * request by another peer.
869  *
870  * @param cls unused
871  * @param client client that sent the message
872  * @param m message sent by the client
873  */
874 static void
875 handle_client_reject (void *cls,
876                       struct GNUNET_SERVER_Client *client,
877                       const struct GNUNET_MessageHeader *m)
878 {
879   struct Operation *incoming;
880   const struct GNUNET_SET_RejectMessage *msg;
881
882   msg = (const struct GNUNET_SET_RejectMessage *) m;
883   GNUNET_break (0 == ntohl (msg->request_id));
884
885   // no matching incoming operation for this reject
886   incoming = get_incoming (ntohl (msg->accept_reject_id));
887   if (NULL == incoming)
888   {
889     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
890     return;
891   }
892   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
893               "peer request rejected by client\n");
894
895   GNUNET_CADET_channel_destroy (incoming->channel);
896   //channel destruction handler called immediately upon destruction
897   GNUNET_SERVER_receive_done (client, GNUNET_OK);
898 }
899
900
901 /**
902  * Called when a client wants to add/remove an element to/from a
903  * set it inhabits.
904  *
905  * @param cls unused
906  * @param client client that sent the message
907  * @param m message sent by the client
908  */
909 static void
910 handle_client_add_remove (void *cls,
911                           struct GNUNET_SERVER_Client *client,
912                           const struct GNUNET_MessageHeader *m)
913 {
914   struct Set *set;
915   const struct GNUNET_SET_ElementMessage *msg;
916   struct GNUNET_SET_Element el;
917   struct ElementEntry *ee;
918
919   // client without a set requested an operation
920   set = set_get (client);
921   if (NULL == set)
922   {
923     GNUNET_break (0);
924     GNUNET_SERVER_client_disconnect (client);
925     return;
926   }
927   GNUNET_SERVER_receive_done (client, GNUNET_OK);
928   msg = (const struct GNUNET_SET_ElementMessage *) m;
929   el.size = ntohs (m->size) - sizeof *msg;
930   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
931               "client ins/rem element of size %u\n", el.size);
932   el.data = &msg[1];
933   if (GNUNET_MESSAGE_TYPE_SET_REMOVE == ntohs (m->type))
934   {
935     struct GNUNET_HashCode hash;
936
937     GNUNET_CRYPTO_hash (el.data, el.size, &hash);
938     ee = GNUNET_CONTAINER_multihashmap_get (set->elements, &hash);
939     if (NULL == ee)
940     {
941       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
942                   "client tried to remove non-existing element\n");
943       return;
944     }
945     if (GNUNET_YES == ee->removed)
946     {
947       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
948                   "client tried to remove element twice\n");
949       return;
950     }
951     ee->removed = GNUNET_YES;
952     ee->generation_removed = set->current_generation;
953     set->vt->remove (set->state, ee);
954   }
955   else
956   {
957     struct ElementEntry *ee_dup;
958
959     ee = GNUNET_malloc (el.size + sizeof *ee);
960     ee->element.size = el.size;
961     memcpy (&ee[1], el.data, el.size);
962     ee->element.data = &ee[1];
963     ee->generation_added = set->current_generation;
964     ee->remote = GNUNET_NO;
965     GNUNET_CRYPTO_hash (ee->element.data, el.size, &ee->element_hash);
966     ee_dup = GNUNET_CONTAINER_multihashmap_get (set->elements,
967                                                 &ee->element_hash);
968     if (NULL != ee_dup)
969     {
970       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
971                   "element inserted twice, ignoring\n");
972       GNUNET_free (ee);
973       return;
974     }
975     GNUNET_CONTAINER_multihashmap_put (set->elements, &ee->element_hash, ee,
976                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
977     set->vt->add (set->state, ee);
978   }
979 }
980
981
982 /**
983  * Called when a client wants to evaluate a set operation with another peer.
984  *
985  * @param cls unused
986  * @param client client that sent the message
987  * @param m message sent by the client
988  */
989 static void
990 handle_client_evaluate (void *cls,
991                         struct GNUNET_SERVER_Client *client,
992                         const struct GNUNET_MessageHeader *m)
993 {
994   struct Set *set;
995   const struct GNUNET_SET_EvaluateMessage *msg;
996   struct OperationSpecification *spec;
997   struct Operation *op;
998
999   set = set_get (client);
1000   if (NULL == set)
1001   {
1002     GNUNET_break (0);
1003     GNUNET_SERVER_client_disconnect (client);
1004     return;
1005   }
1006
1007   msg = (const struct GNUNET_SET_EvaluateMessage *) m;
1008   spec = GNUNET_new (struct OperationSpecification);
1009   spec->operation = set->operation;
1010   spec->app_id = msg->app_id;
1011   spec->salt = ntohl (msg->salt);
1012   spec->peer = msg->target_peer;
1013   spec->set = set;
1014   spec->result_mode = ntohs (msg->result_mode);
1015   spec->client_request_id = ntohl (msg->request_id);
1016   spec->context_msg = GNUNET_MQ_extract_nested_mh (msg);
1017
1018   // for simplicity we just backup the context msg instead of rebuilding it later on
1019   if (NULL != spec->context_msg)
1020     spec->context_msg = GNUNET_copy_message (spec->context_msg);
1021
1022   op = GNUNET_new (struct Operation);
1023   op->spec = spec;
1024   op->generation_created = set->current_generation++;
1025   op->vt = set->vt;
1026   GNUNET_CONTAINER_DLL_insert (set->ops_head, set->ops_tail, op);
1027
1028   op->channel = GNUNET_CADET_channel_create (cadet, op, &msg->target_peer,
1029                                             GNUNET_APPLICATION_TYPE_SET,
1030                                             GNUNET_CADET_OPTION_RELIABLE);
1031
1032   op->mq = GNUNET_CADET_mq_create (op->channel);
1033
1034   set->vt->evaluate (op);
1035   GNUNET_SERVER_receive_done (client, GNUNET_OK);
1036 }
1037
1038
1039 /**
1040  * Handle an ack from a client, and send the next element.
1041  *
1042  * @param cls unused
1043  * @param client the client
1044  * @param m the message
1045  */
1046 static void
1047 handle_client_iter_ack (void *cls,
1048                         struct GNUNET_SERVER_Client *client,
1049                         const struct GNUNET_MessageHeader *m)
1050 {
1051   struct Set *set;
1052
1053   // client without a set requested an operation
1054   set = set_get (client);
1055   if (NULL == set)
1056   {
1057     GNUNET_break (0);
1058     GNUNET_SERVER_client_disconnect (client);
1059     return;
1060   }
1061
1062   // client sent an ack, but we were not expecting one
1063   if (NULL == set->iter)
1064   {
1065     GNUNET_break (0);
1066     GNUNET_SERVER_client_disconnect (client);
1067     return;
1068   }
1069
1070   GNUNET_SERVER_receive_done (client, GNUNET_OK);
1071   send_client_element (set);
1072 }
1073
1074
1075 /**
1076  * Handle a request from the client to
1077  * cancel a running set operation.
1078  *
1079  * @param cls unused
1080  * @param client the client
1081  * @param mh the message
1082  */
1083 static void
1084 handle_client_cancel (void *cls,
1085                       struct GNUNET_SERVER_Client *client,
1086                       const struct GNUNET_MessageHeader *mh)
1087 {
1088   const struct GNUNET_SET_CancelMessage *msg =
1089       (const struct GNUNET_SET_CancelMessage *) mh;
1090   struct Set *set;
1091   struct Operation *op;
1092   int found;
1093
1094   // client without a set requested an operation
1095   set = set_get (client);
1096   if (NULL == set)
1097   {
1098     GNUNET_break (0);
1099     GNUNET_SERVER_client_disconnect (client);
1100     return;
1101   }
1102
1103   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1104               "client requested cancel for op %u\n",
1105               ntohl (msg->request_id));
1106
1107   found = GNUNET_NO;
1108   for (op = set->ops_head; NULL != op; op = op->next)
1109   {
1110     if (op->spec->client_request_id == ntohl (msg->request_id))
1111     {
1112       found = GNUNET_YES;
1113       break;
1114     }
1115   }
1116
1117   /* It may happen that the operation was destroyed due to
1118    * the other peer disconnecting.  The client may not know about this
1119    * yet and try to cancel the (non non-existent) operation.
1120    */
1121   if (GNUNET_NO != found)
1122     _GSS_operation_destroy (op,
1123                             GNUNET_YES);
1124   else
1125     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1126                 "client canceled non-existent op\n");
1127
1128
1129   GNUNET_SERVER_receive_done (client, GNUNET_OK);
1130 }
1131
1132
1133 /**
1134  * Handle a request from the client to accept
1135  * a set operation that came from a remote peer.
1136  * We forward the accept to the associated operation for handling
1137  *
1138  * @param cls unused
1139  * @param client the client
1140  * @param mh the message
1141  */
1142 static void
1143 handle_client_accept (void *cls,
1144                       struct GNUNET_SERVER_Client *client,
1145                       const struct GNUNET_MessageHeader *mh)
1146 {
1147   struct Set *set;
1148   const struct GNUNET_SET_AcceptMessage *msg;
1149   struct Operation *op;
1150
1151   msg = (const struct GNUNET_SET_AcceptMessage *) mh;
1152
1153   // client without a set requested an operation
1154   set = set_get (client);
1155
1156   if (NULL == set)
1157   {
1158     GNUNET_break (0);
1159     GNUNET_SERVER_client_disconnect (client);
1160     return;
1161   }
1162
1163   op = get_incoming (ntohl (msg->accept_reject_id));
1164
1165   /* it is not an error if the set op does not exist -- it may
1166    * have been destroyed when the partner peer disconnected. */
1167   if (NULL == op)
1168   {
1169     struct GNUNET_SET_ResultMessage *result_message;
1170     struct GNUNET_MQ_Envelope *ev;
1171     ev = GNUNET_MQ_msg (result_message, GNUNET_MESSAGE_TYPE_SET_RESULT);
1172     result_message->request_id = msg->request_id;
1173     result_message->element_type = 0;
1174     result_message->result_status = htons (GNUNET_SET_STATUS_FAILURE);
1175     GNUNET_MQ_send (set->client_mq, ev);
1176     GNUNET_SERVER_receive_done (client, GNUNET_OK);
1177     return;
1178   }
1179
1180   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1181               "client accepting %u\n",
1182               ntohl (msg->accept_reject_id));
1183
1184   GNUNET_assert (GNUNET_YES == op->is_incoming);
1185
1186
1187   op->spec->set = set;
1188
1189   GNUNET_assert (GNUNET_YES == op->is_incoming);
1190   op->is_incoming = GNUNET_NO;
1191   GNUNET_assert (NULL != op->state);
1192   GNUNET_free (op->state);
1193   op->state = NULL;
1194   GNUNET_CONTAINER_DLL_remove (incoming_head,
1195                                incoming_tail,
1196                                op);
1197
1198   GNUNET_assert (NULL != op->spec->set);
1199   GNUNET_assert (NULL != op->spec->set->vt);
1200
1201   GNUNET_CONTAINER_DLL_insert (set->ops_head,
1202                                set->ops_tail,
1203                                op);
1204
1205   op->spec->client_request_id = ntohl (msg->request_id);
1206   op->spec->result_mode = ntohl (msg->result_mode);
1207   op->generation_created = set->current_generation++;
1208   op->vt = op->spec->set->vt;
1209   GNUNET_assert (NULL != op->vt->accept);
1210   set->vt->accept (op);
1211   GNUNET_SERVER_receive_done (client, GNUNET_OK);
1212 }
1213
1214
1215 /**
1216  * Called to clean up, after a shutdown has been requested.
1217  *
1218  * @param cls closure
1219  * @param tc context information (why was this task triggered now)
1220  */
1221 static void
1222 shutdown_task (void *cls,
1223                const struct GNUNET_SCHEDULER_TaskContext *tc)
1224 {
1225   while (NULL != incoming_head)
1226     incoming_destroy (incoming_head);
1227
1228   while (NULL != listeners_head)
1229     listener_destroy (listeners_head);
1230
1231   while (NULL != sets_head)
1232     set_destroy (sets_head);
1233
1234   /* it's important to destroy cadet at the end, as all channels
1235    * must be destroyed before the cadet handle! */
1236   if (NULL != cadet)
1237   {
1238     GNUNET_CADET_disconnect (cadet);
1239     cadet = NULL;
1240   }
1241   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1242               "handled shutdown request\n");
1243 }
1244
1245
1246 /**
1247  * Timeout happens iff:
1248  *  - we suggested an operation to our listener,
1249  *    but did not receive a response in time
1250  *  - we got the channel from a peer but no #GNUNET_MESSAGE_TYPE_SET_P2P_OPERATION_REQUEST
1251  *  - shutdown (obviously)
1252  *
1253  * @param cls channel context
1254  * @param tc context information (why was this task triggered now)
1255  */
1256 static void
1257 incoming_timeout_cb (void *cls,
1258                      const struct GNUNET_SCHEDULER_TaskContext *tc)
1259 {
1260   struct Operation *incoming = cls;
1261
1262   incoming->state->timeout_task = GNUNET_SCHEDULER_NO_TASK;
1263   GNUNET_assert (GNUNET_YES == incoming->is_incoming);
1264   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
1265     return;
1266   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1267               "remote peer timed out\n");
1268   incoming_destroy (incoming);
1269 }
1270
1271
1272 /**
1273  * Terminates an incoming operation in case we have not yet received an
1274  * operation request. Called by the channel destruction handler.
1275  *
1276  * @param op the channel context
1277  */
1278 static void
1279 handle_incoming_disconnect (struct Operation *op)
1280 {
1281   GNUNET_assert (GNUNET_YES == op->is_incoming);
1282   /* channel is already dead, incoming_destroy must not
1283    * destroy it ... */
1284   op->channel = NULL;
1285   incoming_destroy (op);
1286   op->vt = NULL;
1287 }
1288
1289
1290 /**
1291  * Method called whenever another peer has added us to a channel
1292  * the other peer initiated.
1293  * Only called (once) upon reception of data with a message type which was
1294  * subscribed to in GNUNET_CADET_connect().
1295  *
1296  * The channel context represents the operation itself and gets added to a DLL,
1297  * from where it gets looked up when our local listener client responds
1298  * to a proposed/suggested operation or connects and associates with this operation.
1299  *
1300  * @param cls closure
1301  * @param channel new handle to the channel
1302  * @param initiator peer that started the channel
1303  * @param port Port this channel is for.
1304  * @param options Unused.
1305  * @return initial channel context for the channel
1306  *         (can be NULL -- that's not an error)
1307  */
1308 static void *
1309 channel_new_cb (void *cls,
1310                struct GNUNET_CADET_Channel *channel,
1311                const struct GNUNET_PeerIdentity *initiator,
1312                uint32_t port, enum GNUNET_CADET_ChannelOption options)
1313 {
1314   struct Operation *incoming;
1315   static const struct SetVT incoming_vt = {
1316     .msg_handler = handle_incoming_msg,
1317     .peer_disconnect = handle_incoming_disconnect
1318   };
1319
1320   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1321               "new incoming channel\n");
1322
1323   if (GNUNET_APPLICATION_TYPE_SET != port)
1324   {
1325     GNUNET_break (0);
1326     GNUNET_CADET_channel_destroy (channel);
1327     return NULL;
1328   }
1329
1330   incoming = GNUNET_new (struct Operation);
1331   incoming->is_incoming = GNUNET_YES;
1332   incoming->state = GNUNET_new (struct OperationState);
1333   incoming->state->peer = *initiator;
1334   incoming->channel = channel;
1335   incoming->mq = GNUNET_CADET_mq_create (incoming->channel);
1336   incoming->vt = &incoming_vt;
1337   incoming->state->timeout_task =
1338       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
1339                                     &incoming_timeout_cb,
1340                                     incoming);
1341   GNUNET_CONTAINER_DLL_insert_tail (incoming_head,
1342                                     incoming_tail,
1343                                     incoming);
1344
1345   return incoming;
1346 }
1347
1348
1349 /**
1350  * Function called whenever a channel is destroyed.  Should clean up
1351  * any associated state.  It must NOT call
1352  * GNUNET_CADET_channel_destroy() on the channel.
1353  *
1354  * The peer_disconnect function is part of a a virtual table set initially either
1355  * when a peer creates a new channel with us (channel_new_cb), or once we create
1356  * a new channel ourselves (evaluate).
1357  *
1358  * Once we know the exact type of operation (union/intersection), the vt is
1359  * replaced with an operation specific instance (_GSS_[op]_vt).
1360  *
1361  * @param cls closure (set from GNUNET_CADET_connect())
1362  * @param channel connection to the other end (henceforth invalid)
1363  * @param channel_ctx place where local state associated
1364  *                   with the channel is stored
1365  */
1366 static void
1367 channel_end_cb (void *cls,
1368                 const struct GNUNET_CADET_Channel *channel,
1369                 void *channel_ctx)
1370 {
1371   struct Operation *op = channel_ctx;
1372
1373   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1374               "channel end cb called\n");
1375   op->channel = NULL;
1376   /* the vt can be null if a client already requested canceling op. */
1377   if (NULL != op->vt)
1378   {
1379     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1380                 "calling peer disconnect due to channel end\n");
1381     op->vt->peer_disconnect (op);
1382   }
1383
1384   if (GNUNET_YES == op->keep)
1385     return;
1386
1387   /* cadet will never call us with the context again! */
1388   GNUNET_free (channel_ctx);
1389   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1390               "channel end cb finished\n");
1391 }
1392
1393
1394 /**
1395  * Functions with this signature are called whenever a message is
1396  * received via a cadet channel.
1397  *
1398  * The msg_handler is a virtual table set in initially either when a peer
1399  * creates a new channel with us (channel_new_cb), or once we create a new channel
1400  * ourselves (evaluate).
1401  *
1402  * Once we know the exact type of operation (union/intersection), the vt is
1403  * replaced with an operation specific instance (_GSS_[op]_vt).
1404  *
1405  * @param cls Closure (set from GNUNET_CADET_connect()).
1406  * @param channel Connection to the other end.
1407  * @param channel_ctx Place to store local state associated with the channel.
1408  * @param message The actual message.
1409  * @return #GNUNET_OK to keep the channel open,
1410  *         #GNUNET_SYSERR to close it (signal serious error).
1411  */
1412 static int
1413 dispatch_p2p_message (void *cls,
1414                       struct GNUNET_CADET_Channel *channel,
1415                       void **channel_ctx,
1416                       const struct GNUNET_MessageHeader *message)
1417 {
1418   struct Operation *op = *channel_ctx;
1419   int ret;
1420
1421   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1422               "dispatching cadet message (type: %u)\n",
1423               ntohs (message->type));
1424   /* do this before the handler, as the handler might kill the channel */
1425   GNUNET_CADET_receive_done (channel);
1426   if (NULL != op->vt)
1427     ret = op->vt->msg_handler (op, message);
1428   else
1429     ret = GNUNET_SYSERR;
1430   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1431               "handled cadet message (type: %u)\n",
1432               ntohs (message->type));
1433   return ret;
1434 }
1435
1436
1437 /**
1438  * Function called by the service's run
1439  * method to run service-specific setup code.
1440  *
1441  * @param cls closure
1442  * @param server the initialized server
1443  * @param cfg configuration to use
1444  */
1445 static void
1446 run (void *cls, struct GNUNET_SERVER_Handle *server,
1447      const struct GNUNET_CONFIGURATION_Handle *cfg)
1448 {
1449   static const struct GNUNET_SERVER_MessageHandler server_handlers[] = {
1450     {handle_client_accept, NULL, GNUNET_MESSAGE_TYPE_SET_ACCEPT,
1451         sizeof (struct GNUNET_SET_AcceptMessage)},
1452     {handle_client_iter_ack, NULL, GNUNET_MESSAGE_TYPE_SET_ITER_ACK, 0},
1453     {handle_client_add_remove, NULL, GNUNET_MESSAGE_TYPE_SET_ADD, 0},
1454     {handle_client_create_set, NULL, GNUNET_MESSAGE_TYPE_SET_CREATE,
1455         sizeof (struct GNUNET_SET_CreateMessage)},
1456     {handle_client_iterate, NULL, GNUNET_MESSAGE_TYPE_SET_ITER_REQUEST,
1457         sizeof (struct GNUNET_MessageHeader)},
1458     {handle_client_evaluate, NULL, GNUNET_MESSAGE_TYPE_SET_EVALUATE, 0},
1459     {handle_client_listen, NULL, GNUNET_MESSAGE_TYPE_SET_LISTEN,
1460         sizeof (struct GNUNET_SET_ListenMessage)},
1461     {handle_client_reject, NULL, GNUNET_MESSAGE_TYPE_SET_REJECT,
1462         sizeof (struct GNUNET_SET_RejectMessage)},
1463     {handle_client_add_remove, NULL, GNUNET_MESSAGE_TYPE_SET_REMOVE, 0},
1464     {handle_client_cancel, NULL, GNUNET_MESSAGE_TYPE_SET_CANCEL,
1465         sizeof (struct GNUNET_SET_CancelMessage)},
1466     {NULL, NULL, 0, 0}
1467   };
1468   static const struct GNUNET_CADET_MessageHandler cadet_handlers[] = {
1469     {dispatch_p2p_message, GNUNET_MESSAGE_TYPE_SET_P2P_OPERATION_REQUEST, 0},
1470     {dispatch_p2p_message, GNUNET_MESSAGE_TYPE_SET_UNION_P2P_IBF, 0},
1471     {dispatch_p2p_message, GNUNET_MESSAGE_TYPE_SET_P2P_ELEMENTS, 0},
1472     {dispatch_p2p_message, GNUNET_MESSAGE_TYPE_SET_P2P_DONE, 0},
1473     {dispatch_p2p_message, GNUNET_MESSAGE_TYPE_SET_P2P_ELEMENT_REQUESTS, 0},
1474     {dispatch_p2p_message, GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SE, 0},
1475     {dispatch_p2p_message, GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_ELEMENT_INFO, 0},
1476     {dispatch_p2p_message, GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_BF, 0},
1477     {dispatch_p2p_message, GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_BF_PART, 0},
1478     {NULL, 0, 0}
1479   };
1480   static const uint32_t cadet_ports[] = {GNUNET_APPLICATION_TYPE_SET, 0};
1481
1482   configuration = cfg;
1483   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
1484                                 &shutdown_task, NULL);
1485   GNUNET_SERVER_disconnect_notify (server, &handle_client_disconnect, NULL);
1486   GNUNET_SERVER_add_handlers (server, server_handlers);
1487
1488   cadet = GNUNET_CADET_connect (cfg, NULL, channel_new_cb, channel_end_cb,
1489                               cadet_handlers, cadet_ports);
1490   if (NULL == cadet)
1491   {
1492     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1493                 _("Could not connect to cadet service\n"));
1494     return;
1495   }
1496 }
1497
1498
1499 /**
1500  * The main function for the set service.
1501  *
1502  * @param argc number of arguments from the command line
1503  * @param argv command line arguments
1504  * @return 0 ok, 1 on error
1505  */
1506 int
1507 main (int argc, char *const *argv)
1508 {
1509   int ret;
1510
1511   ret = GNUNET_SERVICE_run (argc, argv, "set",
1512                             GNUNET_SERVICE_OPTION_NONE, &run, NULL);
1513   return (GNUNET_OK == ret) ? 0 : 1;
1514 }
1515
1516 /* end of gnunet-service-set.c */
1517