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 132 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().

133 {
134  struct NT_Network *cur;
135 
136  while (NULL != (cur = is->net_head))
137  {
139  is->net_tail,
140  cur);
141  GNUNET_free(cur);
142  }
143 }
#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:77
struct NT_Network * net_head
Head of LAN networks list.
Definition: nt.c:112
struct NT_Network * net_tail
Tail of LAN networks list.
Definition: nt.c:117
#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 161 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().

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

284 {
285  struct GNUNET_NT_InterfaceScanner *is = cls;
286 
287  is->interface_task = NULL;
288  delete_networks(is);
290  is);
292  &get_addresses,
293  is);
294 }
Handle to the interface scanner.
Definition: nt.c:108
static void delete_networks(struct GNUNET_NT_InterfaceScanner *is)
Delete all entries from the current network list.
Definition: nt.c:132
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:161
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:1237
#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:122
static void get_addresses(void *cls)
Periodically get list of network addresses from our interfaces.
Definition: nt.c:283
Here is the call graph for this function:
Here is the caller graph for this function: