diff options
author | ng0 <ng0@n0.is> | 2019-09-08 12:33:09 +0000 |
---|---|---|
committer | ng0 <ng0@n0.is> | 2019-09-08 12:33:09 +0000 |
commit | d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb (patch) | |
tree | 9efd18ea7d425652085ed0bd5e8e45604bc5f6b9 /src/nt/nt.c | |
parent | a0fce305c565c0937d917a92712f15e9c5736260 (diff) | |
download | gnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.tar.gz gnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.zip |
uncrustify as demanded.
Diffstat (limited to 'src/nt/nt.c')
-rw-r--r-- | src/nt/nt.c | 366 |
1 files changed, 186 insertions, 180 deletions
diff --git a/src/nt/nt.c b/src/nt/nt.c index 45d24520f..696088b5b 100644 --- a/src/nt/nt.c +++ b/src/nt/nt.c | |||
@@ -16,7 +16,7 @@ | |||
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
18 | SPDX-License-Identifier: AGPL3.0-or-later | 18 | SPDX-License-Identifier: AGPL3.0-or-later |
19 | */ | 19 | */ |
20 | /** | 20 | /** |
21 | * @file nt/nt_api_scanner.c | 21 | * @file nt/nt_api_scanner.c |
22 | * @brief LAN interface scanning to determine IPs in LAN | 22 | * @brief LAN interface scanning to determine IPs in LAN |
@@ -30,7 +30,7 @@ | |||
30 | /** | 30 | /** |
31 | * How frequently do we scan the interfaces for changes to the addresses? | 31 | * How frequently do we scan the interfaces for changes to the addresses? |
32 | */ | 32 | */ |
33 | #define INTERFACE_PROCESSING_INTERVAL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 2) | 33 | #define INTERFACE_PROCESSING_INTERVAL GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 2) |
34 | 34 | ||
35 | 35 | ||
36 | /** | 36 | /** |
@@ -40,22 +40,28 @@ | |||
40 | * @return a string or NULL if invalid | 40 | * @return a string or NULL if invalid |
41 | */ | 41 | */ |
42 | const char * | 42 | const char * |
43 | GNUNET_NT_to_string (enum GNUNET_NetworkType net) | 43 | GNUNET_NT_to_string(enum GNUNET_NetworkType net) |
44 | { | 44 | { |
45 | switch (net) | 45 | switch (net) |
46 | { | 46 | { |
47 | case GNUNET_NT_UNSPECIFIED: | 47 | case GNUNET_NT_UNSPECIFIED: |
48 | return "UNSPECIFIED"; | 48 | return "UNSPECIFIED"; |
49 | |||
49 | case GNUNET_NT_LOOPBACK: | 50 | case GNUNET_NT_LOOPBACK: |
50 | return "LOOPBACK"; | 51 | return "LOOPBACK"; |
52 | |||
51 | case GNUNET_NT_LAN: | 53 | case GNUNET_NT_LAN: |
52 | return "LAN"; | 54 | return "LAN"; |
55 | |||
53 | case GNUNET_NT_WAN: | 56 | case GNUNET_NT_WAN: |
54 | return "WAN"; | 57 | return "WAN"; |
58 | |||
55 | case GNUNET_NT_WLAN: | 59 | case GNUNET_NT_WLAN: |
56 | return "WLAN"; | 60 | return "WLAN"; |
61 | |||
57 | case GNUNET_NT_BT: | 62 | case GNUNET_NT_BT: |
58 | return "BLUETOOTH"; | 63 | return "BLUETOOTH"; |
64 | |||
59 | default: | 65 | default: |
60 | return NULL; | 66 | return NULL; |
61 | } | 67 | } |
@@ -68,8 +74,7 @@ GNUNET_NT_to_string (enum GNUNET_NetworkType net) | |||
68 | * (maybe we can do that heuristically based on interface | 74 | * (maybe we can do that heuristically based on interface |
69 | * name in the future?). | 75 | * name in the future?). |
70 | */ | 76 | */ |
71 | struct NT_Network | 77 | struct NT_Network { |
72 | { | ||
73 | /** | 78 | /** |
74 | * Kept in a DLL. | 79 | * Kept in a DLL. |
75 | */ | 80 | */ |
@@ -100,9 +105,7 @@ struct NT_Network | |||
100 | /** | 105 | /** |
101 | * Handle to the interface scanner. | 106 | * Handle to the interface scanner. |
102 | */ | 107 | */ |
103 | struct GNUNET_NT_InterfaceScanner | 108 | struct GNUNET_NT_InterfaceScanner { |
104 | { | ||
105 | |||
106 | /** | 109 | /** |
107 | * Head of LAN networks list. | 110 | * Head of LAN networks list. |
108 | */ | 111 | */ |
@@ -117,7 +120,6 @@ struct GNUNET_NT_InterfaceScanner | |||
117 | * Task for periodically refreshing our LAN network list. | 120 | * Task for periodically refreshing our LAN network list. |
118 | */ | 121 | */ |
119 | struct GNUNET_SCHEDULER_Task *interface_task; | 122 | struct GNUNET_SCHEDULER_Task *interface_task; |
120 | |||
121 | }; | 123 | }; |
122 | 124 | ||
123 | 125 | ||
@@ -127,17 +129,17 @@ struct GNUNET_NT_InterfaceScanner | |||
127 | * @param is scanner to clean up | 129 | * @param is scanner to clean up |
128 | */ | 130 | */ |
129 | static void | 131 | static void |
130 | delete_networks (struct GNUNET_NT_InterfaceScanner *is) | 132 | delete_networks(struct GNUNET_NT_InterfaceScanner *is) |
131 | { | 133 | { |
132 | struct NT_Network *cur; | 134 | struct NT_Network *cur; |
133 | 135 | ||
134 | while (NULL != (cur = is->net_head)) | 136 | while (NULL != (cur = is->net_head)) |
135 | { | 137 | { |
136 | GNUNET_CONTAINER_DLL_remove (is->net_head, | 138 | GNUNET_CONTAINER_DLL_remove(is->net_head, |
137 | is->net_tail, | 139 | is->net_tail, |
138 | cur); | 140 | cur); |
139 | GNUNET_free (cur); | 141 | GNUNET_free(cur); |
140 | } | 142 | } |
141 | } | 143 | } |
142 | 144 | ||
143 | 145 | ||
@@ -156,116 +158,117 @@ delete_networks (struct GNUNET_NT_InterfaceScanner *is) | |||
156 | * @return #GNUNET_OK to continue iteration | 158 | * @return #GNUNET_OK to continue iteration |
157 | */ | 159 | */ |
158 | static int | 160 | static int |
159 | interface_proc (void *cls, | 161 | interface_proc(void *cls, |
160 | const char *name, | 162 | const char *name, |
161 | int isDefault, | 163 | int isDefault, |
162 | const struct sockaddr *addr, | 164 | const struct sockaddr *addr, |
163 | const struct sockaddr *broadcast_addr, | 165 | const struct sockaddr *broadcast_addr, |
164 | const struct sockaddr *netmask, | 166 | const struct sockaddr *netmask, |
165 | socklen_t addrlen) | 167 | socklen_t addrlen) |
166 | { | 168 | { |
167 | struct GNUNET_NT_InterfaceScanner *is = cls; | 169 | struct GNUNET_NT_InterfaceScanner *is = cls; |
168 | /* Calculate network */ | 170 | /* Calculate network */ |
169 | struct NT_Network *net = NULL; | 171 | struct NT_Network *net = NULL; |
170 | (void) name; | 172 | |
171 | (void) isDefault; | 173 | (void)name; |
172 | (void) broadcast_addr; | 174 | (void)isDefault; |
175 | (void)broadcast_addr; | ||
173 | 176 | ||
174 | /* Skipping IPv4 loopback addresses since we have special check */ | 177 | /* Skipping IPv4 loopback addresses since we have special check */ |
175 | if (addr->sa_family == AF_INET) | 178 | if (addr->sa_family == AF_INET) |
176 | { | 179 | { |
177 | const struct sockaddr_in *a4 = (const struct sockaddr_in *) addr; | 180 | const struct sockaddr_in *a4 = (const struct sockaddr_in *)addr; |
178 | 181 | ||
179 | if ((a4->sin_addr.s_addr & htonl(0xff000000)) == htonl (0x7f000000)) | 182 | if ((a4->sin_addr.s_addr & htonl(0xff000000)) == htonl(0x7f000000)) |
180 | return GNUNET_OK; | 183 | return GNUNET_OK; |
181 | } | 184 | } |
182 | /* Skipping IPv6 loopback addresses since we have special check */ | 185 | /* Skipping IPv6 loopback addresses since we have special check */ |
183 | if (addr->sa_family == AF_INET6) | 186 | if (addr->sa_family == AF_INET6) |
184 | { | 187 | { |
185 | const struct sockaddr_in6 *a6 = (const struct sockaddr_in6 *) addr; | 188 | const struct sockaddr_in6 *a6 = (const struct sockaddr_in6 *)addr; |
186 | if (IN6_IS_ADDR_LOOPBACK (&a6->sin6_addr)) | 189 | if (IN6_IS_ADDR_LOOPBACK(&a6->sin6_addr)) |
187 | return GNUNET_OK; | 190 | return GNUNET_OK; |
188 | } | 191 | } |
189 | 192 | ||
190 | if (addr->sa_family == AF_INET) | 193 | if (addr->sa_family == AF_INET) |
191 | { | 194 | { |
192 | const struct sockaddr_in *addr4 = (const struct sockaddr_in *) addr; | 195 | const struct sockaddr_in *addr4 = (const struct sockaddr_in *)addr; |
193 | const struct sockaddr_in *netmask4 = (const struct sockaddr_in *) netmask; | 196 | const struct sockaddr_in *netmask4 = (const struct sockaddr_in *)netmask; |
194 | struct sockaddr_in *tmp; | 197 | struct sockaddr_in *tmp; |
195 | struct sockaddr_in network4; | 198 | struct sockaddr_in network4; |
196 | 199 | ||
197 | net = GNUNET_malloc (sizeof (struct NT_Network) + 2 * sizeof (struct sockaddr_in)); | 200 | net = GNUNET_malloc(sizeof(struct NT_Network) + 2 * sizeof(struct sockaddr_in)); |
198 | tmp = (struct sockaddr_in *) &net[1]; | 201 | tmp = (struct sockaddr_in *)&net[1]; |
199 | net->network = (struct sockaddr *) &tmp[0]; | 202 | net->network = (struct sockaddr *)&tmp[0]; |
200 | net->netmask = (struct sockaddr *) &tmp[1]; | 203 | net->netmask = (struct sockaddr *)&tmp[1]; |
201 | net->length = addrlen; | 204 | net->length = addrlen; |
202 | 205 | ||
203 | memset (&network4, | 206 | memset(&network4, |
204 | 0, | 207 | 0, |
205 | sizeof (network4)); | 208 | sizeof(network4)); |
206 | network4.sin_family = AF_INET; | 209 | network4.sin_family = AF_INET; |
207 | #if HAVE_SOCKADDR_IN_SIN_LEN | 210 | #if HAVE_SOCKADDR_IN_SIN_LEN |
208 | network4.sin_len = sizeof (network4); | 211 | network4.sin_len = sizeof(network4); |
209 | #endif | 212 | #endif |
210 | network4.sin_addr.s_addr = (addr4->sin_addr.s_addr & netmask4->sin_addr.s_addr); | 213 | network4.sin_addr.s_addr = (addr4->sin_addr.s_addr & netmask4->sin_addr.s_addr); |
211 | 214 | ||
212 | GNUNET_memcpy (net->netmask, | 215 | GNUNET_memcpy(net->netmask, |
213 | netmask4, | 216 | netmask4, |
214 | sizeof (struct sockaddr_in)); | 217 | sizeof(struct sockaddr_in)); |
215 | GNUNET_memcpy (net->network, | 218 | GNUNET_memcpy(net->network, |
216 | &network4, | 219 | &network4, |
217 | sizeof (struct sockaddr_in)); | 220 | sizeof(struct sockaddr_in)); |
218 | } | 221 | } |
219 | 222 | ||
220 | if (addr->sa_family == AF_INET6) | 223 | if (addr->sa_family == AF_INET6) |
221 | { | 224 | { |
222 | const struct sockaddr_in6 *addr6 = (const struct sockaddr_in6 *) addr; | 225 | const struct sockaddr_in6 *addr6 = (const struct sockaddr_in6 *)addr; |
223 | const struct sockaddr_in6 *netmask6 = (const struct sockaddr_in6 *) netmask; | 226 | const struct sockaddr_in6 *netmask6 = (const struct sockaddr_in6 *)netmask; |
224 | struct sockaddr_in6 * tmp; | 227 | struct sockaddr_in6 * tmp; |
225 | struct sockaddr_in6 network6; | 228 | struct sockaddr_in6 network6; |
226 | 229 | ||
227 | net = GNUNET_malloc (sizeof (struct NT_Network) + 2 * sizeof (struct sockaddr_in6)); | 230 | net = GNUNET_malloc(sizeof(struct NT_Network) + 2 * sizeof(struct sockaddr_in6)); |
228 | tmp = (struct sockaddr_in6 *) &net[1]; | 231 | tmp = (struct sockaddr_in6 *)&net[1]; |
229 | net->network = (struct sockaddr *) &tmp[0]; | 232 | net->network = (struct sockaddr *)&tmp[0]; |
230 | net->netmask = (struct sockaddr *) &tmp[1]; | 233 | net->netmask = (struct sockaddr *)&tmp[1]; |
231 | net->length = addrlen; | 234 | net->length = addrlen; |
232 | 235 | ||
233 | memset (&network6, 0, sizeof (network6)); | 236 | memset(&network6, 0, sizeof(network6)); |
234 | network6.sin6_family = AF_INET6; | 237 | network6.sin6_family = AF_INET6; |
235 | #if HAVE_SOCKADDR_IN_SIN_LEN | 238 | #if HAVE_SOCKADDR_IN_SIN_LEN |
236 | network6.sin6_len = sizeof (network6); | 239 | network6.sin6_len = sizeof(network6); |
237 | #endif | 240 | #endif |
238 | unsigned int c = 0; | 241 | unsigned int c = 0; |
239 | uint32_t *addr_elem = (uint32_t *) &addr6->sin6_addr; | 242 | uint32_t *addr_elem = (uint32_t *)&addr6->sin6_addr; |
240 | uint32_t *mask_elem = (uint32_t *) &netmask6->sin6_addr; | 243 | uint32_t *mask_elem = (uint32_t *)&netmask6->sin6_addr; |
241 | uint32_t *net_elem = (uint32_t *) &network6.sin6_addr; | 244 | uint32_t *net_elem = (uint32_t *)&network6.sin6_addr; |
242 | for (c = 0; c < 4; c++) | 245 | for (c = 0; c < 4; c++) |
243 | net_elem[c] = addr_elem[c] & mask_elem[c]; | 246 | net_elem[c] = addr_elem[c] & mask_elem[c]; |
244 | 247 | ||
245 | GNUNET_memcpy (net->netmask, | 248 | GNUNET_memcpy(net->netmask, |
246 | netmask6, | 249 | netmask6, |
247 | sizeof (struct sockaddr_in6)); | 250 | sizeof(struct sockaddr_in6)); |
248 | GNUNET_memcpy (net->network, | 251 | GNUNET_memcpy(net->network, |
249 | &network6, | 252 | &network6, |
250 | sizeof (struct sockaddr_in6)); | 253 | sizeof(struct sockaddr_in6)); |
251 | } | 254 | } |
252 | if (NULL == net) | 255 | if (NULL == net) |
253 | return GNUNET_OK; /* odd / unsupported address family */ | 256 | return GNUNET_OK; /* odd / unsupported address family */ |
254 | 257 | ||
255 | /* Store in list */ | 258 | /* Store in list */ |
256 | #if VERBOSE_NT | 259 | #if VERBOSE_NT |
257 | char * netmask = GNUNET_strdup (GNUNET_a2s((struct sockaddr *) net->netmask, addrlen)); | 260 | char * netmask = GNUNET_strdup(GNUNET_a2s((struct sockaddr *)net->netmask, addrlen)); |
258 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, | 261 | GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, |
259 | "nt", | 262 | "nt", |
260 | "Adding network `%s', netmask `%s'\n", | 263 | "Adding network `%s', netmask `%s'\n", |
261 | GNUNET_a2s ((struct sockaddr *) net->network, | 264 | GNUNET_a2s((struct sockaddr *)net->network, |
262 | addrlen), | 265 | addrlen), |
263 | netmask); | 266 | netmask); |
264 | GNUNET_free (netmask); | 267 | GNUNET_free(netmask); |
265 | #endif | 268 | #endif |
266 | GNUNET_CONTAINER_DLL_insert (is->net_head, | 269 | GNUNET_CONTAINER_DLL_insert(is->net_head, |
267 | is->net_tail, | 270 | is->net_tail, |
268 | net); | 271 | net); |
269 | 272 | ||
270 | return GNUNET_OK; | 273 | return GNUNET_OK; |
271 | } | 274 | } |
@@ -277,17 +280,17 @@ interface_proc (void *cls, | |||
277 | * @param cls closure | 280 | * @param cls closure |
278 | */ | 281 | */ |
279 | static void | 282 | static void |
280 | get_addresses (void *cls) | 283 | get_addresses(void *cls) |
281 | { | 284 | { |
282 | struct GNUNET_NT_InterfaceScanner *is = cls; | 285 | struct GNUNET_NT_InterfaceScanner *is = cls; |
283 | 286 | ||
284 | is->interface_task = NULL; | 287 | is->interface_task = NULL; |
285 | delete_networks (is); | 288 | delete_networks(is); |
286 | GNUNET_OS_network_interfaces_list (&interface_proc, | 289 | GNUNET_OS_network_interfaces_list(&interface_proc, |
287 | is); | 290 | is); |
288 | is->interface_task = GNUNET_SCHEDULER_add_delayed (INTERFACE_PROCESSING_INTERVAL, | 291 | is->interface_task = GNUNET_SCHEDULER_add_delayed(INTERFACE_PROCESSING_INTERVAL, |
289 | &get_addresses, | 292 | &get_addresses, |
290 | is); | 293 | is); |
291 | } | 294 | } |
292 | 295 | ||
293 | 296 | ||
@@ -300,9 +303,9 @@ get_addresses (void *cls) | |||
300 | * @return type of the network the address belongs to | 303 | * @return type of the network the address belongs to |
301 | */ | 304 | */ |
302 | enum GNUNET_NetworkType | 305 | enum GNUNET_NetworkType |
303 | GNUNET_NT_scanner_get_type (struct GNUNET_NT_InterfaceScanner *is, | 306 | GNUNET_NT_scanner_get_type(struct GNUNET_NT_InterfaceScanner *is, |
304 | const struct sockaddr *addr, | 307 | const struct sockaddr *addr, |
305 | socklen_t addrlen) | 308 | socklen_t addrlen) |
306 | { | 309 | { |
307 | struct NT_Network *cur = is->net_head; | 310 | struct NT_Network *cur = is->net_head; |
308 | enum GNUNET_NetworkType type = GNUNET_NT_UNSPECIFIED; | 311 | enum GNUNET_NetworkType type = GNUNET_NT_UNSPECIFIED; |
@@ -312,74 +315,77 @@ GNUNET_NT_scanner_get_type (struct GNUNET_NT_InterfaceScanner *is, | |||
312 | case AF_UNIX: | 315 | case AF_UNIX: |
313 | type = GNUNET_NT_LOOPBACK; | 316 | type = GNUNET_NT_LOOPBACK; |
314 | break; | 317 | break; |
318 | |||
315 | case AF_INET: | 319 | case AF_INET: |
316 | { | 320 | { |
317 | const struct sockaddr_in *a4 = (const struct sockaddr_in *) addr; | 321 | const struct sockaddr_in *a4 = (const struct sockaddr_in *)addr; |
322 | |||
323 | if ((a4->sin_addr.s_addr & htonl(0xff000000)) == htonl(0x7f000000)) | ||
324 | type = GNUNET_NT_LOOPBACK; | ||
325 | break; | ||
326 | } | ||
318 | 327 | ||
319 | if ((a4->sin_addr.s_addr & htonl(0xff000000)) == htonl (0x7f000000)) | ||
320 | type = GNUNET_NT_LOOPBACK; | ||
321 | break; | ||
322 | } | ||
323 | case AF_INET6: | 328 | case AF_INET6: |
324 | { | 329 | { |
325 | const struct sockaddr_in6 *a6 = (const struct sockaddr_in6 *) addr; | 330 | const struct sockaddr_in6 *a6 = (const struct sockaddr_in6 *)addr; |
331 | |||
332 | if (IN6_IS_ADDR_LOOPBACK(&a6->sin6_addr)) | ||
333 | type = GNUNET_NT_LOOPBACK; | ||
334 | break; | ||
335 | } | ||
326 | 336 | ||
327 | if (IN6_IS_ADDR_LOOPBACK (&a6->sin6_addr)) | ||
328 | type = GNUNET_NT_LOOPBACK; | ||
329 | break; | ||
330 | } | ||
331 | default: | 337 | default: |
332 | GNUNET_break (0); | 338 | GNUNET_break(0); |
333 | break; | 339 | break; |
334 | } | 340 | } |
335 | 341 | ||
336 | /* Check local networks */ | 342 | /* Check local networks */ |
337 | while ((NULL != cur) && (GNUNET_NT_UNSPECIFIED == type)) | 343 | while ((NULL != cur) && (GNUNET_NT_UNSPECIFIED == type)) |
338 | { | ||
339 | if (addrlen != cur->length) | ||
340 | { | 344 | { |
345 | if (addrlen != cur->length) | ||
346 | { | ||
347 | cur = cur->next; | ||
348 | continue; | ||
349 | } | ||
350 | if (addr->sa_family == AF_INET) | ||
351 | { | ||
352 | const struct sockaddr_in *a4 = (const struct sockaddr_in *)addr; | ||
353 | const struct sockaddr_in *net4 = (const struct sockaddr_in *)cur->network; | ||
354 | const struct sockaddr_in *mask4 = (const struct sockaddr_in *)cur->netmask; | ||
355 | |||
356 | if (((a4->sin_addr.s_addr & mask4->sin_addr.s_addr)) == net4->sin_addr.s_addr) | ||
357 | type = GNUNET_NT_LAN; | ||
358 | } | ||
359 | if (addr->sa_family == AF_INET6) | ||
360 | { | ||
361 | const struct sockaddr_in6 *a6 = (const struct sockaddr_in6 *)addr; | ||
362 | const struct sockaddr_in6 *net6 = (const struct sockaddr_in6 *)cur->network; | ||
363 | const struct sockaddr_in6 *mask6 = (const struct sockaddr_in6 *)cur->netmask; | ||
364 | |||
365 | int res = GNUNET_YES; | ||
366 | int c = 0; | ||
367 | uint32_t *addr_elem = (uint32_t *)&a6->sin6_addr; | ||
368 | uint32_t *mask_elem = (uint32_t *)&mask6->sin6_addr; | ||
369 | uint32_t *net_elem = (uint32_t *)&net6->sin6_addr; | ||
370 | for (c = 0; c < 4; c++) | ||
371 | if ((addr_elem[c] & mask_elem[c]) != net_elem[c]) | ||
372 | res = GNUNET_NO; | ||
373 | |||
374 | if (res == GNUNET_YES) | ||
375 | type = GNUNET_NT_LAN; | ||
376 | } | ||
341 | cur = cur->next; | 377 | cur = cur->next; |
342 | continue; | ||
343 | } | 378 | } |
344 | if (addr->sa_family == AF_INET) | ||
345 | { | ||
346 | const struct sockaddr_in *a4 = (const struct sockaddr_in *) addr; | ||
347 | const struct sockaddr_in *net4 = (const struct sockaddr_in *) cur->network; | ||
348 | const struct sockaddr_in *mask4 = (const struct sockaddr_in *) cur->netmask; | ||
349 | |||
350 | if (((a4->sin_addr.s_addr & mask4->sin_addr.s_addr)) == net4->sin_addr.s_addr) | ||
351 | type = GNUNET_NT_LAN; | ||
352 | } | ||
353 | if (addr->sa_family == AF_INET6) | ||
354 | { | ||
355 | const struct sockaddr_in6 *a6 = (const struct sockaddr_in6 *) addr; | ||
356 | const struct sockaddr_in6 *net6 = (const struct sockaddr_in6 *) cur->network; | ||
357 | const struct sockaddr_in6 *mask6 = (const struct sockaddr_in6 *) cur->netmask; | ||
358 | |||
359 | int res = GNUNET_YES; | ||
360 | int c = 0; | ||
361 | uint32_t *addr_elem = (uint32_t *) &a6->sin6_addr; | ||
362 | uint32_t *mask_elem = (uint32_t *) &mask6->sin6_addr; | ||
363 | uint32_t *net_elem = (uint32_t *) &net6->sin6_addr; | ||
364 | for (c = 0; c < 4; c++) | ||
365 | if ((addr_elem[c] & mask_elem[c]) != net_elem[c]) | ||
366 | res = GNUNET_NO; | ||
367 | |||
368 | if (res == GNUNET_YES) | ||
369 | type = GNUNET_NT_LAN; | ||
370 | } | ||
371 | cur = cur->next; | ||
372 | } | ||
373 | 379 | ||
374 | /* no local network found for this address, default: WAN */ | 380 | /* no local network found for this address, default: WAN */ |
375 | if (type == GNUNET_NT_UNSPECIFIED) | 381 | if (type == GNUNET_NT_UNSPECIFIED) |
376 | type = GNUNET_NT_WAN; | 382 | type = GNUNET_NT_WAN; |
377 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, | 383 | GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG, |
378 | "nt-scanner-api", | 384 | "nt-scanner-api", |
379 | "`%s' is in network `%s'\n", | 385 | "`%s' is in network `%s'\n", |
380 | GNUNET_a2s (addr, | 386 | GNUNET_a2s(addr, |
381 | addrlen), | 387 | addrlen), |
382 | GNUNET_NT_to_string (type)); | 388 | GNUNET_NT_to_string(type)); |
383 | return type; | 389 | return type; |
384 | } | 390 | } |
385 | 391 | ||
@@ -390,16 +396,16 @@ GNUNET_NT_scanner_get_type (struct GNUNET_NT_InterfaceScanner *is, | |||
390 | * @return interface scanner | 396 | * @return interface scanner |
391 | */ | 397 | */ |
392 | struct GNUNET_NT_InterfaceScanner * | 398 | struct GNUNET_NT_InterfaceScanner * |
393 | GNUNET_NT_scanner_init () | 399 | GNUNET_NT_scanner_init() |
394 | { | 400 | { |
395 | struct GNUNET_NT_InterfaceScanner *is; | 401 | struct GNUNET_NT_InterfaceScanner *is; |
396 | 402 | ||
397 | is = GNUNET_new (struct GNUNET_NT_InterfaceScanner); | 403 | is = GNUNET_new(struct GNUNET_NT_InterfaceScanner); |
398 | GNUNET_OS_network_interfaces_list (&interface_proc, | 404 | GNUNET_OS_network_interfaces_list(&interface_proc, |
399 | is); | 405 | is); |
400 | is->interface_task = GNUNET_SCHEDULER_add_delayed (INTERFACE_PROCESSING_INTERVAL, | 406 | is->interface_task = GNUNET_SCHEDULER_add_delayed(INTERFACE_PROCESSING_INTERVAL, |
401 | &get_addresses, | 407 | &get_addresses, |
402 | is); | 408 | is); |
403 | return is; | 409 | return is; |
404 | } | 410 | } |
405 | 411 | ||
@@ -410,15 +416,15 @@ GNUNET_NT_scanner_init () | |||
410 | * @param is handle to release | 416 | * @param is handle to release |
411 | */ | 417 | */ |
412 | void | 418 | void |
413 | GNUNET_NT_scanner_done (struct GNUNET_NT_InterfaceScanner *is) | 419 | GNUNET_NT_scanner_done(struct GNUNET_NT_InterfaceScanner *is) |
414 | { | 420 | { |
415 | if (NULL != is->interface_task) | 421 | if (NULL != is->interface_task) |
416 | { | 422 | { |
417 | GNUNET_SCHEDULER_cancel (is->interface_task); | 423 | GNUNET_SCHEDULER_cancel(is->interface_task); |
418 | is->interface_task = NULL; | 424 | is->interface_task = NULL; |
419 | } | 425 | } |
420 | delete_networks (is); | 426 | delete_networks(is); |
421 | GNUNET_free (is); | 427 | GNUNET_free(is); |
422 | } | 428 | } |
423 | 429 | ||
424 | 430 | ||