4edf9a26d0199959f4059502faea16cddb93285d
[olsrd.git] / src / linux / net.c
1
2 /*
3  * The olsr.org Optimized Link-State Routing daemon(olsrd)
4  * Copyright (c) 2004, Andreas Tonnesen(andreto@olsr.org)
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * * Redistributions of source code must retain the above copyright
12  *   notice, this list of conditions and the following disclaimer.
13  * * Redistributions in binary form must reproduce the above copyright
14  *   notice, this list of conditions and the following disclaimer in
15  *   the documentation and/or other materials provided with the
16  *   distribution.
17  * * Neither the name of olsr.org, olsrd nor the names of its
18  *   contributors may be used to endorse or promote products derived
19  *   from this software without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
29  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
31  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32  * POSSIBILITY OF SUCH DAMAGE.
33  *
34  * Visit http://www.olsr.org for more information.
35  *
36  * If you find this software useful feel free to make a donation
37  * to the project. For more information see the website or contact
38  * the copyright holders.
39  *
40  */
41
42 /*
43  * Linux spesific code
44  */
45
46 #include "ipcalc.h"
47 #include "common/string.h"
48 #include "olsr_protocol.h"
49 #include "olsr_logging.h"
50 #include "olsr.h"
51 #include "os_kernel_tunnel.h"
52 #include "os_net.h"
53 #include "linux/linux_net.h"
54
55 #include <net/if.h>
56 #include <netinet/ip.h>
57
58 #include <sys/ioctl.h>
59 #include <sys/utsname.h>
60
61 #include <fcntl.h>
62 #include <string.h>
63 #include <stdio.h>
64 #include <syslog.h>
65 #include <unistd.h>
66
67 #define IPV6_ADDR_LOOPBACK      0x0010U
68 #define IPV6_ADDR_LINKLOCAL     0x0020U
69 #define IPV6_ADDR_SITELOCAL     0x0040U
70
71 /* ip forwarding */
72 #define PROC_IPFORWARD_V4 "/proc/sys/net/ipv4/ip_forward"
73 #define PROC_IPFORWARD_V6 "/proc/sys/net/ipv6/conf/all/forwarding"
74
75 /* Redirect proc entry */
76 #define PROC_IF_REDIRECT "/proc/sys/net/ipv4/conf/%s/send_redirects"
77 #define PROC_ALL_REDIRECT "/proc/sys/net/ipv4/conf/all/send_redirects"
78
79 /* IP spoof proc entry */
80 #define PROC_IF_SPOOF "/proc/sys/net/ipv4/conf/%s/rp_filter"
81 #define PROC_ALL_SPOOF "/proc/sys/net/ipv4/conf/all/rp_filter"
82
83
84 /* list of IPv6 interfaces */
85 #define PATH_PROCNET_IFINET6           "/proc/net/if_inet6"
86
87 /*
88  *Wireless definitions for ioctl calls
89  *(from linux/wireless.h)
90  */
91 #define SIOCGIWNAME     0x8B01  /* get name == wireless protocol */
92 #define SIOCGIWRATE     0x8B21  /* get default bit rate (bps) */
93
94 /* The original state of the IP forwarding proc entry */
95 static char orig_fwd_state;
96 static char orig_global_redirect_state;
97 static char orig_global_rp_filter;
98 static char orig_tunnel_rp_filter;
99 #if 0 // should not be necessary for IPv6 */
100 static char orig_tunnel6_rp_filter;
101 #endif
102
103 static int writeToProc(const char *file, char *old, char value) {
104   int fd;
105   char rv;
106
107   if ((fd = open(file, O_RDWR)) < 0) {
108     OLSR_WARN(LOG_INTERFACE, "Cannot open proc entry %s: %s (%d)\n", file, strerror(errno), errno);
109     return -1;
110   }
111
112   if (read(fd, &rv, 1) != 1) {
113     OLSR_WARN(LOG_INTERFACE, "Cannot read proc entry %s: %s (%d)\n", file, strerror(errno), errno);
114     return -1;
115   }
116
117   if (rv != value) {
118     if (lseek(fd, SEEK_SET, 0) == -1) {
119       OLSR_WARN(LOG_INTERFACE, "Cannot rewind proc entry %s: %s (%d)\n", file, strerror(errno), errno);
120       return -1;
121     }
122
123     if (write(fd, &value, 1) != 1) {
124       OLSR_WARN(LOG_INTERFACE, "Cannot write proc entry %s: %s (%d)\n", file, strerror(errno), errno);
125       return -1;
126     }
127   }
128
129   if (close(fd) != 0) {
130     OLSR_WARN(LOG_INTERFACE, "Cannot close proc entry %s: %s (%d)\n", file, strerror(errno), errno);
131     return -1;
132   }
133
134   if (old) {
135     *old = rv;
136   }
137   OLSR_DEBUG(LOG_INTERFACE, "Writing '%c' (was %c) to %s", value, rv, file);
138   return 0;
139 }
140
141 static bool is_at_least_linuxkernel_2_6_31(void) {
142   struct utsname uts;
143
144   memset(&uts, 0, sizeof(uts));
145   if (uname(&uts)) {
146     OLSR_WARN(LOG_NETWORKING, "Cannot not read kernel version: %s (%d)\n", strerror(errno), errno);
147     return false;
148   }
149
150   if (strncmp(uts.release, "2.6.",4) != 0) {
151     return false;
152   }
153   return atoi(&uts.release[4]) >= 31;
154 }
155
156 /**
157  * Setup global interface options (icmp redirect, ip forwarding, rp_filter)
158  * @return 1 on success 0 on failure
159  */
160 void
161 os_init_global_ifoptions(void) {
162   if (writeToProc(olsr_cnf->ip_version == AF_INET ? PROC_IPFORWARD_V4 : PROC_IPFORWARD_V6, &orig_fwd_state, '1')) {
163     OLSR_WARN(LOG_INTERFACE, "Warning, could not enable IP forwarding!\n"
164         "you should manually ensure that IP forwarding is enabled!\n\n");
165     // TODO olsr_startup_sleep(3);
166   }
167
168   if (olsr_cnf->smart_gw_active) {
169     char procfile[FILENAME_MAX];
170
171     /* Generate the procfile name */
172     if (olsr_cnf->ip_version == AF_INET || olsr_cnf->use_niit) {
173       snprintf(procfile, sizeof(procfile), PROC_IF_SPOOF, TUNNEL_ENDPOINT_IF);
174       if (writeToProc(procfile, &orig_tunnel_rp_filter, '0')) {
175         OLSR_WARN(LOG_INTERFACE, "WARNING! Could not disable the IP spoof filter for tunnel!\n"
176             "you should mannually ensure that IP spoof filtering is disabled!\n\n");
177
178         // TODO olsr_startup_sleep(3);
179       }
180     }
181   }
182
183   if (olsr_cnf->ip_version == AF_INET) {
184     if (writeToProc(PROC_ALL_REDIRECT, &orig_global_redirect_state, '0')) {
185       OLSR_WARN(LOG_INTERFACE, "WARNING! Could not disable ICMP redirects!\n"
186           "you should manually ensure that ICMP redirects are disabled!\n\n");
187
188       // TODO olsr_startup_sleep(3);
189     }
190
191     /* check kernel version and disable global rp_filter */
192     if (is_at_least_linuxkernel_2_6_31()) {
193       if (writeToProc(PROC_ALL_SPOOF, &orig_global_rp_filter, '0')) {
194         OLSR_WARN(LOG_INTERFACE, "WARNING! Could not disable global rp_filter (necessary for kernel 2.6.31 and higher!\n"
195             "you should manually ensure that rp_filter is disabled!\n\n");
196
197         // TODO olsr_startup_sleep(3);
198       }
199     }
200   }
201   return;
202 }
203
204 /**
205  *
206  *@return 1 on sucess 0 on failiure
207  */
208 int
209 net_os_set_ifoptions(const char *if_name, struct interface *iface)
210 {
211   char procfile[FILENAME_MAX];
212   if (olsr_cnf->ip_version == AF_INET6)
213     return -1;
214
215   /* Generate the procfile name */
216   snprintf(procfile, sizeof(procfile), PROC_IF_REDIRECT, if_name);
217
218   if (writeToProc(procfile, &iface->nic_state.redirect, '0')) {
219     OLSR_WARN(LOG_INTERFACE, "WARNING! Could not disable ICMP redirects!\n"
220         "you should mannually ensure that ICMP redirects are disabled!\n\n");
221     // TODO olsr_startup_sleep(3);
222     return 0;
223   }
224
225   /* Generate the procfile name */
226   snprintf(procfile, sizeof(procfile), PROC_IF_SPOOF, if_name);
227
228   if (writeToProc(procfile, &iface->nic_state.spoof, '0')) {
229     OLSR_WARN(LOG_INTERFACE, "WARNING! Could not disable the IP spoof filter!\n"
230         "you should mannually ensure that IP spoof filtering is disabled!\n\n");
231
232     // TODO olsr_startup_sleep(3);
233     return 0;
234   }
235   return 1;
236 }
237
238 void net_os_restore_ifoption(struct interface *ifs) {
239   char procfile[FILENAME_MAX];
240
241   /* ICMP redirects */
242   snprintf(procfile, sizeof(procfile), PROC_IF_REDIRECT, ifs->int_name);
243   if (writeToProc(procfile, NULL, ifs->nic_state.redirect)) {
244     OLSR_WARN(LOG_INTERFACE, "Could not restore icmp_redirect for interface %s\n", ifs->int_name);
245   }
246
247   /* Spoof filter */
248   sprintf(procfile, PROC_IF_SPOOF, ifs->int_name);
249   if (writeToProc(procfile, NULL, ifs->nic_state.spoof)) {
250     OLSR_WARN(LOG_INTERFACE, "Could not restore rp_filter for interface %s\n", ifs->int_name);
251   }
252 }
253 /**
254  *Resets the spoof filter and ICMP redirect settings
255  */
256 void
257 os_cleanup_global_ifoptions(void)
258 {
259   char procfile[FILENAME_MAX];
260   OLSR_DEBUG(LOG_INTERFACE, "Restoring network state\n");
261
262   /* Restore IP forwarding to "off" */
263   if (writeToProc(olsr_cnf->ip_version == AF_INET ? PROC_IPFORWARD_V4 : PROC_IPFORWARD_V6, NULL, orig_fwd_state)) {
264     OLSR_WARN(LOG_INTERFACE, "Could not restore ip_forward settings\n");
265   }
266
267   if (olsr_cnf->smart_gw_active && (olsr_cnf->ip_version == AF_INET || olsr_cnf->use_niit)) {
268     /* Generate the procfile name */
269     snprintf(procfile, sizeof(procfile), PROC_IF_SPOOF, TUNNEL_ENDPOINT_IF);
270     if (writeToProc(procfile, NULL, orig_tunnel_rp_filter)) {
271       OLSR_WARN(LOG_INTERFACE, "WARNING! Could not restore the IP spoof filter for tunnel!\n");
272     }
273   }
274
275   if (olsr_cnf->ip_version == AF_INET) {
276     /* Restore global ICMP redirect setting */
277     if (writeToProc(PROC_ALL_REDIRECT, NULL, orig_global_redirect_state)) {
278       OLSR_WARN(LOG_INTERFACE, "Could not restore global icmp_redirect setting\n");
279     }
280
281     /* Restore global rp_filter setting for linux 2.6.31+ */
282     if (is_at_least_linuxkernel_2_6_31()) {
283       if (writeToProc(PROC_ALL_SPOOF, NULL, orig_global_rp_filter)) {
284         OLSR_WARN(LOG_INTERFACE, "Could not restore global rp_filter setting\n");
285       }
286     }
287   }
288 }
289
290 /**
291  *Bind a socket to a device
292  *
293  *@param sock the socket to bind
294  *@param dev_name name of the device
295  *
296  *@return negative if error
297  */
298
299 static int
300 bind_socket_to_device(int sock, const char *dev_name)
301 {
302   /*
303    *Bind to device using the SO_BINDTODEVICE flag
304    */
305   OLSR_DEBUG(LOG_NETWORKING, "Binding socket %d to device %s\n", sock, dev_name);
306   return setsockopt(sock, SOL_SOCKET, SO_BINDTODEVICE, dev_name, strlen(dev_name) + 1);
307 }
308
309
310 /**
311  *Creates a nonblocking broadcast socket.
312  *@param sa sockaddr struct. Used for bind(2).
313  *@return the FD of the socket or -1 on error.
314  */
315 int
316 os_getsocket4(const char *if_name, uint16_t port, int bufspace, union olsr_sockaddr *bindto)
317 {
318   struct sockaddr_in sin4;
319   int on;
320   int sock = socket(AF_INET, SOCK_DGRAM, 0);
321   if (sock < 0) {
322     OLSR_ERROR(LOG_NETWORKING, "Cannot open socket for OLSR PDUs (%s)\n", strerror(errno));
323     olsr_exit(EXIT_FAILURE);
324   }
325
326   on = 1;
327 #ifdef SO_BROADCAST
328   if (setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on)) < 0) {
329     OLSR_ERROR(LOG_NETWORKING, "Cannot set socket for OLSR PDUs to broadcast mode (%s)\n", strerror(errno));
330     close(sock);
331     olsr_exit(EXIT_FAILURE);
332   }
333 #endif
334
335   if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0) {
336     OLSR_ERROR(LOG_NETWORKING, "Cannot reuse address for OLSR PDUs (%s)\n", strerror(errno));
337     close(sock);
338     olsr_exit(EXIT_FAILURE);
339   }
340 #ifdef SO_RCVBUF
341   if(bufspace > 0) {
342     for (on = bufspace;; on -= 1024) {
343       if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF, &on, sizeof(on)) == 0) {
344         OLSR_DEBUG(LOG_NETWORKING, "Set socket buffer space to %d\n", on);
345         break;
346       }
347       if (on <= 8 * 1024) {
348         OLSR_WARN(LOG_NETWORKING, "Could not set a socket buffer space for OLSR PDUs (%s)\n", strerror(errno));
349         break;
350       }
351     }
352   }
353 #endif
354
355   /*
356    * WHEN USING KERNEL 2.6 THIS MUST HAPPEN PRIOR TO THE PORT BINDING!!!!
357    */
358
359   /* Bind to device */
360   if (bind_socket_to_device(sock, if_name) < 0) {
361     OLSR_ERROR(LOG_NETWORKING, "Cannot bind socket for OLSR PDUs to interface %s: %s (%d)\n", if_name, strerror(errno), errno);
362     close(sock);
363     olsr_exit(EXIT_FAILURE);
364   }
365
366   if (bindto == NULL) {
367     memset(&sin4, 0, sizeof(sin4));
368     sin4.sin_family = AF_INET;
369     sin4.sin_port = htons(port);
370     sin4.sin_addr.s_addr = 0;
371     bindto = (union olsr_sockaddr *)&sin4;
372   }
373   if (bind(sock, &bindto->std, sizeof(*bindto)) < 0) {
374     OLSR_ERROR(LOG_NETWORKING, "Coult not bind socket for OLSR PDUs to port (%s)\n", strerror(errno));
375     close(sock);
376     olsr_exit(EXIT_FAILURE);
377   }
378
379   os_socket_set_nonblocking(sock);
380   return sock;
381 }
382
383
384 /**
385  *Creates a nonblocking IPv6 socket
386  *@param sin sockaddr_in6 struct. Used for bind(2).
387  *@return the FD of the socket or -1 on error.
388  */
389 int
390 os_getsocket6(const char *if_name, uint16_t port, int bufspace, union olsr_sockaddr *bindto)
391 {
392   struct sockaddr_in6 sin6;
393   int on;
394   int sock = socket(AF_INET6, SOCK_DGRAM, 0);
395   if (sock < 0) {
396     OLSR_ERROR(LOG_NETWORKING, "Cannot open socket for OLSR PDUs (%s)\n", strerror(errno));
397     olsr_exit(EXIT_FAILURE);
398   }
399 #ifdef IPV6_V6ONLY
400   on = 1;
401   if (setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof(on)) < 0) {
402     OLSR_WARN(LOG_NETWORKING, "Cannot set socket for OLSR PDUs to ipv6 only (%s)\n", strerror(errno));
403   }
404 #endif
405
406
407   //#ifdef SO_BROADCAST
408   /*
409      if (setsockopt(sock, SOL_SOCKET, SO_MULTICAST, &on, sizeof(on)) < 0)
410      {
411      perror("setsockopt");
412      syslog(LOG_ERR, "setsockopt SO_BROADCAST: %m");
413      close(sock);
414      return (-1);
415      }
416    */
417   //#endif
418
419 #ifdef SO_RCVBUF
420   if(bufspace > 0) {
421     for (on = bufspace;; on -= 1024) {
422       if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF, &on, sizeof(on)) == 0) {
423         OLSR_DEBUG(LOG_NETWORKING, "Set socket buffer space to %d\n", on);
424         break;
425       }
426       if (on <= 8 * 1024) {
427         OLSR_WARN(LOG_NETWORKING, "Could not set a socket buffer space for OLSR PDUs (%s)\n", strerror(errno));
428         break;
429       }
430     }
431   }
432 #endif
433
434   on = 1;
435   if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0) {
436     OLSR_ERROR(LOG_NETWORKING, "Cannot reuse address for socket for OLSR PDUs (%s)\n", strerror(errno));
437     close(sock);
438     olsr_exit(EXIT_FAILURE);
439   }
440
441   /*
442    * we are abusing "on" here. The value is 1 which is our intended
443    * hop limit value.
444    */
445   if (setsockopt(sock, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &on, sizeof(on)) < 0) {
446     OLSR_ERROR(LOG_NETWORKING, "Cannot set multicast hops to 1 for socket for OLSR PDUs (%s)\n", strerror(errno));
447     close(sock);
448     olsr_exit(EXIT_FAILURE);
449   }
450
451
452   /*
453    * WHEN USING KERNEL 2.6 THIS MUST HAPPEN PRIOR TO THE PORT BINDING!!!!
454    */
455
456   /* Bind to device */
457   if (bind_socket_to_device(sock, if_name) < 0) {
458     OLSR_ERROR(LOG_NETWORKING, "Cannot bind socket for OLSR PDUs to interface %s: %s (%d)\n", if_name, strerror(errno), errno);
459     close(sock);
460     olsr_exit(EXIT_FAILURE);
461   }
462
463   if (bindto == NULL) {
464     memset(&sin6, 0, sizeof(sin6));
465     sin6.sin6_family = AF_INET6;
466     sin6.sin6_port = htons(port);
467     bindto = (union olsr_sockaddr *)&sin6;
468   }
469   if (bind(sock, &bindto->std, sizeof(*bindto)) < 0) {
470     OLSR_ERROR(LOG_NETWORKING, "Cannot bind socket for OLSR PDUs (%s)\n", strerror(errno));
471     close(sock);
472     olsr_exit(EXIT_FAILURE);
473   }
474
475   os_socket_set_nonblocking(sock);
476   return sock;
477 }
478
479
480 static int
481 join_mcast(struct interface *ifs, int sock)
482 {
483   /* See linux/in6.h */
484 #if !defined REMOVE_LOG_INFO
485   struct ipaddr_str buf;
486 #endif
487   struct ipv6_mreq mcastreq;
488
489   if (olsr_cnf->ip_version == AF_INET) {
490     return 0;
491   }
492   mcastreq.ipv6mr_multiaddr = ifs->int_multicast.v6.sin6_addr;
493   mcastreq.ipv6mr_interface = ifs->if_index;
494
495   OLSR_INFO(LOG_NETWORKING, "Interface %s joining multicast %s\n", ifs->int_name,
496             olsr_sockaddr_to_string(&buf, &ifs->int_multicast));
497   /* Send multicast */
498   if (setsockopt(sock, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, (char *)&mcastreq, sizeof(struct ipv6_mreq))
499       < 0) {
500     OLSR_WARN(LOG_NETWORKING, "Cannot join multicast group (%s)\n", strerror(errno));
501     return -1;
502   }
503 #if 0
504   /* Old libc fix */
505 #ifdef IPV6_JOIN_GROUP
506   /* Join reciever group */
507   if (setsockopt(sock, IPPROTO_IPV6, IPV6_JOIN_GROUP, (char *)&mcastreq, sizeof(struct ipv6_mreq))
508       < 0)
509 #else
510   /* Join reciever group */
511   if (setsockopt(sock, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, (char *)&mcastreq, sizeof(struct ipv6_mreq))
512       < 0)
513 #endif
514   {
515     perror("Join multicast send");
516     return -1;
517   }
518 #endif
519   if (setsockopt(sock, IPPROTO_IPV6, IPV6_MULTICAST_IF, (char *)&mcastreq.ipv6mr_interface, sizeof(mcastreq.ipv6mr_interface))
520       < 0) {
521     OLSR_WARN(LOG_NETWORKING, "Cannot set multicast interface (%s)\n", strerror(errno));
522     return -1;
523   }
524
525   return 0;
526 }
527
528 void
529 os_socket_set_olsr_options(struct interface * ifs, int sock) {
530   /* Set TOS */
531   int data = IPTOS_PREC(olsr_cnf->tos);
532   if (setsockopt(sock, SOL_SOCKET, SO_PRIORITY, (char *)&data, sizeof(data)) < 0) {
533     OLSR_WARN(LOG_INTERFACE, "setsockopt(SO_PRIORITY) error %s", strerror(errno));
534   }
535   data = IPTOS_TOS(olsr_cnf->tos);
536   if (setsockopt(sock, SOL_IP, IP_TOS, (char *)&data, sizeof(data)) < 0) {
537     OLSR_WARN(LOG_INTERFACE, "setsockopt(IP_TOS) error %s", strerror(errno));
538   }
539
540   join_mcast(ifs, sock);
541 }
542
543 /*
544  *From net-tools lib/interface.c
545  *
546  */
547 int
548 get_ipv6_address(char *ifname, struct sockaddr_in6 *saddr6, int addrtype6)
549 {
550   int rv = 0;
551   FILE *f = fopen(_PATH_PROCNET_IFINET6, "r");
552   if (f != NULL) {
553     char devname[IFNAMSIZ];
554     char addr6p[8][5];
555     int plen, scope, dad_status, if_idx;
556     bool found = false;
557     while (fscanf(f, "%4s%4s%4s%4s%4s%4s%4s%4s %02x %02x %02x %02x %20s\n",
558                   addr6p[0], addr6p[1], addr6p[2], addr6p[3],
559                   addr6p[4], addr6p[5], addr6p[6], addr6p[7], &if_idx, &plen, &scope, &dad_status, devname) != EOF) {
560       if (strcmp(devname, ifname) == 0) {
561         char addr6[40];
562         sprintf(addr6, "%s:%s:%s:%s:%s:%s:%s:%s",
563                 addr6p[0], addr6p[1], addr6p[2], addr6p[3], addr6p[4], addr6p[5], addr6p[6], addr6p[7]);
564
565         if (addrtype6 == OLSR_IP6T_SITELOCAL && scope == IPV6_ADDR_SITELOCAL)
566           found = true;
567         else if (addrtype6 == OLSR_IP6T_UNIQUELOCAL && scope == IPV6_ADDR_GLOBAL)
568           found = true;
569         else if (addrtype6 == OLSR_IP6T_GLOBAL && scope == IPV6_ADDR_GLOBAL)
570           found = true;
571
572         if (found) {
573           found = false;
574           if (addr6p[0][0] == 'F' || addr6p[0][0] == 'f') {
575             if (addr6p[0][1] == 'C' || addr6p[0][1] == 'c' || addr6p[0][1] == 'D' || addr6p[0][1] == 'd')
576               found = true;
577           }
578           if (addrtype6 == OLSR_IP6T_SITELOCAL)
579             found = true;
580           else if (addrtype6 == OLSR_IP6T_UNIQUELOCAL && found)
581             found = true;
582           else if (addrtype6 == OLSR_IP6T_GLOBAL && !found)
583             found = true;
584           else
585             found = false;
586         }
587
588         if (found) {
589           inet_pton(AF_INET6, addr6, &saddr6->sin6_addr);
590           rv = 1;
591           break;
592         }
593       }
594     }
595     fclose(f);
596   }
597   return rv;
598 }
599
600
601 /**
602  * Wrapper for sendto(2)
603  */
604 ssize_t
605 os_sendto(int s, const void *buf, size_t len, int flags, const union olsr_sockaddr *sockaddr)
606 {
607   return sendto(s, buf, len, flags, &sockaddr->std, sizeof(*sockaddr));
608 }
609
610 /**
611  * Wrapper for recvfrom(2)
612  */
613
614 ssize_t
615 os_recvfrom(int s, void *buf, size_t len, int flags,
616     union olsr_sockaddr *sockaddr, socklen_t *socklen)
617 {
618   return recvfrom(s, buf, len, flags, &sockaddr->std, socklen);
619 }
620
621 /**
622  * Wrapper for select(2)
623  */
624
625 int
626 os_select(int nfds, fd_set * readfds, fd_set * writefds, fd_set * exceptfds, struct timeval *timeout)
627 {
628   return select(nfds, readfds, writefds, exceptfds, timeout);
629 }
630
631 bool os_is_interface_up(const char * dev)
632 {
633   struct ifreq ifr;
634
635   memset(&ifr, 0, sizeof(ifr));
636   strscpy(ifr.ifr_name, dev, IFNAMSIZ);
637
638   if (ioctl(olsr_cnf->ioctl_s, SIOCGIFFLAGS, &ifr) < 0) {
639     OLSR_WARN(LOG_INTERFACE, "ioctl SIOCGIFFLAGS (get flags) error on device %s: %s (%d)\n",
640         dev, strerror(errno), errno);
641     return 1;
642   }
643   return (ifr.ifr_flags & IFF_UP) != 0;
644 }
645
646 int os_interface_set_state(const char *dev, bool up) {
647   int oldflags;
648   struct ifreq ifr;
649
650   memset(&ifr, 0, sizeof(ifr));
651   strscpy(ifr.ifr_name, dev, IFNAMSIZ);
652
653   if (ioctl(olsr_cnf->ioctl_s, SIOCGIFFLAGS, &ifr) < 0) {
654     OLSR_WARN(LOG_INTERFACE, "ioctl SIOCGIFFLAGS (get flags) error on device %s: %s (%d)\n",
655         dev, strerror(errno), errno);
656     return 1;
657   }
658
659   oldflags = ifr.ifr_flags;
660   if (up) {
661     ifr.ifr_flags |= IFF_UP;
662   }
663   else {
664     ifr.ifr_flags &= ~IFF_UP;
665   }
666
667   if (oldflags == ifr.ifr_flags) {
668     /* interface is already up/down */
669     return 0;
670   }
671
672   if (ioctl(olsr_cnf->ioctl_s, SIOCSIFFLAGS, &ifr) < 0) {
673     OLSR_WARN(LOG_INTERFACE, "ioctl SIOCSIFFLAGS (set flags %s) error on device %s: %s (%d)\n",
674         up ? "up" : "down", dev, strerror(errno), errno);
675     return 1;
676   }
677   return 0;
678 }
679
680 /*
681  * Local Variables:
682  * c-basic-offset: 2
683  * indent-tabs-mode: nil
684  * End:
685  */