GNUnet 0.21.1
nt.c File Reference

LAN interface scanning to determine IPs in LAN. More...

#include "platform.h"
#include "gnunet_util_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
 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...
 

Detailed Description

LAN interface scanning to determine IPs in LAN.

Author
Christian Grothoff
Matthias Wachs

Definition in file nt.c.

Macro Definition Documentation

◆ INTERFACE_PROCESSING_INTERVAL

#define INTERFACE_PROCESSING_INTERVAL
Value:
#define GNUNET_TIME_UNIT_MINUTES
One minute.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:484

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

Definition at line 32 of file nt.c.

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 128 of file nt.c.

129{
130 struct NT_Network *cur;
131
132 while (NULL != (cur = is->net_head))
133 {
135 is->net_tail,
136 cur);
137 GNUNET_free (cur);
138 }
139}
static struct GNUNET_TESTING_Interpreter * is
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_free(ptr)
Wrapper around free.
We keep a list of our local networks so we can answer LAN vs.
Definition: nt.c:72

References GNUNET_CONTAINER_DLL_remove, GNUNET_free, and is.

Referenced by get_addresses(), and GNUNET_NT_scanner_done().

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 157 of file nt.c.

164{
165 struct GNUNET_NT_InterfaceScanner *is = cls;
166 /* Calculate network */
167 struct NT_Network *net = NULL;
168
169 (void) name;
170 (void) isDefault;
171 (void) broadcast_addr;
172
173 /* Skipping IPv4 loopback addresses since we have special check */
174 if (addr->sa_family == AF_INET)
175 {
176 const struct sockaddr_in *a4 = (const struct sockaddr_in *) addr;
177
178 if ((a4->sin_addr.s_addr & htonl (0xff000000)) == htonl (0x7f000000))
179 return GNUNET_OK;
180 }
181 /* Skipping IPv6 loopback addresses since we have special check */
182 if (addr->sa_family == AF_INET6)
183 {
184 const struct sockaddr_in6 *a6 = (const struct sockaddr_in6 *) addr;
185 if (IN6_IS_ADDR_LOOPBACK (&a6->sin6_addr))
186 return GNUNET_OK;
187 }
188
189 if (addr->sa_family == AF_INET)
190 {
191 const struct sockaddr_in *addr4 = (const struct sockaddr_in *) addr;
192 const struct sockaddr_in *netmask4 = (const struct sockaddr_in *) netmask;
193 struct sockaddr_in *tmp;
194 struct sockaddr_in network4;
195
196 net = GNUNET_malloc (sizeof(struct NT_Network) + 2 * sizeof(struct
197 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
211 & netmask4->sin_addr.s_addr);
212
213 GNUNET_memcpy (net->netmask,
214 netmask4,
215 sizeof(struct sockaddr_in));
216 GNUNET_memcpy (net->network,
217 &network4,
218 sizeof(struct sockaddr_in));
219 }
220
221 if (addr->sa_family == AF_INET6)
222 {
223 const struct sockaddr_in6 *addr6 = (const struct sockaddr_in6 *) addr;
224 const struct sockaddr_in6 *netmask6 = (const struct sockaddr_in6 *) netmask;
225 struct sockaddr_in6 *tmp;
226 struct sockaddr_in6 network6;
227
228 net = GNUNET_malloc (sizeof(struct NT_Network) + 2 * sizeof(struct
229 sockaddr_in6));
230 tmp = (struct sockaddr_in6 *) &net[1];
231 net->network = (struct sockaddr *) &tmp[0];
232 net->netmask = (struct sockaddr *) &tmp[1];
233 net->length = addrlen;
234
235 memset (&network6, 0, sizeof(network6));
236 network6.sin6_family = AF_INET6;
237#if HAVE_SOCKADDR_IN_SIN_LEN
238 network6.sin6_len = sizeof(network6);
239#endif
240 unsigned int c = 0;
241 uint32_t *addr_elem = (uint32_t *) &addr6->sin6_addr;
242 uint32_t *mask_elem = (uint32_t *) &netmask6->sin6_addr;
243 uint32_t *net_elem = (uint32_t *) &network6.sin6_addr;
244 for (c = 0; c < 4; c++)
245 net_elem[c] = addr_elem[c] & mask_elem[c];
246
247 GNUNET_memcpy (net->netmask,
248 netmask6,
249 sizeof(struct sockaddr_in6));
250 GNUNET_memcpy (net->network,
251 &network6,
252 sizeof(struct sockaddr_in6));
253 }
254 if (NULL == net)
255 return GNUNET_OK; /* odd / unsupported address family */
256
257 /* Store in list */
258#if VERBOSE_NT
259 char *netmask = GNUNET_strdup (GNUNET_a2s ((struct sockaddr *) net->netmask,
260 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}
static char * name
Name (label) of the records to list.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
#define GNUNET_log_from(kind, comp,...)
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_OK
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).
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_malloc(size)
Wrapper around malloc.
Handle to the interface scanner.
Definition: nt.c:104

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, name, NT_Network::netmask, and NT_Network::network.

Referenced by get_addresses(), and GNUNET_NT_scanner_init().

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.

284{
285 struct GNUNET_NT_InterfaceScanner *is = cls;
286
287 is->interface_task = NULL;
290 is);
291 is->interface_task = GNUNET_SCHEDULER_add_delayed (
294 is);
295}
void GNUNET_OS_network_interfaces_list(GNUNET_OS_NetworkInterfaceProcessor proc, void *proc_cls)
Enumerate all network interfaces.
Definition: os_network.c:397
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:1278
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:157
static void delete_networks(struct GNUNET_NT_InterfaceScanner *is)
Delete all entries from the current network list.
Definition: nt.c:128
#define INTERFACE_PROCESSING_INTERVAL
How frequently do we scan the interfaces for changes to the addresses?
Definition: nt.c:32
static void get_addresses(void *cls)
Periodically get list of network addresses from our interfaces.
Definition: nt.c:283

References delete_networks(), get_addresses(), GNUNET_OS_network_interfaces_list(), GNUNET_SCHEDULER_add_delayed(), interface_proc(), INTERFACE_PROCESSING_INTERVAL, and is.

Referenced by get_addresses(), and GNUNET_NT_scanner_init().

Here is the call graph for this function:
Here is the caller graph for this function: