aboutsummaryrefslogtreecommitdiff
path: root/src/dhtu/plugin_dhtu_ip.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/dhtu/plugin_dhtu_ip.c')
-rw-r--r--src/dhtu/plugin_dhtu_ip.c1172
1 files changed, 0 insertions, 1172 deletions
diff --git a/src/dhtu/plugin_dhtu_ip.c b/src/dhtu/plugin_dhtu_ip.c
deleted file mode 100644
index 612d2c119..000000000
--- a/src/dhtu/plugin_dhtu_ip.c
+++ /dev/null
@@ -1,1172 +0,0 @@
1/*
2 This file is part of GNUnet
3 Copyright (C) 2021, 2022 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 * @author Christian Grothoff
23 *
24 * @file plugin_dhtu_ip.c
25 * @brief plain IP based DHT network underlay
26 */
27#include "platform.h"
28#include "gnunet_dhtu_plugin.h"
29
30/**
31 * How frequently should we re-scan our local interfaces for IPs?
32 */
33#define SCAN_FREQ GNUNET_TIME_UNIT_MINUTES
34
35/**
36 * Maximum number of concurrently active destinations to support.
37 */
38#define MAX_DESTS 256
39
40
41/**
42 * Opaque handle that the underlay offers for our address to be used when
43 * sending messages to another peer.
44 */
45struct GNUNET_DHTU_Source
46{
47
48 /**
49 * Kept in a DLL.
50 */
51 struct GNUNET_DHTU_Source *next;
52
53 /**
54 * Kept in a DLL.
55 */
56 struct GNUNET_DHTU_Source *prev;
57
58 /**
59 * Application context for this source.
60 */
61 void *app_ctx;
62
63 /**
64 * Address in URL form ("ip+udp://$PID/$IP:$PORT")
65 */
66 char *address;
67
68 /**
69 * My actual address.
70 */
71 struct sockaddr_storage addr;
72
73 /**
74 * Number of bytes in @a addr.
75 */
76 socklen_t addrlen;
77
78 /**
79 * Last generation this address was observed.
80 */
81 unsigned int scan_generation;
82
83};
84
85
86/**
87 * Opaque handle that the underlay offers for the target peer when sending
88 * messages to another peer.
89 */
90struct GNUNET_DHTU_Target
91{
92
93 /**
94 * Kept in a DLL.
95 */
96 struct GNUNET_DHTU_Target *next;
97
98 /**
99 * Kept in a DLL.
100 */
101 struct GNUNET_DHTU_Target *prev;
102
103 /**
104 * Application context for this target.
105 */
106 void *app_ctx;
107
108 /**
109 * Head of preferences expressed for this target.
110 */
111 struct GNUNET_DHTU_PreferenceHandle *ph_head;
112
113 /**
114 * Tail of preferences expressed for this target.
115 */
116 struct GNUNET_DHTU_PreferenceHandle *ph_tail;
117
118 /**
119 * Peer's identity.
120 */
121 struct GNUNET_PeerIdentity pid;
122
123 /**
124 * Target IP address.
125 */
126 struct sockaddr_storage addr;
127
128 /**
129 * Number of bytes in @a addr.
130 */
131 socklen_t addrlen;
132
133 /**
134 * Preference counter, length of the @a ph_head DLL.
135 */
136 unsigned int ph_count;
137
138};
139
140/**
141 * Opaque handle expressing a preference of the DHT to
142 * keep a particular target connected.
143 */
144struct GNUNET_DHTU_PreferenceHandle
145{
146 /**
147 * Kept in a DLL.
148 */
149 struct GNUNET_DHTU_PreferenceHandle *next;
150
151 /**
152 * Kept in a DLL.
153 */
154 struct GNUNET_DHTU_PreferenceHandle *prev;
155
156 /**
157 * Target a preference was expressed for.
158 */
159 struct GNUNET_DHTU_Target *target;
160};
161
162
163/**
164 * Closure for all plugin functions.
165 */
166struct Plugin
167{
168 /**
169 * Callbacks into the DHT.
170 */
171 struct GNUNET_DHTU_PluginEnvironment *env;
172
173 /**
174 * Head of sources where we receive traffic.
175 */
176 struct GNUNET_DHTU_Source *src_head;
177
178 /**
179 * Tail of sources where we receive traffic.
180 */
181 struct GNUNET_DHTU_Source *src_tail;
182
183 /**
184 * Head of destinations that are active. Sorted by
185 * last use, with latest used at the head.
186 */
187 struct GNUNET_DHTU_Target *dst_head;
188
189 /**
190 * Tail of destinations that are active.
191 */
192 struct GNUNET_DHTU_Target *dst_tail;
193
194 /**
195 * Map from hashes of sockaddrs to targets.
196 */
197 struct GNUNET_CONTAINER_MultiHashMap *dsts;
198
199 /**
200 * Task that scans for IP address changes.
201 */
202 struct GNUNET_SCHEDULER_Task *scan_task;
203
204 /**
205 * Task that reads incoming UDP packets.
206 */
207 struct GNUNET_SCHEDULER_Task *read_task;
208
209 /**
210 * Port we bind to.
211 */
212 char *port;
213
214 /**
215 * My UDP socket.
216 */
217 struct GNUNET_NETWORK_Handle *sock;
218
219 /**
220 * My identity.
221 */
222 struct GNUNET_PeerIdentity my_id;
223
224 /**
225 * How often have we scanned for IPs?
226 */
227 unsigned int scan_generation;
228
229 /**
230 * Port as a 16-bit value.
231 */
232 uint16_t port16;
233};
234
235
236/**
237 * Create a target to which we may send traffic.
238 *
239 * @param plugin our plugin
240 * @param pid presumed identity of the target
241 * @param addr target address
242 * @param addrlen number of bytes in @a addr
243 * @return new target object
244 */
245static struct GNUNET_DHTU_Target *
246create_target (struct Plugin *plugin,
247 const struct GNUNET_PeerIdentity *pid,
248 const struct sockaddr *addr,
249 socklen_t addrlen)
250{
251 struct GNUNET_DHTU_Target *dst;
252
253 if (MAX_DESTS <=
254 GNUNET_CONTAINER_multihashmap_size (plugin->dsts))
255 {
256 struct GNUNET_HashCode key;
257
258 dst = NULL;
259 for (struct GNUNET_DHTU_Target *pos = plugin->dst_head;
260 NULL != pos;
261 pos = pos->next)
262 {
263 /* >= here assures we remove oldest entries first */
264 if ( (NULL == dst) ||
265 (dst->ph_count >= pos->ph_count) )
266 dst = pos;
267 }
268 GNUNET_assert (NULL != dst);
269 plugin->env->disconnect_cb (dst->app_ctx);
270 GNUNET_CRYPTO_hash (&dst->addr,
271 dst->addrlen,
272 &key);
273 GNUNET_assert (GNUNET_YES ==
274 GNUNET_CONTAINER_multihashmap_remove (plugin->dsts,
275 &key,
276 dst));
277 GNUNET_CONTAINER_DLL_remove (plugin->dst_head,
278 plugin->dst_tail,
279 dst);
280 GNUNET_assert (NULL == dst->ph_head);
281 GNUNET_free (dst);
282 }
283 dst = GNUNET_new (struct GNUNET_DHTU_Target);
284 dst->addrlen = addrlen;
285 dst->pid = *pid;
286 memcpy (&dst->addr,
287 addr,
288 addrlen);
289 GNUNET_CONTAINER_DLL_insert (plugin->dst_head,
290 plugin->dst_tail,
291 dst);
292 plugin->env->connect_cb (plugin->env->cls,
293 dst,
294 &dst->pid,
295 &dst->app_ctx);
296 return dst;
297}
298
299
300/**
301 * Find target matching @a addr. If none exists,
302 * create one!
303 *
304 * @param plugin the plugin handle
305 * @param pid presumed identity of the target
306 * @param src source target is from, or NULL if unknown
307 * @param addr socket address to find
308 * @param addrlen number of bytes in @a addr
309 * @return matching target object
310 */
311static struct GNUNET_DHTU_Target *
312find_target (struct Plugin *plugin,
313 const struct GNUNET_PeerIdentity *pid,
314 const void *addr,
315 size_t addrlen)
316{
317 struct GNUNET_HashCode key;
318 struct GNUNET_DHTU_Target *dst;
319
320 GNUNET_CRYPTO_hash (addr,
321 addrlen,
322 &key);
323 dst = GNUNET_CONTAINER_multihashmap_get (plugin->dsts,
324 &key);
325 if (NULL == dst)
326 {
327 dst = create_target (plugin,
328 pid,
329 (const struct sockaddr *) addr,
330 addrlen);
331 GNUNET_assert (GNUNET_YES ==
332 GNUNET_CONTAINER_multihashmap_put (
333 plugin->dsts,
334 &key,
335 dst,
336 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
337 }
338 else
339 {
340 /* move to head of DLL */
341 GNUNET_CONTAINER_DLL_remove (plugin->dst_head,
342 plugin->dst_tail,
343 dst);
344 GNUNET_CONTAINER_DLL_insert (plugin->dst_head,
345 plugin->dst_tail,
346 dst);
347
348 }
349 return dst;
350}
351
352
353/**
354 * Request creation of a session with a peer at the given @a address.
355 *
356 * @param cls closure (internal context for the plugin)
357 * @param pid identity of the target peer
358 * @param address target address to connect to
359 */
360static void
361ip_try_connect (void *cls,
362 const struct GNUNET_PeerIdentity *pid,
363 const char *address)
364{
365 struct Plugin *plugin = cls;
366 char *colon;
367 const char *port;
368 char *addr;
369 struct addrinfo hints = {
370 .ai_flags = AI_NUMERICHOST | AI_NUMERICSERV
371 };
372 struct addrinfo *result = NULL;
373
374 if (0 !=
375 strncmp (address,
376 "ip+",
377 strlen ("ip+")))
378 return;
379 address += strlen ("ip+");
380 if (0 !=
381 strncmp (address,
382 "udp://",
383 strlen ("udp://")))
384 return;
385 address += strlen ("udp://");
386 addr = GNUNET_strdup (address);
387 colon = strchr (addr, ':');
388 if (NULL == colon)
389 {
390 port = plugin->port;
391 }
392 else
393 {
394 *colon = '\0';
395 port = colon + 1;
396 }
397 if (0 !=
398 getaddrinfo (addr,
399 port,
400 &hints,
401 &result))
402 {
403 GNUNET_break (0);
404 GNUNET_free (addr);
405 return;
406 }
407 GNUNET_free (addr);
408 (void) find_target (plugin,
409 pid,
410 result->ai_addr,
411 result->ai_addrlen);
412 freeaddrinfo (result);
413}
414
415
416/**
417 * Request underlay to keep the connection to @a target alive if possible.
418 * Hold may be called multiple times to express a strong preference to
419 * keep a connection, say because a @a target is in multiple tables.
420 *
421 * @param cls closure
422 * @param target connection to keep alive
423 */
424static struct GNUNET_DHTU_PreferenceHandle *
425ip_hold (void *cls,
426 struct GNUNET_DHTU_Target *target)
427{
428 struct GNUNET_DHTU_PreferenceHandle *ph;
429
430 ph = GNUNET_new (struct GNUNET_DHTU_PreferenceHandle);
431 ph->target = target;
432 GNUNET_CONTAINER_DLL_insert (target->ph_head,
433 target->ph_tail,
434 ph);
435 target->ph_count++;
436 return ph;
437}
438
439
440/**
441 * Do no long request underlay to keep the connection alive.
442 *
443 * @param cls closure
444 * @param target connection to keep alive
445 */
446static void
447ip_drop (struct GNUNET_DHTU_PreferenceHandle *ph)
448{
449 struct GNUNET_DHTU_Target *target = ph->target;
450
451 GNUNET_CONTAINER_DLL_remove (target->ph_head,
452 target->ph_tail,
453 ph);
454 target->ph_count--;
455 GNUNET_free (ph);
456}
457
458
459/**
460 * Send message to some other participant over the network. Note that
461 * sending is not guaranteeing that the other peer actually received the
462 * message. For any given @a target, the DHT must wait for the @a
463 * finished_cb to be called before calling send() again.
464 *
465 * @param cls closure (internal context for the plugin)
466 * @param target receiver identification
467 * @param msg message
468 * @param msg_size number of bytes in @a msg
469 * @param finished_cb function called once transmission is done
470 * (not called if @a target disconnects, then only the
471 * disconnect_cb is called).
472 * @param finished_cb_cls closure for @a finished_cb
473 */
474static void
475ip_send (void *cls,
476 struct GNUNET_DHTU_Target *target,
477 const void *msg,
478 size_t msg_size,
479 GNUNET_SCHEDULER_TaskCallback finished_cb,
480 void *finished_cb_cls)
481{
482 struct Plugin *plugin = cls;
483 char buf[sizeof (plugin->my_id) + msg_size];
484
485 memcpy (buf,
486 &plugin->my_id,
487 sizeof (plugin->my_id));
488 memcpy (&buf[sizeof (plugin->my_id)],
489 msg,
490 msg_size);
491 GNUNET_NETWORK_socket_sendto (plugin->sock,
492 buf,
493 sizeof (buf),
494 (const struct sockaddr *) &target->addr,
495 target->addrlen);
496 finished_cb (finished_cb_cls);
497}
498
499
500/**
501 * Create a new source on which we may be receiving traffic.
502 *
503 * @param plugin our plugin
504 * @param addr our address
505 * @param addrlen number of bytes in @a addr
506 * @return new source object
507 */
508static struct GNUNET_DHTU_Source *
509create_source (struct Plugin *plugin,
510 const struct sockaddr *addr,
511 socklen_t addrlen)
512{
513 struct GNUNET_DHTU_Source *src;
514
515 src = GNUNET_new (struct GNUNET_DHTU_Source);
516 src->addrlen = addrlen;
517 memcpy (&src->addr,
518 addr,
519 addrlen);
520 src->scan_generation = plugin->scan_generation;
521 switch (addr->sa_family)
522 {
523 case AF_INET:
524 {
525 const struct sockaddr_in *s4 = (const struct sockaddr_in *) addr;
526 char buf[INET_ADDRSTRLEN];
527
528 GNUNET_assert (sizeof (struct sockaddr_in) == addrlen);
529 GNUNET_asprintf (&src->address,
530 "ip+udp://%s:%u",
531 inet_ntop (AF_INET,
532 &s4->sin_addr,
533 buf,
534 sizeof (buf)),
535 ntohs (s4->sin_port));
536 }
537 break;
538 case AF_INET6:
539 {
540 const struct sockaddr_in6 *s6 = (const struct sockaddr_in6 *) addr;
541 char buf[INET6_ADDRSTRLEN];
542
543 GNUNET_assert (sizeof (struct sockaddr_in6) == addrlen);
544 GNUNET_asprintf (&src->address,
545 "ip+udp://[%s]:%u",
546 inet_ntop (AF_INET6,
547 &s6->sin6_addr,
548 buf,
549 sizeof (buf)),
550 ntohs (s6->sin6_port));
551 }
552 break;
553 default:
554 GNUNET_break (0);
555 GNUNET_free (src);
556 return NULL;
557 }
558 GNUNET_CONTAINER_DLL_insert (plugin->src_head,
559 plugin->src_tail,
560 src);
561 plugin->env->address_add_cb (plugin->env->cls,
562 src->address,
563 src,
564 &src->app_ctx);
565 return src;
566}
567
568
569/**
570 * Compare two addresses excluding the ports for equality. Only compares IP
571 * address. Must only be called on AF_INET or AF_INET6 addresses.
572 *
573 * @param a1 address to compare
574 * @param a2 address to compare
575 * @param alen number of bytes in @a a1 and @a a2
576 * @return 0 if @a a1 == @a a2.
577 */
578static int
579addrcmp_np (const struct sockaddr *a1,
580 const struct sockaddr *a2,
581 size_t alen)
582{
583 GNUNET_assert (a1->sa_family == a2->sa_family);
584 switch (a1->sa_family)
585 {
586 case AF_INET:
587 GNUNET_assert (sizeof (struct sockaddr_in) == alen);
588 {
589 const struct sockaddr_in *s1 = (const struct sockaddr_in *) a1;
590 const struct sockaddr_in *s2 = (const struct sockaddr_in *) a2;
591
592 if (s1->sin_addr.s_addr != s2->sin_addr.s_addr)
593 return 1;
594 break;
595 }
596 case AF_INET6:
597 GNUNET_assert (sizeof (struct sockaddr_in6) == alen);
598 {
599 const struct sockaddr_in6 *s1 = (const struct sockaddr_in6 *) a1;
600 const struct sockaddr_in6 *s2 = (const struct sockaddr_in6 *) a2;
601
602 if (0 != GNUNET_memcmp (&s1->sin6_addr,
603 &s2->sin6_addr))
604 return 1;
605 break;
606 }
607 default:
608 GNUNET_assert (0);
609 }
610 return 0;
611}
612
613
614/**
615 * Compare two addresses for equality. Only
616 * compares IP address and port. Must only be
617 * called on AF_INET or AF_INET6 addresses.
618 *
619 * @param a1 address to compare
620 * @param a2 address to compare
621 * @param alen number of bytes in @a a1 and @a a2
622 * @return 0 if @a a1 == @a a2.
623 */
624static int
625addrcmp (const struct sockaddr *a1,
626 const struct sockaddr *a2,
627 size_t alen)
628{
629 GNUNET_assert (a1->sa_family == a2->sa_family);
630 switch (a1->sa_family)
631 {
632 case AF_INET:
633 GNUNET_assert (sizeof (struct sockaddr_in) == alen);
634 {
635 const struct sockaddr_in *s1 = (const struct sockaddr_in *) a1;
636 const struct sockaddr_in *s2 = (const struct sockaddr_in *) a2;
637
638 if (s1->sin_port != s2->sin_port)
639 return 1;
640 if (s1->sin_addr.s_addr != s2->sin_addr.s_addr)
641 return 1;
642 break;
643 }
644 case AF_INET6:
645 GNUNET_assert (sizeof (struct sockaddr_in6) == alen);
646 {
647 const struct sockaddr_in6 *s1 = (const struct sockaddr_in6 *) a1;
648 const struct sockaddr_in6 *s2 = (const struct sockaddr_in6 *) a2;
649
650 if (s1->sin6_port != s2->sin6_port)
651 return 1;
652 if (0 != GNUNET_memcmp (&s1->sin6_addr,
653 &s2->sin6_addr))
654 return 1;
655 break;
656 }
657 default:
658 GNUNET_assert (0);
659 }
660 return 0;
661}
662
663
664/**
665 * Callback function invoked for each interface found.
666 *
667 * @param cls closure
668 * @param name name of the interface (can be NULL for unknown)
669 * @param isDefault is this presumably the default interface
670 * @param addr address of this interface (can be NULL for unknown or unassigned)
671 * @param broadcast_addr the broadcast address (can be NULL for unknown or unassigned)
672 * @param netmask the network mask (can be NULL for unknown or unassigned)
673 * @param addrlen length of the address
674 * @return #GNUNET_OK to continue iteration, #GNUNET_SYSERR to abort
675 */
676static enum GNUNET_GenericReturnValue
677process_ifcs (void *cls,
678 const char *name,
679 int isDefault,
680 const struct sockaddr *addr,
681 const struct sockaddr *broadcast_addr,
682 const struct sockaddr *netmask,
683 socklen_t addrlen)
684{
685 struct Plugin *plugin = cls;
686 struct GNUNET_DHTU_Source *src;
687
688 for (src = plugin->src_head;
689 NULL != src;
690 src = src->next)
691 {
692 if ( (addrlen == src->addrlen) &&
693 (0 == addrcmp_np (addr,
694 (const struct sockaddr *) &src->addr,
695 addrlen)) )
696 {
697 src->scan_generation = plugin->scan_generation;
698 return GNUNET_OK;
699 }
700 }
701 switch (addr->sa_family)
702 {
703 case AF_INET:
704 {
705 struct sockaddr_in v4;
706
707 GNUNET_assert (sizeof(v4) == addrlen);
708 memcpy (&v4,
709 addr,
710 addrlen);
711 v4.sin_port = htons (plugin->port16);
712 (void) create_source (plugin,
713 (const struct sockaddr *) &v4,
714 sizeof (v4));
715 break;
716 }
717 case AF_INET6:
718 {
719 struct sockaddr_in6 v6;
720
721 GNUNET_assert (sizeof(v6) == addrlen);
722 memcpy (&v6,
723 addr,
724 addrlen);
725 v6.sin6_port = htons (plugin->port16);
726 (void) create_source (plugin,
727 (const struct sockaddr *) &v6,
728 sizeof (v6));
729 break;
730 }
731 }
732 return GNUNET_OK;
733}
734
735
736/**
737 * Scan network interfaces for IP address changes.
738 *
739 * @param cls a `struct Plugin`
740 */
741static void
742scan (void *cls)
743{
744 struct Plugin *plugin = cls;
745 struct GNUNET_DHTU_Source *next;
746
747 plugin->scan_generation++;
748 GNUNET_OS_network_interfaces_list (&process_ifcs,
749 plugin);
750 for (struct GNUNET_DHTU_Source *src = plugin->src_head;
751 NULL != src;
752 src = next)
753 {
754 next = src->next;
755 if (src->scan_generation >= plugin->scan_generation)
756 continue;
757 GNUNET_CONTAINER_DLL_remove (plugin->src_head,
758 plugin->src_tail,
759 src);
760 plugin->env->address_del_cb (src->app_ctx);
761 GNUNET_free (src->address);
762 GNUNET_free (src);
763 }
764 plugin->scan_task = GNUNET_SCHEDULER_add_delayed (SCAN_FREQ,
765 &scan,
766 plugin);
767}
768
769
770/**
771 * Find our source matching @a addr. If none exists,
772 * create one!
773 *
774 * @param plugin the plugin handle
775 * @param addr socket address to find
776 * @param addrlen number of bytes in @a addr
777 * @return matching source object
778 */
779static struct GNUNET_DHTU_Source *
780find_source (struct Plugin *plugin,
781 const void *addr,
782 size_t addrlen)
783{
784 for (struct GNUNET_DHTU_Source *src = plugin->src_head;
785 NULL != src;
786 src = src->next)
787 {
788 if ( (addrlen == src->addrlen) &&
789 (0 == addrcmp (addr,
790 (const struct sockaddr *) &src->addr,
791 addrlen)) )
792 return src;
793 }
794
795 return create_source (plugin,
796 (const struct sockaddr *) addr,
797 addrlen);
798}
799
800
801/**
802 * UDP socket is ready to receive. Read.
803 *
804 * @param cls our `struct Plugin *`
805 */
806static void
807read_cb (void *cls)
808{
809 struct Plugin *plugin = cls;
810 ssize_t ret;
811 const struct GNUNET_PeerIdentity *pid;
812 char buf[65536] GNUNET_ALIGN;
813 struct sockaddr_storage sa;
814 struct iovec iov = {
815 .iov_base = buf,
816 .iov_len = sizeof (buf)
817 };
818 char ctl[128];
819 struct msghdr mh = {
820 .msg_name = &sa,
821 .msg_namelen = sizeof (sa),
822 .msg_iov = &iov,
823 .msg_iovlen = 1,
824 .msg_control = ctl,
825 .msg_controllen = sizeof (ctl)
826 };
827 struct GNUNET_DHTU_Target *dst = NULL;
828 struct GNUNET_DHTU_Source *src = NULL;
829
830 ret = recvmsg (GNUNET_NETWORK_get_fd (plugin->sock),
831 &mh,
832 MSG_DONTWAIT);
833 plugin->read_task = GNUNET_SCHEDULER_add_read_net (
834 GNUNET_TIME_UNIT_FOREVER_REL,
835 plugin->sock,
836 &read_cb,
837 plugin);
838 if (ret < 0)
839 return; /* read failure, hopefully EAGAIN */
840 if (ret < sizeof (*pid))
841 {
842 GNUNET_break_op (0);
843 return;
844 }
845 /* find IP where we received message */
846 for (struct cmsghdr *cmsg = CMSG_FIRSTHDR (&mh);
847 NULL != cmsg;
848 cmsg = CMSG_NXTHDR (&mh,
849 cmsg))
850 {
851 GNUNET_log (GNUNET_ERROR_TYPE_INFO,
852 "Got CMSG level %u (%d/%d), type %u (%d/%d)\n",
853 cmsg->cmsg_level,
854 (cmsg->cmsg_level == IPPROTO_IP),
855 (cmsg->cmsg_level == IPPROTO_IPV6),
856 cmsg->cmsg_type,
857 (cmsg->cmsg_type == IP_PKTINFO),
858 (cmsg->cmsg_type == IPV6_PKTINFO));
859 if ( (cmsg->cmsg_level == IPPROTO_IP) &&
860 (cmsg->cmsg_type == IP_PKTINFO) )
861 {
862 if (CMSG_LEN (sizeof (struct in_pktinfo)) ==
863 cmsg->cmsg_len)
864 {
865 struct in_pktinfo pi;
866
867 memcpy (&pi,
868 CMSG_DATA (cmsg),
869 sizeof (pi));
870 {
871 struct sockaddr_in sa = {
872 .sin_family = AF_INET,
873 .sin_addr = pi.ipi_addr,
874 .sin_port = htons (plugin->port16)
875 };
876
877 src = find_source (plugin,
878 &sa,
879 sizeof (sa));
880 /* For sources we discovered by reading,
881 force the generation far into the future */
882 src->scan_generation = plugin->scan_generation + 60;
883 }
884 break;
885 }
886 else
887 GNUNET_break (0);
888 }
889 if ( (cmsg->cmsg_level == IPPROTO_IPV6) &&
890 (cmsg->cmsg_type == IPV6_PKTINFO) )
891 {
892 if (CMSG_LEN (sizeof (struct in6_pktinfo)) ==
893 cmsg->cmsg_len)
894 {
895 struct in6_pktinfo pi;
896
897 memcpy (&pi,
898 CMSG_DATA (cmsg),
899 sizeof (pi));
900 {
901 struct sockaddr_in6 sa = {
902 .sin6_family = AF_INET6,
903 .sin6_addr = pi.ipi6_addr,
904 .sin6_port = htons (plugin->port16),
905 .sin6_scope_id = pi.ipi6_ifindex
906 };
907
908 src = find_source (plugin,
909 &sa,
910 sizeof (sa));
911 /* For sources we discovered by reading,
912 force the generation far into the future */
913 src->scan_generation = plugin->scan_generation + 60;
914 break;
915 }
916 }
917 else
918 GNUNET_break (0);
919 }
920 }
921 if (NULL == src)
922 {
923 GNUNET_break (0);
924 return;
925 }
926 pid = (const struct GNUNET_PeerIdentity *) buf;
927 dst = find_target (plugin,
928 pid,
929 &sa,
930 mh.msg_namelen);
931 if (NULL == dst)
932 {
933 GNUNET_break (0);
934 return;
935 }
936 plugin->env->receive_cb (plugin->env->cls,
937 &dst->app_ctx,
938 &src->app_ctx,
939 &buf[sizeof(*pid)],
940 ret - sizeof (*pid));
941}
942
943
944/**
945 * Entry point for the plugin.
946 *
947 * @param cls closure (the `struct GNUNET_DHTU_PluginEnvironment`)
948 * @return the plugin's API
949 */
950void *
951libgnunet_plugin_dhtu_ip_init (void *cls)
952{
953 struct GNUNET_DHTU_PluginEnvironment *env = cls;
954 struct GNUNET_DHTU_PluginFunctions *api;
955 struct Plugin *plugin;
956 char *port;
957 unsigned int nport;
958 int sock;
959 int af;
960 unsigned long long nse;
961
962 if (GNUNET_OK !=
963 GNUNET_CONFIGURATION_get_value_number (env->cfg,
964 "DHTU-IP",
965 "NSE",
966 &nse))
967 {
968 GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
969 "DHTU-IP",
970 "NSE");
971 return NULL;
972 }
973 if (GNUNET_OK !=
974 GNUNET_CONFIGURATION_get_value_string (env->cfg,
975 "DHTU-IP",
976 "UDP_PORT",
977 &port))
978 {
979 GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
980 "DHTU-IP",
981 "UDP_PORT");
982 return NULL;
983 }
984 {
985 char dummy;
986
987 if ( (1 != sscanf (port,
988 "%u%c",
989 &nport,
990 &dummy)) ||
991 (nport > UINT16_MAX) )
992 {
993 GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
994 "DHTU-IP",
995 "UDP_PORT",
996 "must be number below 65536");
997 GNUNET_free (port);
998 return NULL;
999 }
1000 }
1001 plugin = GNUNET_new (struct Plugin);
1002 plugin->env = env;
1003 plugin->port = port;
1004 plugin->port16 = (uint16_t) nport;
1005 if (GNUNET_OK !=
1006 GNUNET_CRYPTO_get_peer_identity (env->cfg,
1007 &plugin->my_id))
1008 {
1009 GNUNET_free (plugin);
1010 return NULL;
1011 }
1012 af = AF_INET6;
1013 sock = socket (af,
1014 SOCK_DGRAM,
1015 IPPROTO_UDP);
1016 if (-1 == sock)
1017 {
1018 GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
1019 "socket");
1020 GNUNET_free (plugin->port);
1021 GNUNET_free (plugin);
1022 return NULL;
1023 }
1024 switch (af)
1025 {
1026 case AF_INET:
1027 {
1028 int on = 1;
1029
1030 if (0 !=
1031 setsockopt (sock,
1032 IPPROTO_IP,
1033 IP_PKTINFO,
1034 &on,
1035 sizeof (on)))
1036 {
1037 GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
1038 "setsockopt");
1039 }
1040 }
1041 {
1042 struct sockaddr_in sa = {
1043 .sin_family = AF_INET,
1044 .sin_port = htons ((uint16_t) nport)
1045 };
1046
1047 if (0 !=
1048 bind (sock,
1049 (const struct sockaddr *) &sa,
1050 sizeof (sa)))
1051 {
1052 GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
1053 "socket");
1054 GNUNET_break (0 ==
1055 close (sock));
1056 GNUNET_free (plugin->port);
1057 GNUNET_free (plugin);
1058 return NULL;
1059 }
1060 }
1061 break;
1062 case AF_INET6:
1063 {
1064 int on = 1;
1065
1066 if (0 !=
1067 setsockopt (sock,
1068 IPPROTO_IPV6,
1069 IPV6_RECVPKTINFO,
1070 &on,
1071 sizeof (on)))
1072 {
1073 GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
1074 "setsockopt");
1075 }
1076 }
1077 {
1078 struct sockaddr_in6 sa = {
1079 .sin6_family = AF_INET6,
1080 .sin6_port = htons ((uint16_t) nport)
1081 };
1082
1083 if (0 !=
1084 bind (sock,
1085 (const struct sockaddr *) &sa,
1086 sizeof (sa)))
1087 {
1088 GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
1089 "socket");
1090 GNUNET_break (0 ==
1091 close (sock));
1092 GNUNET_free (plugin->port);
1093 GNUNET_free (plugin);
1094 return NULL;
1095 }
1096 }
1097 break;
1098 }
1099 plugin->dsts = GNUNET_CONTAINER_multihashmap_create (128,
1100 GNUNET_NO);
1101 plugin->sock = GNUNET_NETWORK_socket_box_native (sock);
1102 plugin->read_task = GNUNET_SCHEDULER_add_read_net (
1103 GNUNET_TIME_UNIT_FOREVER_REL,
1104 plugin->sock,
1105 &read_cb,
1106 plugin);
1107 env->network_size_cb (env->cls,
1108 GNUNET_TIME_UNIT_ZERO_ABS,
1109 log (nse) / log (2),
1110 -1.0 /* stddev */);
1111 plugin->scan_task = GNUNET_SCHEDULER_add_now (&scan,
1112 plugin);
1113 api = GNUNET_new (struct GNUNET_DHTU_PluginFunctions);
1114 api->cls = plugin;
1115 api->try_connect = &ip_try_connect;
1116 api->hold = &ip_hold;
1117 api->drop = &ip_drop;
1118 api->send = &ip_send;
1119 return api;
1120}
1121
1122
1123/**
1124 * Exit point from the plugin.
1125 *
1126 * @param cls closure (our `struct Plugin`)
1127 * @return NULL
1128 */
1129void *
1130libgnunet_plugin_dhtu_ip_done (void *cls)
1131{
1132 struct GNUNET_DHTU_PluginFunctions *api = cls;
1133 struct Plugin *plugin = api->cls;
1134 struct GNUNET_DHTU_Source *src;
1135 struct GNUNET_DHTU_Target *dst;
1136
1137 while (NULL != (dst = plugin->dst_head))
1138 {
1139 plugin->env->disconnect_cb (dst->app_ctx);
1140 GNUNET_assert (NULL == dst->ph_head);
1141 GNUNET_CONTAINER_DLL_remove (plugin->dst_head,
1142 plugin->dst_tail,
1143 dst);
1144 GNUNET_free (dst);
1145 }
1146 while (NULL != (src = plugin->src_head))
1147 {
1148 plugin->env->address_del_cb (src->app_ctx);
1149 GNUNET_CONTAINER_DLL_remove (plugin->src_head,
1150 plugin->src_tail,
1151 src);
1152 GNUNET_free (src->address);
1153 GNUNET_free (src);
1154 }
1155 plugin->env->network_size_cb (plugin->env->cls,
1156 GNUNET_TIME_UNIT_FOREVER_ABS,
1157 0.0,
1158 0.0);
1159 GNUNET_CONTAINER_multihashmap_destroy (plugin->dsts);
1160 if (NULL != plugin->read_task)
1161 {
1162 GNUNET_SCHEDULER_cancel (plugin->read_task);
1163 plugin->read_task = NULL;
1164 }
1165 GNUNET_SCHEDULER_cancel (plugin->scan_task);
1166 GNUNET_break (GNUNET_OK ==
1167 GNUNET_NETWORK_socket_close (plugin->sock));
1168 GNUNET_free (plugin->port);
1169 GNUNET_free (plugin);
1170 GNUNET_free (api);
1171 return NULL;
1172}
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-24 12:06:43 +0000