aboutsummaryrefslogtreecommitdiff
path: root/src/regex/gnunet-service-regex.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/regex/gnunet-service-regex.c')
-rw-r--r--src/regex/gnunet-service-regex.c410
1 files changed, 0 insertions, 410 deletions
diff --git a/src/regex/gnunet-service-regex.c b/src/regex/gnunet-service-regex.c
deleted file mode 100644
index 7a5cc1f05..000000000
--- a/src/regex/gnunet-service-regex.c
+++ /dev/null
@@ -1,410 +0,0 @@
1/*
2 This file is part of GNUnet.
3 Copyright (C) 2013 GNUnet e.V.
4
5 GNUnet is free software: you can redistribute it and/or modify it
6 under the terms of the GNU Affero General Public License as published
7 by the Free Software Foundation, either version 3 of the License,
8 or (at your 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 Affero General Public License for more details.
14
15 You should have received a copy of the GNU Affero General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>.
17
18 SPDX-License-Identifier: AGPL3.0-or-later
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 */
36struct ClientEntry
37{
38 /**
39 * Queue for transmissions to @e client.
40 */
41 struct GNUNET_MQ_Handle *mq;
42
43 /**
44 * Handle identifying the client.
45 */
46 struct GNUNET_SERVICE_Client *client;
47
48 /**
49 * Search handle (if this client is searching).
50 */
51 struct REGEX_INTERNAL_Search *sh;
52
53 /**
54 * Announcement handle (if this client is announcing).
55 */
56 struct REGEX_INTERNAL_Announcement *ah;
57
58 /**
59 * Refresh frequency for announcements.
60 */
61 struct GNUNET_TIME_Relative frequency;
62
63 /**
64 * Task for re-announcing.
65 */
66 struct GNUNET_SCHEDULER_Task *refresh_task;
67};
68
69
70/**
71 * Connection to the DHT.
72 */
73static struct GNUNET_DHT_Handle *dht;
74
75/**
76 * Handle for doing statistics.
77 */
78static struct GNUNET_STATISTICS_Handle *stats;
79
80/**
81 * Private key for this peer.
82 */
83static struct GNUNET_CRYPTO_EddsaPrivateKey *my_private_key;
84
85
86/**
87 * Task run during shutdown.
88 *
89 * @param cls unused
90 */
91static void
92cleanup_task (void *cls)
93{
94 GNUNET_DHT_disconnect (dht);
95 dht = NULL;
96 GNUNET_STATISTICS_destroy (stats,
97 GNUNET_NO);
98 stats = NULL;
99 GNUNET_free (my_private_key);
100 my_private_key = NULL;
101}
102
103
104/**
105 * Periodic task to refresh our announcement of the regex.
106 *
107 * @param cls the `struct ClientEntry *` of the client that triggered the
108 * announcement
109 */
110static void
111reannounce (void *cls)
112{
113 struct ClientEntry *ce = cls;
114
115 REGEX_INTERNAL_reannounce (ce->ah);
116 ce->refresh_task = GNUNET_SCHEDULER_add_delayed (ce->frequency,
117 &reannounce,
118 ce);
119}
120
121
122/**
123 * Check ANNOUNCE message.
124 *
125 * @param cls identification of the client
126 * @param am the actual message
127 * @return #GNUNET_OK if @am is well-formed
128 */
129static int
130check_announce (void *cls,
131 const struct AnnounceMessage *am)
132{
133 struct ClientEntry *ce = cls;
134
135 GNUNET_MQ_check_zero_termination (am);
136 if (NULL != ce->ah)
137 {
138 /* only one announcement per client allowed */
139 GNUNET_break (0);
140 return GNUNET_SYSERR;
141 }
142 return GNUNET_OK;
143}
144
145
146/**
147 * Handle ANNOUNCE message.
148 *
149 * @param cls identification of the client
150 * @param am the actual message
151 */
152static void
153handle_announce (void *cls,
154 const struct AnnounceMessage *am)
155{
156 struct ClientEntry *ce = cls;
157 const char *regex;
158
159 regex = (const char *) &am[1];
160 ce->frequency = GNUNET_TIME_relative_ntoh (am->refresh_delay);
161 ce->refresh_task = GNUNET_SCHEDULER_add_delayed (ce->frequency,
162 &reannounce,
163 ce);
164 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
165 "Starting to announce regex `%s' every %s\n",
166 regex,
167 GNUNET_STRINGS_relative_time_to_string (ce->frequency,
168 GNUNET_NO));
169 ce->ah = REGEX_INTERNAL_announce (dht,
170 my_private_key,
171 regex,
172 ntohs (am->compression),
173 stats);
174 if (NULL == ce->ah)
175 {
176 GNUNET_break (0);
177 GNUNET_SCHEDULER_cancel (ce->refresh_task);
178 ce->refresh_task = NULL;
179 GNUNET_SERVICE_client_drop (ce->client);
180 return;
181 }
182 GNUNET_SERVICE_client_continue (ce->client);
183}
184
185
186/**
187 * Handle result, pass it back to the client.
188 *
189 * @param cls the struct ClientEntry of the client searching
190 * @param id Peer providing a regex that matches the string.
191 * @param get_path Path of the get request.
192 * @param get_path_length Length of @a get_path.
193 * @param put_path Path of the put request.
194 * @param put_path_length Length of the @a put_path.
195 */
196static void
197handle_search_result (void *cls,
198 const struct GNUNET_PeerIdentity *id,
199 const struct GNUNET_PeerIdentity *get_path,
200 unsigned int get_path_length,
201 const struct GNUNET_PeerIdentity *put_path,
202 unsigned int put_path_length)
203{
204 struct ClientEntry *ce = cls;
205 struct GNUNET_MQ_Envelope *env;
206 struct ResultMessage *result;
207 struct GNUNET_PeerIdentity *gp;
208 uint16_t size;
209
210 if ((get_path_length >= 65536) ||
211 (put_path_length >= 65536) ||
212 ( ((get_path_length + put_path_length) * sizeof(struct
213 GNUNET_PeerIdentity))
214 + sizeof(struct ResultMessage) >= GNUNET_MAX_MESSAGE_SIZE) )
215 {
216 GNUNET_break (0);
217 return;
218 }
219 size = (get_path_length + put_path_length) * sizeof(struct
220 GNUNET_PeerIdentity);
221 env = GNUNET_MQ_msg_extra (result,
222 size,
223 GNUNET_MESSAGE_TYPE_REGEX_RESULT);
224 result->get_path_length = htons ((uint16_t) get_path_length);
225 result->put_path_length = htons ((uint16_t) put_path_length);
226 result->id = *id;
227 gp = &result->id;
228 GNUNET_memcpy (&gp[1],
229 get_path,
230 get_path_length * sizeof(struct GNUNET_PeerIdentity));
231 GNUNET_memcpy (&gp[1 + get_path_length],
232 put_path,
233 put_path_length * sizeof(struct GNUNET_PeerIdentity));
234 GNUNET_MQ_send (ce->mq,
235 env);
236}
237
238
239/**
240 * Check SEARCH message.
241 *
242 * @param cls identification of the client
243 * @param message the actual message
244 */
245static int
246check_search (void *cls,
247 const struct RegexSearchMessage *sm)
248{
249 struct ClientEntry *ce = cls;
250 const char *string;
251 uint16_t size;
252
253 size = ntohs (sm->header.size) - sizeof(*sm);
254 string = (const char *) &sm[1];
255 if ('\0' != string[size - 1])
256 {
257 GNUNET_break (0);
258 return GNUNET_SYSERR;
259 }
260 if (NULL != ce->sh)
261 {
262 /* only one search allowed per client */
263 GNUNET_break (0);
264 return GNUNET_SYSERR;
265 }
266 return GNUNET_OK;
267}
268
269
270/**
271 * Handle SEARCH message.
272 *
273 * @param cls identification of the client
274 * @param message the actual message
275 */
276static void
277handle_search (void *cls,
278 const struct RegexSearchMessage *sm)
279{
280 struct ClientEntry *ce = cls;
281 const char *string;
282
283 string = (const char *) &sm[1];
284 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
285 "Starting to search for `%s'\n",
286 string);
287 ce->sh = REGEX_INTERNAL_search (dht,
288 string,
289 &handle_search_result,
290 ce,
291 stats);
292 if (NULL == ce->sh)
293 {
294 GNUNET_break (0);
295 GNUNET_SERVICE_client_drop (ce->client);
296 return;
297 }
298 GNUNET_SERVICE_client_continue (ce->client);
299}
300
301
302/**
303 * Process regex requests.
304 *
305 * @param cls closure
306 * @param cfg configuration to use
307 * @param service the initialized service
308 */
309static void
310run (void *cls,
311 const struct GNUNET_CONFIGURATION_Handle *cfg,
312 struct GNUNET_SERVICE_Handle *service)
313{
314 my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg);
315 if (NULL == my_private_key)
316 {
317 GNUNET_SCHEDULER_shutdown ();
318 return;
319 }
320 dht = GNUNET_DHT_connect (cfg, 1024);
321 if (NULL == dht)
322 {
323 GNUNET_free (my_private_key);
324 my_private_key = NULL;
325 GNUNET_SCHEDULER_shutdown ();
326 return;
327 }
328 GNUNET_SCHEDULER_add_shutdown (&cleanup_task,
329 NULL);
330 stats = GNUNET_STATISTICS_create ("regex", cfg);
331}
332
333
334/**
335 * Callback called when a client connects to the service.
336 *
337 * @param cls closure for the service
338 * @param c the new client that connected to the service
339 * @param mq the message queue used to send messages to the client
340 * @return @a c
341 */
342static void *
343client_connect_cb (void *cls,
344 struct GNUNET_SERVICE_Client *c,
345 struct GNUNET_MQ_Handle *mq)
346{
347 struct ClientEntry *ce;
348
349 ce = GNUNET_new (struct ClientEntry);
350 ce->client = c;
351 ce->mq = mq;
352 return ce;
353}
354
355
356/**
357 * Callback called when a client disconnected from the service
358 *
359 * @param cls closure for the service
360 * @param c the client that disconnected
361 * @param internal_cls should be equal to @a c
362 */
363static void
364client_disconnect_cb (void *cls,
365 struct GNUNET_SERVICE_Client *c,
366 void *internal_cls)
367{
368 struct ClientEntry *ce = internal_cls;
369
370 if (NULL != ce->refresh_task)
371 {
372 GNUNET_SCHEDULER_cancel (ce->refresh_task);
373 ce->refresh_task = NULL;
374 }
375 if (NULL != ce->ah)
376 {
377 REGEX_INTERNAL_announce_cancel (ce->ah);
378 ce->ah = NULL;
379 }
380 if (NULL != ce->sh)
381 {
382 REGEX_INTERNAL_search_cancel (ce->sh);
383 ce->sh = NULL;
384 }
385 GNUNET_free (ce);
386}
387
388
389/**
390 * Define "main" method using service macro.
391 */
392GNUNET_SERVICE_MAIN
393 ("regex",
394 GNUNET_SERVICE_OPTION_NONE,
395 &run,
396 &client_connect_cb,
397 &client_disconnect_cb,
398 NULL,
399 GNUNET_MQ_hd_var_size (announce,
400 GNUNET_MESSAGE_TYPE_REGEX_ANNOUNCE,
401 struct AnnounceMessage,
402 NULL),
403 GNUNET_MQ_hd_var_size (search,
404 GNUNET_MESSAGE_TYPE_REGEX_SEARCH,
405 struct RegexSearchMessage,
406 NULL),
407 GNUNET_MQ_handler_end ());
408
409
410/* end of gnunet-service-regex.c */
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-19 12:30:09 +0000