GNUnet  0.10.x
Data Structures | Macros | Functions
nt.c File Reference
#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_nt_lib.h"
Include dependency graph for nt.c:

Go to the source code of this file.

Data Structures

struct  NT_Network
 We keep a list of our local networks so we can answer LAN vs. More...
 
struct  GNUNET_NT_InterfaceScanner
 Handle to the interface scanner. More...
 

Macros

#define INTERFACE_PROCESSING_INTERVAL   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 2)
 How frequently do we scan the interfaces for changes to the addresses? More...
 

Functions

const char * GNUNET_NT_to_string (enum GNUNET_NetworkType net)
 Convert a enum GNUNET_NetworkType to a string. More...
 
static void delete_networks (struct GNUNET_NT_InterfaceScanner *is)
 Delete all entries from the current network list. More...
 
static int interface_proc (void *cls, const char *name, int isDefault, const struct sockaddr *addr, const struct sockaddr *broadcast_addr, const struct sockaddr *netmask, socklen_t addrlen)
 Function invoked for each interface found. More...
 
static void get_addresses (void *cls)
 Periodically get list of network addresses from our interfaces. More...
 
enum GNUNET_NetworkType GNUNET_NT_scanner_get_type (struct GNUNET_NT_InterfaceScanner *is, const struct sockaddr *addr, socklen_t addrlen)
 Returns where the address is located: LAN or WAN or ... More...
 
struct GNUNET_NT_InterfaceScannerGNUNET_NT_scanner_init ()
 Initialize the interface scanner. More...
 
void GNUNET_NT_scanner_done (struct GNUNET_NT_InterfaceScanner *is)
 Client is done with the interface scanner, release resources. More...
 

Macro Definition Documentation

◆ INTERFACE_PROCESSING_INTERVAL

#define INTERFACE_PROCESSING_INTERVAL   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 2)

How frequently do we scan the interfaces for changes to the addresses?

Definition at line 33 of file nt.c.

Referenced by get_addresses(), and GNUNET_NT_scanner_init().

Function Documentation

◆ delete_networks()

static void delete_networks ( struct GNUNET_NT_InterfaceScanner is)
static

Delete all entries from the current network list.

Parameters
isscanner to clean up

Definition at line 130 of file nt.c.

References GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_NT_InterfaceScanner::net_head, and GNUNET_NT_InterfaceScanner::net_tail.

Referenced by get_addresses(), and GNUNET_NT_scanner_done().

131 {
132  struct NT_Network *cur;
133 
134  while (NULL != (cur = is->net_head))
135  {
137  is->net_tail,
138  cur);
139  GNUNET_free (cur);
140  }
141 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
We keep a list of our local networks so we can answer LAN vs.
Definition: nt.c:71
struct NT_Network * net_head
Head of LAN networks list.
Definition: nt.c:109
struct NT_Network * net_tail
Tail of LAN networks list.
Definition: nt.c:114
#define GNUNET_free(ptr)
Wrapper around free.
Here is the caller graph for this function:

◆ interface_proc()

static int interface_proc ( void *  cls,
const char *  name,
int  isDefault,
const struct sockaddr *  addr,
const struct sockaddr *  broadcast_addr,
const struct sockaddr *  netmask,
socklen_t  addrlen 
)
static

Function invoked for each interface found.

Adds the interface's network addresses to the respective DLL, so we can distinguish between LAN and WAN.

Parameters
clsclosure with the struct GNUNET_NT_InterfaceScanner
namename of the interface (can be NULL for unknown)
isDefaultis this presumably the default interface
addraddress of this interface (can be NULL for unknown or unassigned)
broadcast_addrthe broadcast address (can be NULL for unknown or unassigned)
netmaskthe network mask (can be NULL for unknown or unassigned)
addrlenlength of the address
Returns
GNUNET_OK to continue iteration

Definition at line 159 of file nt.c.

References GNUNET_a2s(), GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log_from, GNUNET_malloc, GNUNET_memcpy, GNUNET_OK, GNUNET_strdup, is, GNUNET_NT_InterfaceScanner::net_head, GNUNET_NT_InterfaceScanner::net_tail, NT_Network::netmask, and NT_Network::network.

Referenced by get_addresses(), and GNUNET_NT_scanner_init().

