GNUnet  0.11.x
plugin_transport_udp_broadcasting.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet
3  Copyright (C) 2010, 2011 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 
27 #include "platform.h"
28 #include "plugin_transport_udp.h"
29 #include "gnunet_hello_lib.h"
30 #include "gnunet_util_lib.h"
32 #include "gnunet_protocols.h"
34 #include "gnunet_signatures.h"
35 #include "gnunet_constants.h"
39 #include "transport.h"
40 
41 #define LOG(kind, ...) GNUNET_log_from (kind, "transport-udp", __VA_ARGS__)
42 
43 /* *********** Cryogenic ********** */
44 #if LINUX
45 #include <sys/stat.h>
46 #include <fcntl.h>
47 
48 #include <sys/ioctl.h>
49 #include <sys/select.h>
50 #include <sys/time.h>
51 
52 #define PM_MAGIC 'k'
53 #define PM_SET_DELAY_AND_TIMEOUT _IOW (PM_MAGIC, 1, struct pm_times)
54 
55 struct pm_times
56 {
57  unsigned long delay_msecs;
58  unsigned long timeout_msecs;
59 };
60 #endif
61 /************************************/
62 
63 
65 {
69  struct GNUNET_MessageHeader header;
70 
74  struct GNUNET_PeerIdentity sender;
75 };
76 
77 
79 {
81 
83 
88 
89  struct Plugin *plugin;
90 
91  struct sockaddr *addr;
92 
93  socklen_t addrlen;
94 
95 #if LINUX
96 
99  struct GNUNET_DISK_FileHandle *cryogenic_fd;
100 
104  struct pm_times cryogenic_times;
105 #endif
106 };
107 
108 
113 {
114  struct Plugin *plugin;
115 
116  const union UdpAddress *udp_addr;
117 
118  size_t udp_addr_len;
119 
123  enum GNUNET_NetworkType ats_address_network_type;
124 };
125 
126 
135 static int
136 broadcast_mst_cb (void *cls,
137  const struct GNUNET_MessageHeader *message)
138 {
139  struct MstContext *mc = cls;
140  struct Plugin *plugin = mc->plugin;
142  const struct GNUNET_MessageHeader *hello;
143  const struct UDP_Beacon_Message *msg;
144 
145  msg = (const struct UDP_Beacon_Message *) message;
146 
148  ntohs (msg->header.type))
149  return GNUNET_OK;
151  "Received beacon with %u bytes from peer `%s' via address `%s'\n",
152  ntohs (msg->header.size),
153  GNUNET_i2s (&msg->sender),
154  udp_address_to_string (NULL,
155  mc->udp_addr,
156  mc->udp_addr_len));
157  hello = (struct GNUNET_MessageHeader *) &msg[1];
158  address = GNUNET_HELLO_address_allocate (&msg->sender,
159  PLUGIN_NAME,
160  mc->udp_addr,
161  mc->udp_addr_len,
163  plugin->env->receive (plugin->env->cls,
164  address,
165  NULL,
166  hello);
167  GNUNET_HELLO_address_free (address);
168  GNUNET_STATISTICS_update (plugin->env->stats,
169  _ ("# Multicast HELLO beacons received via UDP"),
170  1, GNUNET_NO);
171  return GNUNET_OK;
172 }
173 
174 
186 void
188  const char *buf,
189  ssize_t size,
190  const union UdpAddress *udp_addr,
191  size_t udp_addr_len,
192  enum GNUNET_NetworkType network_type)
193 {
194  struct GNUNET_MessageStreamTokenizer *broadcast_mst;
195  struct MstContext mc;
196 
197  broadcast_mst = GNUNET_MST_create (&broadcast_mst_cb,
198  &mc);
199  mc.plugin = plugin;
200  mc.udp_addr = udp_addr;
202  mc.ats_address_network_type = network_type;
203  GNUNET_MST_from_buffer (broadcast_mst,
204  buf, size,
205  GNUNET_NO,
206  GNUNET_NO);
207  GNUNET_MST_destroy (broadcast_mst);
208 }
209 
210 
211 static unsigned int
213  struct UDP_Beacon_Message *msg)
214 {
215  uint16_t hello_size;
216  uint16_t msg_size;
217 
218  const struct GNUNET_MessageHeader *hello;
219 
220  hello = plugin->env->get_our_hello ();
221  if (NULL == hello)
222  return 0;
223  hello_size = GNUNET_HELLO_size ((struct GNUNET_HELLO_Message *) hello);
224  msg_size = hello_size + sizeof(struct UDP_Beacon_Message);
225 
226  if ((hello_size < (sizeof(struct GNUNET_MessageHeader))) ||
227  (msg_size > (UDP_MTU)))
228  return 0;
229 
230  msg->sender = *(plugin->env->my_identity);
231  msg->header.size = htons (msg_size);
233  GNUNET_memcpy (&msg[1], hello, hello_size);
234  return msg_size;
235 }
236 
237 
238 static void
240 {
241  struct BroadcastAddress *baddr = cls;
242  struct Plugin *plugin = baddr->plugin;
243  int sent;
244  uint16_t msg_size;
245  char buf[65536] GNUNET_ALIGN;
246 
247  baddr->broadcast_task = NULL;
248 
249  msg_size = prepare_beacon (plugin, (struct UDP_Beacon_Message *) &buf);
250  if (0 != msg_size)
251  {
252  struct sockaddr_in *addr = (struct sockaddr_in *) baddr->addr;
253 
254  addr->sin_port = htons (plugin->port);
255  sent = GNUNET_NETWORK_socket_sendto (plugin->sockv4, &buf, msg_size,
256  (const struct sockaddr *) addr,
257  baddr->addrlen);
258  if (sent == GNUNET_SYSERR)
259  {
260  if ((ENETUNREACH == errno) || (ENETDOWN == errno))
261  {
262  /* "Network unreachable" or "Network down"
263  *
264  * This indicates that we just do not have network connectivity
265  */
267  "Network connectivity is down, cannot send beacon!\n");
268  }
269  else
271  }
272  else
273  {
275  "Sent HELLO beacon broadcast with %i bytes to address %s\n", sent,
276  GNUNET_a2s (baddr->addr, baddr->addrlen));
277  }
278  }
279 
280 #if LINUX
281  /*
282  * Cryogenic
283  */
284  if (NULL != baddr->cryogenic_fd)
285  {
286  baddr->cryogenic_times.delay_msecs =
287  (plugin->broadcast_interval.rel_value_us / 1000.0) * 0.5;
288  baddr->cryogenic_times.timeout_msecs =
289  (plugin->broadcast_interval.rel_value_us / 1000.0) * 1.5;
290 
291  if (ioctl (baddr->cryogenic_fd->fd,
292  PM_SET_DELAY_AND_TIMEOUT,
293  &baddr->cryogenic_times) < 0)
294  {
296  baddr->broadcast_task =
298  &udp_ipv4_broadcast_send, baddr);
299  }
300  else
302  baddr->cryogenic_fd,
304  baddr);
305  }
306  else
307 #endif
308  baddr->broadcast_task =
310  &udp_ipv4_broadcast_send, baddr);
311 }
312 
313 
314 static void
316 {
317  struct BroadcastAddress *baddr = cls;
318  struct Plugin *plugin = baddr->plugin;
319  ssize_t sent;
320  uint16_t msg_size;
321  char buf[65536] GNUNET_ALIGN;
322  const struct sockaddr_in6 *s6 = (const struct sockaddr_in6 *) baddr->addr;
323 
324  baddr->broadcast_task = NULL;
325 
326  msg_size = prepare_beacon (plugin, (struct UDP_Beacon_Message *) &buf);
327  /* Note: unclear if this actually works to limit the multicast to
328  the specified interface as we're not (necessarily) using a
329  link-local multicast group and the kernel suggests that the
330  scope ID is only respected for link-local addresses; however,
331  if the scope ID is ignored, the kernel should just multicast
332  on ALL interfaces, which is merely slightly less efficient;
333  in that case, we might want to revert to only doing this
334  once, and not per interface (hard to test...) */plugin->ipv6_multicast_address.sin6_scope_id = s6->sin6_scope_id;
335  sent = GNUNET_NETWORK_socket_sendto (plugin->sockv6, &buf, msg_size,
336  (const struct sockaddr *)
337  &plugin->ipv6_multicast_address,
338  sizeof(struct sockaddr_in6));
339  plugin->ipv6_multicast_address.sin6_scope_id = 0;
340  if (sent == GNUNET_SYSERR)
341  {
342  if ((ENETUNREACH == errno) || (ENETDOWN == errno))
343  {
344  /* "Network unreachable" or "Network down"
345  *
346  * This indicates that this system is IPv6 enabled, but does not
347  * have a valid global IPv6 address assigned
349  "Network connectivity is down, cannot send beacon!\n");
350  }
351  else
353  }
354  else
355  {
357  "Sending IPv6 HELLO beacon broadcast with %d bytes to address %s\n",
358  (int) sent,
359  GNUNET_a2s ((const struct sockaddr *) &plugin->ipv6_multicast_address,
360  sizeof(struct sockaddr_in6)));
361  }
362 #if LINUX
363  /*
364  * Cryogenic
365  */
366  if (NULL != baddr->cryogenic_fd)
367  {
368  baddr->cryogenic_times.delay_msecs =
369  (plugin->broadcast_interval.rel_value_us / 1000.0) * 0.5;
370  baddr->cryogenic_times.timeout_msecs =
371  (plugin->broadcast_interval.rel_value_us / 1000.0) * 1.5;
372 
373  if (ioctl (baddr->cryogenic_fd->fd,
374  PM_SET_DELAY_AND_TIMEOUT,
375  &baddr->cryogenic_times) < 0)
376  {
378  baddr->broadcast_task =
380  &udp_ipv6_broadcast_send, baddr);
381  }
382  else
384  baddr->cryogenic_fd,
386  baddr);
387  }
388  else
389 #endif
390  baddr->broadcast_task =
392  &udp_ipv6_broadcast_send, baddr);
393 }
394 
395 
408 static int
409 iface_proc (void *cls,
410  const char *name,
411  int isDefault,
412  const struct sockaddr *addr,
413  const struct sockaddr *broadcast_addr,
414  const struct sockaddr *netmask, socklen_t addrlen)
415 {
416  struct Plugin *plugin = cls;
417  struct BroadcastAddress *ba;
418  enum GNUNET_NetworkType network;
419 
420  if (NULL == addr)
421  return GNUNET_OK;
423  "address %s for interface %s %p\n ",
424  GNUNET_a2s (addr, addrlen), name, addr);
425  if (NULL == broadcast_addr)
426  return GNUNET_OK;
428  "broadcast address %s for interface %s %p\n ",
429  GNUNET_a2s (broadcast_addr, addrlen), name, broadcast_addr);
430  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "netmask %s for interface %s %p\n ",
431  GNUNET_a2s (netmask, addrlen), name, netmask);
432 
433  network = plugin->env->get_address_type (plugin->env->cls, broadcast_addr,
434  addrlen);
435  if (GNUNET_NT_LOOPBACK == network)
436  {
437  /* Broadcasting on loopback does not make sense */
438  return GNUNET_YES;
439  }
440 
441  ba = GNUNET_new (struct BroadcastAddress);
442  ba->plugin = plugin;
443  ba->addr = GNUNET_malloc (addrlen);
444  GNUNET_memcpy (ba->addr, broadcast_addr, addrlen);
445  ba->addrlen = addrlen;
446 
447  if ((GNUNET_YES == plugin->enable_ipv4) &&
448  (NULL != plugin->sockv4) &&
449  (addrlen == sizeof(struct sockaddr_in)))
450  {
451 #if LINUX
452  /*
453  * setup Cryogenic FD for ipv4 broadcasting
454  */
455  char *filename;
456 
457  GNUNET_asprintf (&filename,
458  "/dev/cryogenic/%s",
459  name);
460  if (0 == access (name, R_OK))
461  {
462  ba->cryogenic_fd =
463  GNUNET_DISK_file_open (filename,
466  }
467  GNUNET_free (filename);
468 #endif
469  ba->broadcast_task =
471  }
472  if ((GNUNET_YES == plugin->enable_ipv6) &&
473  (NULL != plugin->sockv6) &&
474  (addrlen == sizeof(struct sockaddr_in6)))
475  {
476  /* Create IPv6 multicast request */
477  struct ipv6_mreq multicastRequest;
478  const struct sockaddr_in6 *s6 = (const struct
479  sockaddr_in6 *) broadcast_addr;
480 
481  multicastRequest.ipv6mr_multiaddr =
482  plugin->ipv6_multicast_address.sin6_addr;
483  /* http://tools.ietf.org/html/rfc2553#section-5.2:
484  *
485  * IPV6_JOIN_GROUP
486  *
487  * Join a multicast group on a specified local interface. If the
488  * interface index is specified as 0, the kernel chooses the local
489  * interface. For example, some kernels look up the multicast
490  * group in the normal IPv6 routing table and using the resulting
491  * interface; we do this for each interface, so no need to use
492  * zero (anymore...).
493  */multicastRequest.ipv6mr_interface = s6->sin6_scope_id;
494 
495  /* Join the multicast group */
496  if (GNUNET_OK !=
498  (plugin->sockv6, IPPROTO_IPV6, IPV6_JOIN_GROUP,
499  &multicastRequest, sizeof(multicastRequest)))
500  {
502  "Failed to join IPv6 multicast group: IPv6 broadcasting not running\n");
503  }
504  else
505  {
506 #if LINUX
507  /*
508  * setup Cryogenic FD for ipv6 broadcasting
509  */
510  char *filename;
511 
512  GNUNET_asprintf (&filename,
513  "/dev/cryogenic/%s",
514  name);
515  if (0 == access (name, R_OK))
516  {
517  ba->cryogenic_fd =
518  GNUNET_DISK_file_open (filename,
521  }
522  GNUNET_free (filename);
523 #endif
524  ba->broadcast_task =
526  }
527  }
529  plugin->broadcast_tail, ba);
530  return GNUNET_OK;
531 }
532 
533 
541 void
543  struct sockaddr_in6 *server_addrv6,
544  struct sockaddr_in *server_addrv4)
545 {
546  if (GNUNET_YES ==
548  "topology",
549  "FRIENDS-ONLY"))
550  {
552  _ (
553  "Disabling HELLO broadcasting due to friend-to-friend only configuration!\n"));
554  return;
555  }
556 
557  if (GNUNET_YES != plugin->enable_broadcasting)
558  return; /* We do not send, just receive */
559 
560  /* create IPv4 broadcast socket */
561  if ((GNUNET_YES == plugin->enable_ipv4) && (NULL != plugin->sockv4))
562  {
563  static int yes = 1;
564 
566  (plugin->sockv4, SOL_SOCKET, SO_BROADCAST, &yes,
567  sizeof(int)) != GNUNET_OK)
568  {
570  _ (
571  "Failed to set IPv4 broadcast option for broadcast socket on port %d\n"),
572  ntohs (server_addrv4->sin_port));
573  }
574  }
575  /* create IPv6 multicast socket */
576  if ((GNUNET_YES == plugin->enable_ipv6) && (plugin->sockv6 != NULL))
577  {
578  memset (&plugin->ipv6_multicast_address, 0, sizeof(struct sockaddr_in6));
579  GNUNET_assert (1 ==
580  inet_pton (AF_INET6, "FF05::13B",
581  &plugin->ipv6_multicast_address.sin6_addr));
582  plugin->ipv6_multicast_address.sin6_family = AF_INET6;
583  plugin->ipv6_multicast_address.sin6_port = htons (plugin->port);
584  }
586 }
587 
588 
594 void
596 {
597  if (GNUNET_YES == plugin->enable_broadcasting)
598  {
599  /* Disable broadcasting */
600  while (plugin->broadcast_head != NULL)
601  {
602  struct BroadcastAddress *p = plugin->broadcast_head;
603 
604  if (p->broadcast_task != NULL)
605  {
607  p->broadcast_task = NULL;
608  }
609  if ((GNUNET_YES == plugin->enable_ipv6) &&
610  (NULL != plugin->sockv6) &&
611  (p->addrlen == sizeof(struct sockaddr_in6)))
612  {
613  /* Create IPv6 multicast request */
614  struct ipv6_mreq multicastRequest;
615  const struct sockaddr_in6 *s6 = (const struct sockaddr_in6 *) p->addr;
616 
617  multicastRequest.ipv6mr_multiaddr =
618  plugin->ipv6_multicast_address.sin6_addr;
619  multicastRequest.ipv6mr_interface = s6->sin6_scope_id;
620 
621  /* Leave the multicast group */
622  if (GNUNET_OK ==
624  (plugin->sockv6, IPPROTO_IPV6, IPV6_LEAVE_GROUP,
625  &multicastRequest, sizeof(multicastRequest)))
626  {
628  }
629  else
630  {
631  LOG (GNUNET_ERROR_TYPE_DEBUG, "IPv6 multicasting stopped\n");
632  }
633  }
634 
635 #if LINUX
636  GNUNET_DISK_file_close (p->cryogenic_fd);
637 #endif
639  plugin->broadcast_tail, p);
640  GNUNET_free (p->addr);
641  GNUNET_free (p);
642  }
643  }
644 }
645 
646 
647 /* end of plugin_transport_udp_broadcasting.c */
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
int GNUNET_NETWORK_socket_setsockopt(struct GNUNET_NETWORK_Handle *fd, int level, int option_name, const void *option_value, socklen_t option_len)
Set socket option.
Definition: network.c:883
void udp_broadcast_receive(struct Plugin *plugin, const char *buf, ssize_t size, const union UdpAddress *udp_addr, size_t udp_addr_len, enum GNUNET_NetworkType network_type)
We received a broadcast message.
A HELLO message is used to exchange information about transports with other peers.
int enable_broadcasting
Is broadcasting enabled: GNUNET_YES or GNUNET_NO.
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_HELLO_Address * GNUNET_HELLO_address_allocate(const struct GNUNET_PeerIdentity *peer, const char *transport_name, const void *address, size_t address_length, enum GNUNET_HELLO_AddressInfo local_info)
Allocate an address struct.
Definition: address.c:73
int GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1345
uint64_t rel_value_us
The actual value.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
Implementation of the UDP transport protocol.
common internal definitions for transport service
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration to use.
int enable_ipv4
Is IPv4 enabled: GNUNET_YES or GNUNET_NO.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
void setup_broadcast(struct Plugin *plugin, struct sockaddr_in6 *server_addrv6, struct sockaddr_in *server_addrv4)
Setup broadcasting subsystem.
struct BroadcastAddress * next
Nobody is allowed to do anything to the file.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_NO
Definition: gnunet_common.h:78
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_write_file(struct GNUNET_TIME_Relative delay, const struct GNUNET_DISK_FileHandle *wfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1669
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_new(type)
Allocate a struct or union of the given type.
void GNUNET_OS_network_interfaces_list(GNUNET_OS_NetworkInterfaceProcessor proc, void *proc_cls)
Enumerate all network interfaces.
Definition: os_network.c:396
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
struct GNUNET_NETWORK_Handle * sockv4
The read socket for IPv4.
struct GNUNET_PeerIdentity sender
What is the identity of the sender.
Client-specific context for broadcast_mst_cb().
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
#define UDP_MTU
MTU for fragmentation subsystem.
GNUNET_NetworkType
Types of networks (with separate quotas) we support.
Definition: gnunet_nt_lib.h:35
enum GNUNET_NetworkType ats_address_network_type
ATS network type.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1253
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
#define LOG(kind,...)
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
void GNUNET_MST_destroy(struct GNUNET_MessageStreamTokenizer *mst)
Destroys a tokenizer.
Definition: mst.c:411
struct GNUNET_DATACACHE_PluginEnvironment * env
Our execution environment.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1280
Handle to a message stream tokenizer.
Definition: mst.c:43
ssize_t GNUNET_NETWORK_socket_sendto(const struct GNUNET_NETWORK_Handle *desc, const void *message, size_t length, const struct sockaddr *dest_addr, socklen_t dest_len)
Send data to a particular destination (always non-blocking).
Definition: network.c:850
static char buf[2048]
static char * filename
static unsigned int prepare_beacon(struct Plugin *plugin, struct UDP_Beacon_Message *msg)
struct GNUNET_MessageStreamTokenizer * GNUNET_MST_create(GNUNET_MessageTokenizerCallback cb, void *cb_cls)
Create a message stream tokenizer.
Definition: mst.c:85
static int broadcast_mst_cb(void *cls, const struct GNUNET_MessageHeader *message)
Parse broadcast message received.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
const char * GNUNET_a2s(const struct sockaddr *addr, socklen_t addrlen)
Convert a "struct sockaddr*" (IPv4 or IPv6 address) to a string (for printing debug messages)...
int GNUNET_MST_from_buffer(struct GNUNET_MessageStreamTokenizer *mst, const char *buf, size_t size, int purge, int one_shot)
Add incoming data to the receive buffer and call the callback for all complete messages.
Definition: mst.c:114
static void udp_ipv4_broadcast_send(void *cls)
struct GNUNET_SCHEDULER_Task * broadcast_task
ID of select broadcast task.
struct BroadcastAddress * broadcast_head
Tail of DLL of broadcast addresses.
static struct GNUNET_TESTBED_Controller * mc
Handle to the master controller.
static char * plugin
Solver plugin name as string.
struct GNUNET_TIME_Relative broadcast_interval
Broadcast interval.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static unsigned int size
Size of the "table".
Definition: peer.c:67
struct GNUNET_MessageHeader header
Message header.
Open the file for writing.
Loopback (same host).
Definition: gnunet_nt_lib.h:45
The identity of the host (wraps the signing key of the peer).
struct BroadcastAddress * prev
No additional information.
#define GNUNET_ALIGN
gcc-ism to force alignment; we use this to align char-arrays that may then be cast to &#39;struct&#39;s...
Handle for a plugin.
Definition: block.c:37
const char * name
#define PLUGIN_NAME
Either an IPv4 or IPv6 UDP address.
An address for communicating with a peer.
const char * udp_address_to_string(void *cls, const void *addr, size_t addrlen)
Function called for a quick conversion of the binary address to a numeric address.
#define GNUNET_log(kind,...)
Entry in list of pending tasks.
Definition: scheduler.c:134
struct GNUNET_NETWORK_Handle * sockv6
The read socket for IPv6.
uint16_t port
Port used.
void stop_broadcast(struct Plugin *plugin)
Stop broadcasting subsystem.
uint16_t GNUNET_HELLO_size(const struct GNUNET_HELLO_Message *hello)
Return the size of the given HELLO message.
Definition: hello.c:652
static int iface_proc(void *cls, const char *name, int isDefault, const struct sockaddr *addr, const struct sockaddr *broadcast_addr, const struct sockaddr *netmask, socklen_t addrlen)
Callback function invoked for each interface found.
void * cls
Closure to use for callbacks.
Header for all communications.
#define GNUNET_YES
Definition: gnunet_common.h:77
static void udp_ipv6_broadcast_send(void *cls)
#define GNUNET_MESSAGE_TYPE_TRANSPORT_BROADCAST_BEACON
Message send by a peer to notify the other to keep the session alive.
struct BroadcastAddress * broadcast_tail
Head of DLL of broadcast addresses.
int GNUNET_CONFIGURATION_get_value_yesno(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option)
Get a configuration value that should be in a set of "YES" or "NO".
struct GNUNET_DISK_FileHandle * GNUNET_DISK_file_open(const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
Open a file.
Definition: disk.c:1268
struct sockaddr_in6 ipv6_multicast_address
IPv6 multicast address.
static char * address
GNS address for this phone.
Handle used to access files (and pipes).
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_HELLO_address_free(addr)
Free an address.
#define GNUNET_malloc(size)
Wrapper around malloc.
int enable_ipv6
Is IPv6 enabled: GNUNET_YES or GNUNET_NO.
const union UdpAddress * udp_addr
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966