doxygen
[oweals/gnunet.git] / src / transport / gnunet-service-transport_blacklist.c
1 /*
2      This file is part of GNUnet.
3      (C) 2010,2011 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 transport/gnunet-service-transport_blacklist.c
23  * @brief blacklisting implementation
24  * @author Christian Grothoff
25  */
26 #include "platform.h"
27 #include "gnunet-service-transport.h"
28 #include "gnunet-service-transport_blacklist.h"
29 #include "gnunet-service-transport_neighbours.h"
30 #include "transport.h"
31
32
33 /**
34  * Size of the blacklist hash map.
35  */
36 #define TRANSPORT_BLACKLIST_HT_SIZE 64
37
38
39 /**
40  * Context we use when performing a blacklist check.
41  */
42 struct GST_BlacklistCheck;
43
44
45 /**
46  * Information kept for each client registered to perform
47  * blacklisting.
48  */
49 struct Blacklisters
50 {
51   /**
52    * This is a linked list.
53    */
54   struct Blacklisters *next;
55
56   /**
57    * This is a linked list.
58    */
59   struct Blacklisters *prev;
60
61   /**
62    * Client responsible for this entry.
63    */
64   struct GNUNET_SERVER_Client *client;
65
66   /**
67    * Blacklist check that we're currently performing (or NULL
68    * if we're performing one that has been cancelled).
69    */
70   struct GST_BlacklistCheck *bc;
71
72   /**
73    * Set to GNUNET_YES if we're currently waiting for a reply.
74    */
75   int waiting_for_reply;
76
77 };
78
79
80
81 /**
82  * Context we use when performing a blacklist check.
83  */
84 struct GST_BlacklistCheck
85 {
86
87   /**
88    * This is a linked list.
89    */
90   struct GST_BlacklistCheck *next;
91
92   /**
93    * This is a linked list.
94    */
95   struct GST_BlacklistCheck *prev;
96
97   /**
98    * Peer being checked.
99    */
100   struct GNUNET_PeerIdentity peer;
101
102   /**
103    * Continuation to call with the result.
104    */
105   GST_BlacklistTestContinuation cont;
106
107   /**
108    * Closure for cont.
109    */
110   void *cont_cls;
111
112   /**
113    * Current transmission request handle for this client, or NULL if no
114    * request is pending.
115    */
116   struct GNUNET_SERVER_TransmitHandle *th;
117
118   /**
119    * Our current position in the blacklisters list.
120    */
121   struct Blacklisters *bl_pos;
122
123   /**
124    * Current task performing the check.
125    */
126   GNUNET_SCHEDULER_TaskIdentifier task;
127
128 };
129
130
131 /**
132  * Head of DLL of active blacklisting queries.
133  */
134 static struct GST_BlacklistCheck *bc_head;
135
136 /**
137  * Tail of DLL of active blacklisting queries.
138  */
139 static struct GST_BlacklistCheck *bc_tail;
140
141 /**
142  * Head of DLL of blacklisting clients.
143  */
144 static struct Blacklisters *bl_head;
145
146 /**
147  * Tail of DLL of blacklisting clients.
148  */
149 static struct Blacklisters *bl_tail;
150
151 /**
152  * Hashmap of blacklisted peers.  Values are of type 'char *' (transport names),
153  * can be NULL if we have no static blacklist.
154  */
155 static struct GNUNET_CONTAINER_MultiHashMap *blacklist;
156
157
158 /**
159  * Perform next action in the blacklist check.
160  *
161  * @param cls the 'struct BlacklistCheck*'
162  * @param tc unused
163  */
164 static void
165 do_blacklist_check (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
166
167
168 /**
169  * Called whenever a client is disconnected.  Frees our
170  * resources associated with that client.
171  *
172  * @param cls closure (unused)
173  * @param client identification of the client
174  */
175 static void
176 client_disconnect_notification (void *cls, struct GNUNET_SERVER_Client *client)
177 {
178   struct Blacklisters *bl;
179   struct GST_BlacklistCheck *bc;
180
181   if (client == NULL)
182     return;
183   for (bl = bl_head; bl != NULL; bl = bl->next)
184   {
185     if (bl->client != client)
186       continue;
187     for (bc = bc_head; bc != NULL; bc = bc->next)
188     {
189       if (bc->bl_pos != bl)
190         continue;
191       bc->bl_pos = bl->next;
192       if (bc->th != NULL)
193       {
194         GNUNET_SERVER_notify_transmit_ready_cancel (bc->th);
195         bc->th = NULL;
196       }
197       if (bc->task == GNUNET_SCHEDULER_NO_TASK)
198         bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check, bc);
199       break;
200     }
201     GNUNET_CONTAINER_DLL_remove (bl_head, bl_tail, bl);
202     GNUNET_SERVER_client_drop (bl->client);
203     GNUNET_free (bl);
204     break;
205   }
206 }
207
208
209 /**
210  * Read the blacklist file, containing transport:peer entries.
211  * Provided the transport is loaded, set up hashmap with these
212  * entries to blacklist peers by transport.
213  *
214  */
215 static void
216 read_blacklist_file ()
217 {
218   char *fn;
219   char *data;
220   size_t pos;
221   size_t colon_pos;
222   int tsize;
223   struct GNUNET_PeerIdentity pid;
224   uint64_t fsize;
225   struct GNUNET_CRYPTO_HashAsciiEncoded enc;
226   unsigned int entries_found;
227   char *transport_name;
228
229   if (GNUNET_OK !=
230       GNUNET_CONFIGURATION_get_value_filename (GST_cfg, "TRANSPORT",
231                                                "BLACKLIST_FILE", &fn))
232   {
233     GNUNET_log_config_missing (GNUNET_ERROR_TYPE_DEBUG,
234                                "transport", "BLACKLIST_FILE");
235     return;
236   }
237   if (GNUNET_OK != GNUNET_DISK_file_test (fn))
238   {
239     GNUNET_free (fn);
240     return; /* no blacklist */
241   }
242   if (GNUNET_OK != GNUNET_DISK_file_size (fn,
243       &fsize, GNUNET_NO, GNUNET_YES))
244   {
245     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
246                 _("Could not read blacklist file `%s'\n"), fn);
247     GNUNET_free (fn);
248     return;
249   }
250   if (0 == fsize)
251   {
252     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Blacklist file `%s' is empty.\n",
253                 fn);
254     GNUNET_free (fn);
255     return;
256   }
257   /* FIXME: use mmap */
258   data = GNUNET_malloc_large (fsize);
259   GNUNET_assert (data != NULL);
260   if (fsize != GNUNET_DISK_fn_read (fn, data, fsize))
261   {
262     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
263                 _("Failed to read blacklist from `%s'\n"), fn);
264     GNUNET_free (fn);
265     GNUNET_free (data);
266     return;
267   }
268   entries_found = 0;
269   pos = 0;
270   while ((pos < fsize) && isspace ((unsigned char) data[pos]))
271     pos++;
272   while ((fsize >= sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)) &&
273          (pos <=
274           fsize - sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)))
275   {
276     colon_pos = pos;
277     while ((colon_pos < fsize) && (data[colon_pos] != ':') &&
278            (!isspace ((unsigned char) data[colon_pos])))
279       colon_pos++;
280     if (colon_pos >= fsize)
281     {
282       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
283                   _
284                   ("Syntax error in blacklist file at offset %llu, giving up!\n"),
285                   (unsigned long long) colon_pos);
286       GNUNET_free (fn);
287       GNUNET_free (data);
288       return;
289     }
290
291     if (isspace ((unsigned char) data[colon_pos]))
292     {
293       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
294                   _
295                   ("Syntax error in blacklist file at offset %llu, skipping bytes.\n"),
296                   (unsigned long long) colon_pos);
297       pos = colon_pos;
298       while ((pos < fsize) && isspace ((unsigned char) data[pos]))
299         pos++;
300       continue;
301     }
302     tsize = colon_pos - pos;
303     if ((pos >= fsize) || (pos + tsize >= fsize) ||
304         (tsize == 0))
305     {
306       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
307                   _
308                   ("Syntax error in blacklist file at offset %llu, giving up!\n"),
309                   (unsigned long long) colon_pos);
310       GNUNET_free (fn);
311       GNUNET_free (data);
312       return;
313     }
314
315     if (tsize < 1)
316       continue;
317
318     transport_name = GNUNET_malloc (tsize + 1);
319     memcpy (transport_name, &data[pos], tsize);
320     pos = colon_pos + 1;
321     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
322                 "Read transport name `%s' in blacklist file.\n",
323                 transport_name);
324     memcpy (&enc, &data[pos], sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded));
325     if (!isspace
326         ((unsigned char)
327          enc.encoding[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1]))
328     {
329       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
330                   _
331                   ("Syntax error in blacklist file at offset %llu, skipping bytes.\n"),
332                   (unsigned long long) pos);
333       pos++;
334       while ((pos < fsize) && (!isspace ((unsigned char) data[pos])))
335         pos++;
336       GNUNET_free_non_null (transport_name);
337       continue;
338     }
339     enc.encoding[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] = '\0';
340     if (GNUNET_OK !=
341         GNUNET_CRYPTO_hash_from_string ((char *) &enc, &pid.hashPubKey))
342     {
343       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
344                   _
345                   ("Syntax error in blacklist file at offset %llu, skipping bytes `%s'.\n"),
346                   (unsigned long long) pos, &enc);
347     }
348     else
349     {
350       if (0 !=
351           memcmp (&pid, &GST_my_identity, sizeof (struct GNUNET_PeerIdentity)))
352       {
353         entries_found++;
354         GST_blacklist_add_peer (&pid, transport_name);
355       }
356       else
357       {
358         GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
359                     _("Found myself `%s' in blacklist (useless, ignored)\n"),
360                     GNUNET_i2s (&pid));
361       }
362     }
363     pos = pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded);
364     GNUNET_free_non_null (transport_name);
365     while ((pos < fsize) && isspace ((unsigned char) data[pos]))
366       pos++;
367   }
368   GNUNET_STATISTICS_update (GST_stats, "# Transport entries blacklisted",
369                             entries_found, GNUNET_NO);
370   GNUNET_free (data);
371   GNUNET_free (fn);
372 }
373
374
375 /**
376  * Start blacklist subsystem.
377  *
378  * @param server server used to accept clients from
379  */
380 void
381 GST_blacklist_start (struct GNUNET_SERVER_Handle *server)
382 {
383   read_blacklist_file ();
384   GNUNET_SERVER_disconnect_notify (server, &client_disconnect_notification,
385                                    NULL);
386 }
387
388
389 /**
390  * Free the given entry in the blacklist.
391  *
392  * @param cls unused
393  * @param key host identity (unused)
394  * @param value the blacklist entry
395  * @return GNUNET_OK (continue to iterate)
396  */
397 static int
398 free_blacklist_entry (void *cls, const struct GNUNET_HashCode * key, void *value)
399 {
400   char *be = value;
401
402   GNUNET_free (be);
403   return GNUNET_OK;
404 }
405
406
407 /**
408  * Stop blacklist subsystem.
409  */
410 void
411 GST_blacklist_stop ()
412 {
413   if (NULL != blacklist)
414   {
415     GNUNET_CONTAINER_multihashmap_iterate (blacklist, &free_blacklist_entry,
416                                            NULL);
417     GNUNET_CONTAINER_multihashmap_destroy (blacklist);
418     blacklist = NULL;
419   }
420 }
421
422
423 /**
424  * Transmit blacklist query to the client.
425  *
426  * @param cls the 'struct GST_BlacklistCheck'
427  * @param size number of bytes allowed
428  * @param buf where to copy the message
429  * @return number of bytes copied to buf
430  */
431 static size_t
432 transmit_blacklist_message (void *cls, size_t size, void *buf)
433 {
434   struct GST_BlacklistCheck *bc = cls;
435   struct Blacklisters *bl;
436   struct BlacklistMessage bm;
437
438   bc->th = NULL;
439   if (size == 0)
440   {
441     GNUNET_assert (bc->task == GNUNET_SCHEDULER_NO_TASK);
442     bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check, bc);
443     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
444                 "Failed to send blacklist test for peer `%s' to client\n",
445                 GNUNET_i2s (&bc->peer));
446     return 0;
447   }
448   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
449               "Sending blacklist test for peer `%s' to client\n",
450               GNUNET_i2s (&bc->peer));
451   bl = bc->bl_pos;
452   bm.header.size = htons (sizeof (struct BlacklistMessage));
453   bm.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_QUERY);
454   bm.is_allowed = htonl (0);
455   bm.peer = bc->peer;
456   memcpy (buf, &bm, sizeof (bm));
457   GNUNET_SERVER_receive_done (bl->client, GNUNET_OK);
458   bl->waiting_for_reply = GNUNET_YES;
459   return sizeof (bm);
460 }
461
462
463 /**
464  * Perform next action in the blacklist check.
465  *
466  * @param cls the 'struct GST_BlacklistCheck*'
467  * @param tc unused
468  */
469 static void
470 do_blacklist_check (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
471 {
472   struct GST_BlacklistCheck *bc = cls;
473   struct Blacklisters *bl;
474
475   bc->task = GNUNET_SCHEDULER_NO_TASK;
476   bl = bc->bl_pos;
477   if (bl == NULL)
478   {
479     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
480                 "No other blacklist clients active, will allow neighbour `%s'\n",
481                 GNUNET_i2s (&bc->peer));
482     bc->cont (bc->cont_cls, &bc->peer, GNUNET_OK);
483     GNUNET_CONTAINER_DLL_remove(bc_head, bc_tail, bc);
484     GNUNET_free (bc);
485     return;
486   }
487   if ((bl->bc != NULL) || (bl->waiting_for_reply != GNUNET_NO))
488     return;                     /* someone else busy with this client */
489   bl->bc = bc;
490   bc->th =
491       GNUNET_SERVER_notify_transmit_ready (bl->client,
492                                            sizeof (struct BlacklistMessage),
493                                            GNUNET_TIME_UNIT_FOREVER_REL,
494                                            &transmit_blacklist_message, bc);
495 }
496
497
498 /**
499  * Got the result about an existing connection from a new blacklister.
500  * Shutdown the neighbour if necessary.
501  *
502  * @param cls unused
503  * @param peer the neighbour that was investigated
504  * @param allowed GNUNET_OK if we can keep it,
505  *                GNUNET_NO if we must shutdown the connection
506  */
507 static void
508 confirm_or_drop_neighbour (void *cls, const struct GNUNET_PeerIdentity *peer,
509                            int allowed)
510 {
511   if (GNUNET_OK == allowed)
512     return;                     /* we're done */
513   GNUNET_STATISTICS_update (GST_stats,
514                             gettext_noop ("# disconnects due to blacklist"), 1,
515                             GNUNET_NO);
516   GST_neighbours_force_disconnect (peer);
517 }
518
519
520 /**
521  * Closure for 'test_connection_ok'.
522  */
523 struct TestConnectionContext
524 {
525   /**
526    * Is this the first neighbour we're checking?
527    */
528   int first;
529
530   /**
531    * Handle to the blacklisting client we need to ask.
532    */
533   struct Blacklisters *bl;
534 };
535
536
537 /**
538  * Test if an existing connection is still acceptable given a new
539  * blacklisting client.
540  *
541  * @param cls the 'struct TestConnectionContest'
542  * @param neighbour neighbour's identity
543  * @param address the address
544  * @param bandwidth_in inbound quota in NBO
545  * @param bandwidth_out outbound quota in NBO
546  */
547 static void
548 test_connection_ok (void *cls, const struct GNUNET_PeerIdentity *neighbour,
549                     const struct GNUNET_HELLO_Address *address,
550                     struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
551                     struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out)
552 {
553   struct TestConnectionContext *tcc = cls;
554   struct GST_BlacklistCheck *bc;
555
556   bc = GNUNET_malloc (sizeof (struct GST_BlacklistCheck));
557   GNUNET_CONTAINER_DLL_insert (bc_head, bc_tail, bc);
558   bc->peer = *neighbour;
559   bc->cont = &confirm_or_drop_neighbour;
560   bc->cont_cls = NULL;
561   bc->bl_pos = tcc->bl;
562   if (GNUNET_YES == tcc->first)
563   {
564     /* all would wait for the same client, no need to
565      * create more than just the first task right now */
566     bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check, bc);
567     tcc->first = GNUNET_NO;
568   }
569 }
570
571
572 /**
573  * Initialize a blacklisting client.  We got a blacklist-init
574  * message from this client, add him to the list of clients
575  * to query for blacklisting.
576  *
577  * @param cls unused
578  * @param client the client
579  * @param message the blacklist-init message that was sent
580  */
581 void
582 GST_blacklist_handle_init (void *cls, struct GNUNET_SERVER_Client *client,
583                            const struct GNUNET_MessageHeader *message)
584 {
585   struct Blacklisters *bl;
586   struct TestConnectionContext tcc;
587
588   bl = bl_head;
589   while (bl != NULL)
590   {
591     if (bl->client == client)
592     {
593       GNUNET_break (0);
594       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
595       return;
596     }
597     bl = bl->next;
598   }
599   GNUNET_SERVER_client_mark_monitor (client);
600   bl = GNUNET_malloc (sizeof (struct Blacklisters));
601   bl->client = client;
602   GNUNET_SERVER_client_keep (client);
603   GNUNET_CONTAINER_DLL_insert_after (bl_head, bl_tail, bl_tail, bl);
604
605   /* confirm that all existing connections are OK! */
606   tcc.bl = bl;
607   tcc.first = GNUNET_YES;
608   GST_neighbours_iterate (&test_connection_ok, &tcc);
609 }
610
611
612 /**
613  * A blacklisting client has sent us reply. Process it.
614  *
615  * @param cls unused
616  * @param client the client
617  * @param message the blacklist-init message that was sent
618  */
619 void
620 GST_blacklist_handle_reply (void *cls, struct GNUNET_SERVER_Client *client,
621                             const struct GNUNET_MessageHeader *message)
622 {
623   const struct BlacklistMessage *msg =
624       (const struct BlacklistMessage *) message;
625   struct Blacklisters *bl;
626   struct GST_BlacklistCheck *bc;
627
628   bl = bl_head;
629   while ((bl != NULL) && (bl->client != client))
630     bl = bl->next;
631   if (bl == NULL)
632   {
633     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Blacklist client disconnected\n");
634     /* FIXME: other error handling here!? */
635     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
636     return;
637   }
638   bc = bl->bc;
639   bl->bc = NULL;
640   bl->waiting_for_reply = GNUNET_NO;
641   if (NULL != bc)
642   {
643     /* only run this if the blacklist check has not been
644      * cancelled in the meantime... */
645     if (ntohl (msg->is_allowed) == GNUNET_SYSERR)
646     {
647       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
648                   "Blacklist check failed, peer not allowed\n");
649       bc->cont (bc->cont_cls, &bc->peer, GNUNET_NO);
650       GNUNET_CONTAINER_DLL_remove (bc_head, bc_tail, bc);
651       GNUNET_free (bc);
652     }
653     else
654     {
655       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
656                   "Blacklist check succeeded, continuing with checks\n");
657       bc->bl_pos = bc->bl_pos->next;
658       bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check, bc);
659     }
660   }
661   /* check if any other bc's are waiting for this blacklister */
662   bc = bc_head;
663   for (bc = bc_head; bc != NULL; bc = bc->next)
664     if ((bc->bl_pos == bl) && (GNUNET_SCHEDULER_NO_TASK == bc->task))
665     {
666       bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check, bc);
667       break;
668     }
669 }
670
671
672 /**
673  * Add the given peer to the blacklist (for the given transport).
674  *
675  * @param peer peer to blacklist
676  * @param transport_name transport to blacklist for this peer, NULL for all
677  */
678 void
679 GST_blacklist_add_peer (const struct GNUNET_PeerIdentity *peer,
680                         const char *transport_name)
681 {
682   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
683               "Adding peer `%s' with plugin `%s' to blacklist\n",
684               GNUNET_i2s (peer), transport_name);
685   if (blacklist == NULL)
686     blacklist =
687       GNUNET_CONTAINER_multihashmap_create (TRANSPORT_BLACKLIST_HT_SIZE,
688                                             GNUNET_NO);
689   GNUNET_CONTAINER_multihashmap_put (blacklist, &peer->hashPubKey,
690                                      GNUNET_strdup (transport_name),
691                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
692 }
693
694
695 /**
696  * Test if the given blacklist entry matches.  If so,
697  * abort the iteration.
698  *
699  * @param cls the transport name to match (const char*)
700  * @param key the key (unused)
701  * @param value the 'char *' (name of a blacklisted transport)
702  * @return GNUNET_OK if the entry does not match, GNUNET_NO if it matches
703  */
704 static int
705 test_blacklisted (void *cls, const struct GNUNET_HashCode * key, void *value)
706 {
707   const char *transport_name = cls;
708   char *be = value;
709
710   /* blacklist check for specific no specific transport*/
711   if (transport_name == NULL)
712     return GNUNET_NO;
713
714   /* blacklist check for specific transport */
715   if (0 == strcmp (transport_name, be))
716     return GNUNET_NO;           /* abort iteration! */
717   return GNUNET_OK;
718 }
719
720
721 /**
722  * Test if a peer/transport combination is blacklisted.
723  *
724  * @param peer the identity of the peer to test
725  * @param transport_name name of the transport to test, never NULL
726  * @param cont function to call with result
727  * @param cont_cls closure for 'cont'
728  * @return handle to the blacklist check, NULL if the decision
729  *        was made instantly and 'cont' was already called
730  */
731 struct GST_BlacklistCheck *
732 GST_blacklist_test_allowed (const struct GNUNET_PeerIdentity *peer,
733                             const char *transport_name,
734                             GST_BlacklistTestContinuation cont, void *cont_cls)
735 {
736   struct GST_BlacklistCheck *bc;
737
738   GNUNET_assert (peer != NULL);
739
740   if ((blacklist != NULL) &&
741       (GNUNET_SYSERR ==
742        GNUNET_CONTAINER_multihashmap_get_multiple (blacklist, &peer->hashPubKey,
743                                                    &test_blacklisted,
744                                                    (void *) transport_name)))
745   {
746     /* disallowed by config, disapprove instantly */
747     GNUNET_STATISTICS_update (GST_stats,
748                               gettext_noop ("# disconnects due to blacklist"),
749                               1, GNUNET_NO);
750     if (cont != NULL)
751       cont (cont_cls, peer, GNUNET_NO);
752     return NULL;
753   }
754
755   if (bl_head == NULL)
756   {
757     /* no blacklist clients, approve instantly */
758     if (cont != NULL)
759       cont (cont_cls, peer, GNUNET_OK);
760     return NULL;
761   }
762
763   /* need to query blacklist clients */
764   bc = GNUNET_malloc (sizeof (struct GST_BlacklistCheck));
765   GNUNET_CONTAINER_DLL_insert (bc_head, bc_tail, bc);
766   bc->peer = *peer;
767   bc->cont = cont;
768   bc->cont_cls = cont_cls;
769   bc->bl_pos = bl_head;
770   bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check, bc);
771   return bc;
772 }
773
774
775 /**
776  * Cancel a blacklist check.
777  *
778  * @param bc check to cancel
779  */
780 void
781 GST_blacklist_test_cancel (struct GST_BlacklistCheck *bc)
782 {
783   GNUNET_CONTAINER_DLL_remove (bc_head, bc_tail, bc);
784   if (bc->bl_pos != NULL)
785   {
786     if (bc->bl_pos->bc == bc)
787     {
788       /* we're at the head of the queue, remove us! */
789       bc->bl_pos->bc = NULL;
790     }
791   }
792   if (GNUNET_SCHEDULER_NO_TASK != bc->task)
793   {
794     GNUNET_SCHEDULER_cancel (bc->task);
795     bc->task = GNUNET_SCHEDULER_NO_TASK;
796   }
797   if (NULL != bc->th)
798   {
799     GNUNET_SERVER_notify_transmit_ready_cancel (bc->th);
800     bc->th = NULL;
801   }
802   GNUNET_free (bc);
803 }
804
805
806 /* end of file gnunet-service-transport_blacklist.c */