aboutsummaryrefslogtreecommitdiff
path: root/src/nt/nt.c
diff options
context:
space:
mode:
authorng0 <ng0@n0.is>2019-09-08 12:33:09 +0000
committerng0 <ng0@n0.is>2019-09-08 12:33:09 +0000
commitd41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb (patch)
tree9efd18ea7d425652085ed0bd5e8e45604bc5f6b9 /src/nt/nt.c
parenta0fce305c565c0937d917a92712f15e9c5736260 (diff)
downloadgnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.tar.gz
gnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.zip
uncrustify as demanded.
Diffstat (limited to 'src/nt/nt.c')
-rw-r--r--src/nt/nt.c366
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 */
42const char * 42const char *
43GNUNET_NT_to_string (enum GNUNET_NetworkType net) 43GNUNET_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 */
71struct NT_Network 77struct 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 */
103struct GNUNET_NT_InterfaceScanner 108struct 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 */
129static void 131static void
130delete_networks (struct GNUNET_NT_InterfaceScanner *is) 132delete_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 */
158static int 160static int
159interface_proc (void *cls, 161interface_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 */
279static void 282static void
280get_addresses (void *cls) 283get_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 */
302enum GNUNET_NetworkType 305enum GNUNET_NetworkType
303GNUNET_NT_scanner_get_type (struct GNUNET_NT_InterfaceScanner *is, 306GNUNET_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 */
392struct GNUNET_NT_InterfaceScanner * 398struct GNUNET_NT_InterfaceScanner *
393GNUNET_NT_scanner_init () 399GNUNET_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 */
412void 418void
413GNUNET_NT_scanner_done (struct GNUNET_NT_InterfaceScanner *is) 419GNUNET_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