missing fi
[oweals/gnunet.git] / src / regex / gnunet-service-regex.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 regex/gnunet-service-regex.c
23  * @brief service to advertise capabilities described as regex and to
24  *        lookup capabilities by regex
25  * @author Christian Grothoff
26  */
27 #include "platform.h"
28 #include "gnunet_util_lib.h"
29 #include "regex_internal_lib.h"
30 #include "regex_ipc.h"
31
32
33 /**
34  * Information about one of our clients.
35  */
36 struct ClientEntry
37 {
38
39   /**
40    * Kept in DLL.
41    */
42   struct ClientEntry *next;
43
44   /**
45    * Kept in DLL.
46    */
47   struct ClientEntry *prev;
48
49   /**
50    * Handle identifying the client.
51    */
52   struct GNUNET_SERVER_Client *client;
53
54   /**
55    * Search handle (if this client is searching).
56    */
57   struct REGEX_INTERNAL_Search *sh;
58
59   /**
60    * Announcement handle (if this client is announcing).
61    */
62   struct REGEX_INTERNAL_Announcement *ah;
63
64   /**
65    * Refresh frequency for announcements.
66    */
67   struct GNUNET_TIME_Relative frequency;
68
69   /**
70    * Task for re-announcing.
71    */
72   GNUNET_SCHEDULER_TaskIdentifier refresh_task;
73
74 };
75
76
77 /**
78  * Connection to the DHT.
79  */
80 static struct GNUNET_DHT_Handle *dht;
81
82 /**
83  * Handle for doing statistics.
84  */
85 static struct GNUNET_STATISTICS_Handle *stats;
86
87 /**
88  * Head of list of clients.
89  */
90 static struct ClientEntry *client_head;
91
92 /**
93  * End of list of clients.
94  */
95 static struct ClientEntry *client_tail;
96
97 /**
98  * Our notification context, used to send back results to the client.
99  */
100 static struct GNUNET_SERVER_NotificationContext *nc;
101
102 /**
103  * Private key for this peer.
104  */
105 static struct GNUNET_CRYPTO_EddsaPrivateKey *my_private_key;
106
107
108 /**
109  * Task run during shutdown.
110  *
111  * @param cls unused
112  * @param tc unused
113  */
114 static void
115 cleanup_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
116 {
117   GNUNET_DHT_disconnect (dht);
118   dht = NULL;
119   GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
120   stats = NULL;
121   GNUNET_SERVER_notification_context_destroy (nc);
122   nc = NULL;
123   GNUNET_free (my_private_key);
124   my_private_key = NULL;
125 }
126
127
128 /**
129  * A client disconnected.  Remove all of its data structure entries.
130  *
131  * @param cls closure, NULL
132  * @param client identification of the client
133  */
134 static void
135 handle_client_disconnect (void *cls, struct GNUNET_SERVER_Client *client)
136 {
137   struct ClientEntry *ce;
138   struct ClientEntry *nx;
139
140   nx = client_head;
141   for (ce = nx; NULL != ce; ce = nx)
142   {
143     nx = ce->next;
144     if (ce->client == client)
145     {
146       if (GNUNET_SCHEDULER_NO_TASK != ce->refresh_task)
147       {
148         GNUNET_SCHEDULER_cancel (ce->refresh_task);
149         ce->refresh_task = GNUNET_SCHEDULER_NO_TASK;
150       }
151       if (NULL != ce->ah)
152       {
153         REGEX_INTERNAL_announce_cancel (ce->ah);
154         ce->ah = NULL;
155       }
156       if (NULL != ce->sh)
157       {
158         REGEX_INTERNAL_search_cancel (ce->sh);
159         ce->sh = NULL;
160       }
161       GNUNET_CONTAINER_DLL_remove (client_head, client_tail, ce);
162       GNUNET_free (ce);
163     }
164   }
165 }
166
167
168 /**
169  * Periodic task to refresh our announcement of the regex.
170  *
171  * @param cls the 'struct ClientEntry' of the client that triggered the
172  *        announcement
173  * @param tc scheduler context
174  */
175 static void
176 reannounce (void *cls,
177             const struct GNUNET_SCHEDULER_TaskContext *tc)
178 {
179   struct ClientEntry *ce = cls;
180
181   REGEX_INTERNAL_reannounce (ce->ah);
182   ce->refresh_task = GNUNET_SCHEDULER_add_delayed (ce->frequency,
183                                                    &reannounce,
184                                                    ce);
185 }
186
187
188 /**
189  * Handle ANNOUNCE message.
190  *
191  * @param cls closure
192  * @param client identification of the client
193  * @param message the actual message
194  */
195 static void
196 handle_announce (void *cls,
197                  struct GNUNET_SERVER_Client *client,
198                  const struct GNUNET_MessageHeader *message)
199 {
200   const struct AnnounceMessage *am;
201   const char *regex;
202   struct ClientEntry *ce;
203   uint16_t size;
204
205   size = ntohs (message->size);
206   am = (const struct AnnounceMessage *) message;
207   regex = (const char *) &am[1];
208   if ( (size <= sizeof (struct AnnounceMessage)) ||
209        ('\0' != regex[size - sizeof (struct AnnounceMessage) - 1]) )
210   {
211     GNUNET_break (0);
212     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
213     return;
214   }
215
216   ce = GNUNET_new (struct ClientEntry);
217   ce->client = client;
218   ce->frequency = GNUNET_TIME_relative_ntoh (am->refresh_delay);
219   ce->refresh_task = GNUNET_SCHEDULER_add_delayed (ce->frequency,
220                                                    &reannounce,
221                                                    ce);
222   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
223               "Starting to announce regex `%s' every %s\n",
224               regex,
225               GNUNET_STRINGS_relative_time_to_string (ce->frequency,
226                                                       GNUNET_NO));
227   ce->ah = REGEX_INTERNAL_announce (dht,
228                                     my_private_key,
229                                     regex,
230                                     ntohs (am->compression),
231                                     stats);
232   if (NULL == ce->ah)
233   {
234     GNUNET_break (0);
235     GNUNET_SCHEDULER_cancel (ce->refresh_task);
236     GNUNET_free (ce);
237     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
238     return;
239   }
240   GNUNET_CONTAINER_DLL_insert (client_head,
241                                client_tail,
242                                ce);
243   GNUNET_SERVER_receive_done (client, GNUNET_OK);
244 }
245
246
247 /**
248  * Handle result, pass it back to the client.
249  *
250  * @param cls the struct ClientEntry of the client searching
251  * @param id Peer providing a regex that matches the string.
252  * @param get_path Path of the get request.
253  * @param get_path_length Lenght of get_path.
254  * @param put_path Path of the put request.
255  * @param put_path_length Length of the put_path.
256  */
257 static void
258 handle_search_result (void *cls,
259                       const struct GNUNET_PeerIdentity *id,
260                       const struct GNUNET_PeerIdentity *get_path,
261                       unsigned int get_path_length,
262                       const struct GNUNET_PeerIdentity *put_path,
263                       unsigned int put_path_length)
264 {
265   struct ClientEntry *ce = cls;
266   struct ResultMessage *result;
267   struct GNUNET_PeerIdentity *gp;
268   uint16_t size;
269
270   if ( (get_path_length >= 65536) ||
271        (put_path_length >= 65536) ||
272        ( (get_path_length + put_path_length) * sizeof (struct GNUNET_PeerIdentity))
273        + sizeof (struct ResultMessage) >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
274   {
275     GNUNET_break (0);
276     return;
277   }
278   size = (get_path_length + put_path_length) * sizeof (struct GNUNET_PeerIdentity) + sizeof (struct ResultMessage);
279   result = GNUNET_malloc (size);
280   result->header.size = htons (size);
281   result->header.type = htons (GNUNET_MESSAGE_TYPE_REGEX_RESULT);
282   result->get_path_length = htons ((uint16_t) get_path_length);
283   result->put_path_length = htons ((uint16_t) put_path_length);
284   result->id = *id;
285   gp = &result->id;
286   memcpy (&gp[1],
287           get_path,
288           get_path_length * sizeof (struct GNUNET_PeerIdentity));
289   memcpy (&gp[1 + get_path_length],
290           put_path,
291           put_path_length * sizeof (struct GNUNET_PeerIdentity));
292   GNUNET_SERVER_notification_context_unicast (nc,
293                                               ce->client,
294                                               &result->header, GNUNET_NO);
295   GNUNET_free (result);
296 }
297
298
299 /**
300  * Handle SEARCH message.
301  *
302  * @param cls closure
303  * @param client identification of the client
304  * @param message the actual message
305  */
306 static void
307 handle_search (void *cls,
308                struct GNUNET_SERVER_Client *client,
309                const struct GNUNET_MessageHeader *message)
310 {
311   const struct SearchMessage *sm;
312   const char *string;
313   struct ClientEntry *ce;
314   uint16_t size;
315
316   size = ntohs (message->size);
317   sm = (const struct SearchMessage *) message;
318   string = (const char *) &sm[1];
319   if ( (size <= sizeof (struct SearchMessage)) ||
320        ('\0' != string[size - sizeof (struct SearchMessage) - 1]) )
321   {
322     GNUNET_break (0);
323     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
324     return;
325   }
326   ce = GNUNET_new (struct ClientEntry);
327   ce->client = client;
328   ce->sh = REGEX_INTERNAL_search (dht,
329                                 string,
330                                 &handle_search_result,
331                                 ce,
332                                 stats);
333   if (NULL == ce->sh)
334   {
335     GNUNET_break (0);
336     GNUNET_free (ce);
337     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
338     return;
339   }
340   GNUNET_CONTAINER_DLL_insert (client_head,
341                                client_tail,
342                                ce);
343   GNUNET_SERVER_notification_context_add (nc, client);
344   GNUNET_SERVER_receive_done (client, GNUNET_OK);
345 }
346
347
348 /**
349  * Process regex requests.
350  *
351  * @param cls closure
352  * @param server the initialized server
353  * @param cfg configuration to use
354  */
355 static void
356 run (void *cls, struct GNUNET_SERVER_Handle *server,
357      const struct GNUNET_CONFIGURATION_Handle *cfg)
358 {
359   static const struct GNUNET_SERVER_MessageHandler handlers[] = {
360     {&handle_announce, NULL, GNUNET_MESSAGE_TYPE_REGEX_ANNOUNCE, 0},
361     {&handle_search, NULL, GNUNET_MESSAGE_TYPE_REGEX_SEARCH, 0},
362     {NULL, NULL, 0, 0}
363   };
364
365   my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg);
366   if (NULL == my_private_key)
367   {
368     GNUNET_SCHEDULER_shutdown ();
369     return;
370   }
371   dht = GNUNET_DHT_connect (cfg, 1024);
372   if (NULL == dht)
373   {
374     GNUNET_free (my_private_key);
375     my_private_key = NULL;
376     GNUNET_SCHEDULER_shutdown ();
377     return;
378   }
379   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &cleanup_task,
380                                 NULL);
381   nc = GNUNET_SERVER_notification_context_create (server, 1);
382   stats = GNUNET_STATISTICS_create ("regex", cfg);
383   GNUNET_SERVER_add_handlers (server, handlers);
384   GNUNET_SERVER_disconnect_notify (server, &handle_client_disconnect, NULL);
385 }
386
387
388 /**
389  * The main function for the regex service.
390  *
391  * @param argc number of arguments from the command line
392  * @param argv command line arguments
393  * @return 0 ok, 1 on error
394  */
395 int
396 main (int argc, char *const *argv)
397 {
398   return (GNUNET_OK ==
399           GNUNET_SERVICE_run (argc, argv, "regex",
400                               GNUNET_SERVICE_OPTION_NONE, &run, NULL)) ? 0 : 1;
401 }
402
403 /* end of gnunet-service-regex.c */