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  */