Fix handling of alias interfaces
[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   char if_buf[IF_NAMESIZE];
312   char *ptr;
313
314   strscpy(if_buf, dev_name, sizeof(if_buf));
315   ptr = strchr(if_buf, ':');
316   if (ptr) {
317     *ptr = 0;
318   }
319
320   /*
321    *Bind to device using the SO_BINDTODEVICE flag
322    */
323   OLSR_DEBUG(LOG_NETWORKING, "Binding socket %d to device %s\n", sock, dev_name);
324   return setsockopt(sock, SOL_SOCKET, SO_BINDTODEVICE, ptr, strlen(ptr) + 1);
325 }
326
327
328 /**
329  *Creates a nonblocking broadcast socket.
330  *@param sa sockaddr struct. Used for bind(2).
331  *@return the FD of the socket or -1 on error.
332  */
333 int
334 os_getsocket4(const char *if_name, uint16_t port, int bufspace, union olsr_sockaddr *bindto)
335 {
336   struct sockaddr_in sin4;
337   int on;
338   int sock = socket(AF_INET, SOCK_DGRAM, 0);
339   if (sock < 0) {
340     OLSR_ERROR(LOG_NETWORKING, "Cannot open socket for OLSR PDUs (%s)\n", strerror(errno));
341     olsr_exit(EXIT_FAILURE);
342   }
343
344   on = 1;
345 #ifdef SO_BROADCAST
346   if (setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on)) < 0) {
347     OLSR_ERROR(LOG_NETWORKING, "Cannot set socket for OLSR PDUs to broadcast mode (%s)\n", strerror(errno));
348     close(sock);
349     olsr_exit(EXIT_FAILURE);
350   }
351 #endif
352
353   if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0) {
354     OLSR_ERROR(LOG_NETWORKING, "Cannot reuse address for OLSR PDUs (%s)\n", strerror(errno));
355     close(sock);
356     olsr_exit(EXIT_FAILURE);
357   }
358 #ifdef SO_RCVBUF
359   if(bufspace > 0) {
360     for (on = bufspace;; on -= 1024) {
361       if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF, &on, sizeof(on)) == 0) {
362         OLSR_DEBUG(LOG_NETWORKING, "Set socket buffer space to %d\n", on);
363         break;
364       }
365       if (on <= 8 * 1024) {
366         OLSR_WARN(LOG_NETWORKING, "Could not set a socket buffer space for OLSR PDUs (%s)\n", strerror(errno));
367         break;
368       }
369     }
370   }
371 #endif
372
373   /*
374    * WHEN USING KERNEL 2.6 THIS MUST HAPPEN PRIOR TO THE PORT BINDING!!!!
375    */
376
377   /* Bind to device */
378   if (bind_socket_to_device(sock, if_name) < 0) {
379     OLSR_ERROR(LOG_NETWORKING, "Cannot bind socket for OLSR PDUs to interface %s: %s (%d)\n", if_name, strerror(errno), errno);
380     close(sock);
381     olsr_exit(EXIT_FAILURE);
382   }
383
384   if (bindto == NULL) {
385     memset(&sin4, 0, sizeof(sin4));
386     sin4.sin_family = AF_INET;
387     sin4.sin_port = htons(port);
388     sin4.sin_addr.s_addr = 0;
389     bindto = (union olsr_sockaddr *)&sin4;
390   }
391   if (bind(sock, &bindto->std, sizeof(*bindto)) < 0) {
392 #if !defined(REMOVE_LOG_ERROR)
393     struct ipaddr_str buf;
394 #endif
395     OLSR_ERROR(LOG_NETWORKING, "Could not bind socket for OLSR PDUs to %s/%d: %s (%d)\n",
396         inet_ntop(AF_INET, &sin4.sin_addr, buf.buf, sizeof(buf)), port, strerror(errno), errno);
397     close(sock);
398     olsr_exit(EXIT_FAILURE);
399   }
400
401   os_socket_set_nonblocking(sock);
402   return sock;
403 }
404
405
406 /**
407  *Creates a nonblocking IPv6 socket
408  *@param sin sockaddr_in6 struct. Used for bind(2).
409  *@return the FD of the socket or -1 on error.
410  */
411 int
412 os_getsocket6(const char *if_name, uint16_t port, int bufspace, union olsr_sockaddr *bindto)
413 {
414   struct sockaddr_in6 sin6;
415   int on;
416   int sock = socket(AF_INET6, SOCK_DGRAM, 0);
417   if (sock < 0) {
418     OLSR_ERROR(LOG_NETWORKING, "Cannot open socket for OLSR PDUs (%s)\n", strerror(errno));
419     olsr_exit(EXIT_FAILURE);
420   }
421 #ifdef IPV6_V6ONLY
422   on = 1;
423   if (setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof(on)) < 0) {
424     OLSR_WARN(LOG_NETWORKING, "Cannot set socket for OLSR PDUs to ipv6 only (%s)\n", strerror(errno));
425   }
426 #endif
427
428
429   //#ifdef SO_BROADCAST
430   /*
431      if (setsockopt(sock, SOL_SOCKET, SO_MULTICAST, &on, sizeof(on)) < 0)
432      {
433      perror("setsockopt");
434      syslog(LOG_ERR, "setsockopt SO_BROADCAST: %m");
435      close(sock);
436      return (-1);
437      }
438    */
439   //#endif
440
441 #ifdef SO_RCVBUF
442   if(bufspace > 0) {
443     for (on = bufspace;; on -= 1024) {
444       if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF, &on, sizeof(on)) == 0) {
445         OLSR_DEBUG(LOG_NETWORKING, "Set socket buffer space to %d\n", on);
446         break;
447       }
448       if (on <= 8 * 1024) {
449         OLSR_WARN(LOG_NETWORKING, "Could not set a socket buffer space for OLSR PDUs (%s)\n", strerror(errno));
450         break;
451       }
452     }
453   }
454 #endif
455
456   on = 1;
457   if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0) {
458     OLSR_ERROR(LOG_NETWORKING, "Cannot reuse address for socket for OLSR PDUs (%s)\n", strerror(errno));
459     close(sock);
460     olsr_exit(EXIT_FAILURE);
461   }
462
463   /*
464    * we are abusing "on" here. The value is 1 which is our intended
465    * hop limit value.
466    */
467   if (setsockopt(sock, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &on, sizeof(on)) < 0) {
468     OLSR_ERROR(LOG_NETWORKING, "Cannot set multicast hops to 1 for socket for OLSR PDUs (%s)\n", strerror(errno));
469     close(sock);
470     olsr_exit(EXIT_FAILURE);
471   }
472
473
474   /*
475    * WHEN USING KERNEL 2.6 THIS MUST HAPPEN PRIOR TO THE PORT BINDING!!!!
476    */
477
478   /* Bind to device */
479   if (bind_socket_to_device(sock, if_name) < 0) {
480     OLSR_ERROR(LOG_NETWORKING, "Cannot bind socket for OLSR PDUs to interface %s: %s (%d)\n", if_name, strerror(errno), errno);
481     close(sock);
482     olsr_exit(EXIT_FAILURE);
483   }
484
485   if (bindto == NULL) {
486     memset(&sin6, 0, sizeof(sin6));
487     sin6.sin6_family = AF_INET6;
488     sin6.sin6_port = htons(port);
489     bindto = (union olsr_sockaddr *)&sin6;
490   }
491   if (bind(sock, &bindto->std, sizeof(*bindto)) < 0) {
492     OLSR_ERROR(LOG_NETWORKING, "Cannot bind socket for OLSR PDUs (%s)\n", strerror(errno));
493     close(sock);
494     olsr_exit(EXIT_FAILURE);
495   }
496
497   os_socket_set_nonblocking(sock);
498   return sock;
499 }
500
501
502 static int
503 join_mcast(struct interface *ifs, int sock, union olsr_sockaddr *mcast_socket) {
504   /* See linux/in6.h */
505 #if !defined REMOVE_LOG_INFO
506   struct ipaddr_str buf1, buf2;
507 #endif
508   struct ip_mreq   v4_mreq;
509   struct ipv6_mreq v6_mreq;
510   char p;
511
512   OLSR_INFO(LOG_NETWORKING, "Interface %s joining multicast %s (src %s)\n", ifs->int_name,
513       olsr_sockaddr_to_string(&buf1, mcast_socket),
514       olsr_sockaddr_to_string(&buf2, &ifs->int_src));
515
516   if (olsr_cnf->ip_version == AF_INET) {
517     if (!IN_MULTICAST(ntohl(mcast_socket->v4.sin_addr.s_addr))) {
518       return 0;
519     }
520
521     v4_mreq.imr_multiaddr = mcast_socket->v4.sin_addr;
522     v4_mreq.imr_interface = ifs->int_src.v4.sin_addr;
523
524     if (setsockopt(sock, IPPROTO_IP, IP_ADD_MEMBERSHIP,
525         &v4_mreq, sizeof(v4_mreq)) < 0) {
526       OLSR_WARN(LOG_NETWORKING, "Cannot join multicast group (%s)\n", strerror(errno));
527       return -1;
528     }
529     if (setsockopt(sock, IPPROTO_IP, IP_MULTICAST_IF,
530         &ifs->int_src, sizeof(ifs->int_src.v4)) < 0) {
531       OLSR_WARN(LOG_NETWORKING, "Cannot set multicast interface (%s)\n", strerror(errno));
532       return -1;
533     }
534
535     p = 0;
536     if(setsockopt(sock, IPPROTO_IP, IP_MULTICAST_LOOP, (char *)&p, sizeof(p)) < 0) {
537       OLSR_WARN(LOG_NETWORKING, "Cannot deactivate local loop of multicast interface (%s)\n",
538           strerror(errno));
539       return -1;
540     }
541   }
542   else {
543     v6_mreq.ipv6mr_multiaddr = mcast_socket->v6.sin6_addr;
544     v6_mreq.ipv6mr_interface = ifs->if_index;
545
546     /* Send multicast */
547     if (setsockopt(sock, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP,
548         &v6_mreq, sizeof(v6_mreq)) < 0) {
549       OLSR_WARN(LOG_NETWORKING, "Cannot join multicast group (%s)\n", strerror(errno));
550       return -1;
551     }
552     if (setsockopt(sock, IPPROTO_IPV6, IPV6_MULTICAST_IF,
553         &ifs->if_index, sizeof(ifs->if_index)) < 0) {
554       OLSR_WARN(LOG_NETWORKING, "Cannot set multicast interface (%s)\n", strerror(errno));
555       return -1;
556     }
557     p = 0;
558     if(setsockopt(sock, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, (char *)&p, sizeof(p)) < 0) {
559       OLSR_WARN(LOG_NETWORKING, "Cannot deactivate local loop of multicast interface (%s)\n",
560           strerror(errno));
561       return -1;
562     }
563   }
564   return 0;
565 }
566
567 void
568 os_socket_set_olsr_options(struct interface * ifs, int sock, union olsr_sockaddr *mcast) {
569   /* Set TOS */
570   int data = IPTOS_PREC(olsr_cnf->tos);
571   if (setsockopt(sock, SOL_SOCKET, SO_PRIORITY, (char *)&data, sizeof(data)) < 0) {
572     OLSR_WARN(LOG_INTERFACE, "setsockopt(SO_PRIORITY) error %s", strerror(errno));
573   }
574   data = IPTOS_TOS(olsr_cnf->tos);
575   if (setsockopt(sock, SOL_IP, IP_TOS, (char *)&data, sizeof(data)) < 0) {
576     OLSR_WARN(LOG_INTERFACE, "setsockopt(IP_TOS) error %s", strerror(errno));
577   }
578
579   if (mcast) {
580     join_mcast(ifs, sock, mcast);
581   }
582 }
583
584 /*
585  *From net-tools lib/interface.c
586  *
587  */
588 int
589 get_ipv6_address(char *ifname, struct sockaddr_in6 *saddr6, int addrtype6)
590 {
591   int rv = 0;
592   FILE *f = fopen(_PATH_PROCNET_IFINET6, "r");
593   if (f != NULL) {
594     char devname[IFNAMSIZ];
595     char addr6p[8][5];
596     int plen, scope, dad_status, if_idx;
597     bool found = false;
598     while (fscanf(f, "%4s%4s%4s%4s%4s%4s%4s%4s %02x %02x %02x %02x %20s\n",
599                   addr6p[0], addr6p[1], addr6p[2], addr6p[3],
600                   addr6p[4], addr6p[5], addr6p[6], addr6p[7], &if_idx, &plen, &scope, &dad_status, devname) != EOF) {
601       if (strcmp(devname, ifname) == 0) {
602         char addr6[40];
603         sprintf(addr6, "%s:%s:%s:%s:%s:%s:%s:%s",
604                 addr6p[0], addr6p[1], addr6p[2], addr6p[3], addr6p[4], addr6p[5], addr6p[6], addr6p[7]);
605
606         if (addrtype6 == OLSR_IP6T_SITELOCAL && scope == IPV6_ADDR_SITELOCAL)
607           found = true;
608         else if (addrtype6 == OLSR_IP6T_UNIQUELOCAL && scope == IPV6_ADDR_GLOBAL)
609           found = true;
610         else if (addrtype6 == OLSR_IP6T_GLOBAL && scope == IPV6_ADDR_GLOBAL)
611           found = true;
612
613         if (found) {
614           found = false;
615           if (addr6p[0][0] == 'F' || addr6p[0][0] == 'f') {
616             if (addr6p[0][1] == 'C' || addr6p[0][1] == 'c' || addr6p[0][1] == 'D' || addr6p[0][1] == 'd')
617               found = true;
618           }
619           if (addrtype6 == OLSR_IP6T_SITELOCAL)
620             found = true;
621           else if (addrtype6 == OLSR_IP6T_UNIQUELOCAL && found)
622             found = true;
623           else if (addrtype6 == OLSR_IP6T_GLOBAL && !found)
624             found = true;
625           else
626             found = false;
627         }
628
629         if (found) {
630           inet_pton(AF_INET6, addr6, &saddr6->sin6_addr);
631           rv = 1;
632           break;
633         }
634       }
635     }
636     fclose(f);
637   }
638   return rv;
639 }
640
641
642 /**
643  * Wrapper for sendto(2)
644  */
645 ssize_t
646 os_sendto(int s, const void *buf, size_t len, int flags, const union olsr_sockaddr *sockaddr)
647 {
648   return sendto(s, buf, len, flags, &sockaddr->std, sizeof(*sockaddr));
649 }
650
651 /**
652  * Wrapper for recvfrom(2)
653  */
654
655 ssize_t
656 os_recvfrom(int s, void *buf, size_t len, int flags,
657     union olsr_sockaddr *sockaddr, socklen_t *socklen)
658 {
659   return recvfrom(s, buf, len, flags, &sockaddr->std, socklen);
660 }
661
662 /**
663  * Wrapper for select(2)
664  */
665
666 int
667 os_select(int nfds, fd_set * readfds, fd_set * writefds, fd_set * exceptfds, struct timeval *timeout)
668 {
669   return select(nfds, readfds, writefds, exceptfds, timeout);
670 }
671
672 bool os_is_interface_up(const char * dev)
673 {
674   struct ifreq ifr;
675
676   memset(&ifr, 0, sizeof(ifr));
677   strscpy(ifr.ifr_name, dev, IFNAMSIZ);
678
679   if (ioctl(olsr_cnf->ioctl_s, SIOCGIFFLAGS, &ifr) < 0) {
680     OLSR_WARN(LOG_INTERFACE, "ioctl SIOCGIFFLAGS (get flags) error on device %s: %s (%d)\n",
681         dev, strerror(errno), errno);
682     return 1;
683   }
684   return (ifr.ifr_flags & IFF_UP) != 0;
685 }
686
687 int os_interface_set_state(const char *dev, bool up) {
688   int oldflags;
689   struct ifreq ifr;
690
691   memset(&ifr, 0, sizeof(ifr));
692   strscpy(ifr.ifr_name, dev, IFNAMSIZ);
693
694   if (ioctl(olsr_cnf->ioctl_s, SIOCGIFFLAGS, &ifr) < 0) {
695     OLSR_WARN(LOG_INTERFACE, "ioctl SIOCGIFFLAGS (get flags) error on device %s: %s (%d)\n",
696         dev, strerror(errno), errno);
697     return 1;
698   }
699
700   oldflags = ifr.ifr_flags;
701   if (up) {
702     ifr.ifr_flags |= IFF_UP;
703   }
704   else {
705     ifr.ifr_flags &= ~IFF_UP;
706   }
707
708   if (oldflags == ifr.ifr_flags) {
709     /* interface is already up/down */
710     return 0;
711   }
712
713   if (ioctl(olsr_cnf->ioctl_s, SIOCSIFFLAGS, &ifr) < 0) {
714     OLSR_WARN(LOG_INTERFACE, "ioctl SIOCSIFFLAGS (set flags %s) error on device %s: %s (%d)\n",
715         up ? "up" : "down", dev, strerror(errno), errno);
716     return 1;
717   }
718   return 0;
719 }
720
721 /*
722  * Local Variables:
723  * c-basic-offset: 2
724  * indent-tabs-mode: nil
725  * End:
726  */