166 {
167  struct GNUNET_NT_InterfaceScanner *is = cls;
168  /* Calculate network */
169  struct NT_Network *net = NULL;
170  (void) name;
171  (void) isDefault;
172  (void) broadcast_addr;
173 
174  /* Skipping IPv4 loopback addresses since we have special check */
175  if (addr->sa_family == AF_INET)
176  {
177  const struct sockaddr_in *a4 = (const struct sockaddr_in *) addr;
178 
179  if ((a4->sin_addr.s_addr & htonl(0xff000000)) == htonl (0x7f000000))
180  return GNUNET_OK;
181  }
182  /* Skipping IPv6 loopback addresses since we have special check */
183  if (addr->sa_family == AF_INET6)
184  {
185  const struct sockaddr_in6 *a6 = (const struct sockaddr_in6 *) addr;
186  if (IN6_IS_ADDR_LOOPBACK (&a6->sin6_addr))
187  return GNUNET_OK;
188  }
189 
190  if (addr->sa_family == AF_INET)
191  {
192  const struct sockaddr_in *addr4 = (const struct sockaddr_in *) addr;
193  const struct sockaddr_in *netmask4 = (const struct sockaddr_in *) netmask;
194  struct sockaddr_in *tmp;
195  struct sockaddr_in network4;
196 
197  net = GNUNET_malloc (sizeof (struct NT_Network) + 2 * sizeof (struct sockaddr_in));
198  tmp = (struct sockaddr_in *) &net[1];
199  net->network = (struct sockaddr *) &tmp[0];
200  net->netmask = (struct sockaddr *) &tmp[1];
201  net->length = addrlen;
202 
203  memset (&network4,
204  0,
205  sizeof (network4));
206  network4.sin_family = AF_INET;
207 #if HAVE_SOCKADDR_IN_SIN_LEN
208  network4.sin_len = sizeof (network4);
209 #endif
210  network4.sin_addr.s_addr = (addr4->sin_addr.s_addr & netmask4->sin_addr.s_addr);
211 
212  GNUNET_memcpy (net->netmask,
213  netmask4,
214  sizeof (struct sockaddr_in));
215  GNUNET_memcpy (net->network,
216  &network4,
217  sizeof (struct sockaddr_in));
218  }
219 
220  if (addr->sa_family == AF_INET6)
221  {
222  const struct sockaddr_in6 *addr6 = (const struct sockaddr_in6 *) addr;
223  const struct sockaddr_in6 *netmask6 = (const struct sockaddr_in6 *) netmask;
224  struct sockaddr_in6 * tmp;
225  struct sockaddr_in6 network6;
226 
227  net = GNUNET_malloc (sizeof (struct NT_Network) + 2 * sizeof (struct sockaddr_in6));
228  tmp = (struct sockaddr_in6 *) &net[1];
229  net->network = (struct sockaddr *) &tmp[0];
230  net->netmask = (struct sockaddr *) &tmp[1];
231  net->length = addrlen;
232 
233  memset (&network6, 0, sizeof (network6));
234  network6.sin6_family = AF_INET6;
235 #if HAVE_SOCKADDR_IN_SIN_LEN
236  network6.sin6_len = sizeof (network6);
237 #endif
238  unsigned int c = 0;
239  uint32_t *addr_elem = (uint32_t *) &addr6->sin6_addr;
240  uint32_t *mask_elem = (uint32_t *) &netmask6->sin6_addr;
241  uint32_t *net_elem = (uint32_t *) &network6.sin6_addr;
242  for (c = 0; c < 4; c++)
243  net_elem[c] = addr_elem[c] & mask_elem[c];
244 
245  GNUNET_memcpy (net->netmask,
246  netmask6,
247  sizeof (struct sockaddr_in6));
248  GNUNET_memcpy (net->network,
249  &network6,
250  sizeof (struct sockaddr_in6));
251  }
252  if (NULL == net)
253  return GNUNET_OK; /* odd / unsupported address family */
254 
255  /* Store in list */
256 #if VERBOSE_NT
257  char * netmask = GNUNET_strdup (GNUNET_a2s((struct sockaddr *) net->netmask, addrlen));
259  "nt",
260  "Adding network `%s', netmask `%s'\n",
261  GNUNET_a2s ((struct sockaddr *) net->network,
262  addrlen),
263  netmask);
264  GNUNET_free (netmask);
265 #endif
267  is->net_tail,
268  net);
269 
270  return GNUNET_OK;
271 }
Handle to the interface scanner.
Definition: nt.c:103
We keep a list of our local networks so we can answer LAN vs.
Definition: nt.c:71
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
static struct GNUNET_NT_InterfaceScanner * is
Network scanner to determine network types.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
struct NT_Network * net_head
Head of LAN networks list.
Definition: nt.c:109
struct NT_Network * net_tail
Tail of LAN networks list.
Definition: nt.c:114
#define GNUNET_memcpy(dst, src, n)
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)...
const char * name
#define GNUNET_log_from(kind, comp,...)
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ get_addresses()

static void get_addresses ( void *  cls)
static

Periodically get list of network addresses from our interfaces.

Parameters
clsclosure

Definition at line 280 of file nt.c.

References delete_networks(), GNUNET_OS_network_interfaces_list(), GNUNET_SCHEDULER_add_delayed(), interface_proc(), INTERFACE_PROCESSING_INTERVAL, GNUNET_NT_InterfaceScanner::interface_task, and is.

Referenced by GNUNET_NT_scanner_init().

281 {
282  struct GNUNET_NT_InterfaceScanner *is = cls;
283 
284  is->interface_task = NULL;
285  delete_networks (is);
287  is);
289  &get_addresses,
290  is);
291 }
Handle to the interface scanner.
Definition: nt.c:103
static void delete_networks(struct GNUNET_NT_InterfaceScanner *is)
Delete all entries from the current network list.
Definition: nt.c:130
static struct GNUNET_NT_InterfaceScanner * is
Network scanner to determine network types.
void GNUNET_OS_network_interfaces_list(GNUNET_OS_NetworkInterfaceProcessor proc, void *proc_cls)
Enumerate all network interfaces.
Definition: os_network.c:388
static int interface_proc(void *cls, const char *name, int isDefault, const struct sockaddr *addr, const struct sockaddr *broadcast_addr, const struct sockaddr *netmask, socklen_t addrlen)
Function invoked for each interface found.
Definition: nt.c:159
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:1246
#define INTERFACE_PROCESSING_INTERVAL
How frequently do we scan the interfaces for changes to the addresses?
Definition: nt.c:33
struct GNUNET_SCHEDULER_Task * interface_task
Task for periodically refreshing our LAN network list.
Definition: nt.c:119
static void get_addresses(void *cls)
Periodically get list of network addresses from our interfaces.
Definition: nt.c:280
Here is the call graph for this function:
Here is the caller graph for this function: