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