src/linux/kernel_routes_nl.c

   1 /*
   2  * The olsr.org Optimized Link-State Routing daemon(olsrd)
   3  * Copyright (c) 2004, Andreas Tonnesen(andreto@olsr.org)
   4  * Copyright (c) 2007, Sven-Ola for the policy routing stuff
   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 #include "kernel_routes.h"
  43 #include "ipc_frontend.h"
  44 #include "log.h"
  45 #include "net_os.h"
  46 #include "ifnet.h"
  47
  48 #include <assert.h>
  49 #include <linux/types.h>
  50 #include <linux/rtnetlink.h>
  51
  52 //ipip includes
  53 #include <netinet/in.h>
  54 #include <sys/ioctl.h>
  55 #include <net/if.h>
  56 #include <linux/ip.h>
  57 #include <linux/if_tunnel.h>
  58
  59 //ifup includes
  60 #include <sys/socket.h>
  61 #include <sys/ioctl.h>
  62 #include <sys/types.h>
  63 #include <net/if.h>
  64
  65 /*
  66  * This file contains the rtnetlink version of the linux routing code.
  67  * You will find the old ioctl version in kernel_routes_ioctl.c
  68  *
  69  * You can deactivate this code (and activating the ioctl one)
  70  * by removing the -DLINUX_NETLINK_ROUTING from make/Makefile.linux
  71  */
  72 #ifdef LINUX_NETLINK_ROUTING
  73 /*
  74  * The ARM compile complains about alignment. Copied
  75  * from /usr/include/linux/netlink.h and adapted for ARM
  76  */
  77 #define MY_NLMSG_NEXT(nlh,len)   ((len) -= NLMSG_ALIGN((nlh)->nlmsg_len), \
  78           (struct nlmsghdr*)ARM_NOWARN_ALIGN((((char*)(nlh)) + NLMSG_ALIGN((nlh)->nlmsg_len)))
  79
  80
  81 static void rtnetlink_read(int sock, void *, unsigned int);
  82
  83 struct olsr_rtreq {
  84   struct nlmsghdr n;
  85   struct rtmsg r;
  86   char buf[512];
  87 };
  88
  89 struct olsr_ipadd_req {
  90   struct nlmsghdr n;
  91   struct ifaddrmsg ifa;
  92   char buf[256];
  93 };
  94
  95 int rtnetlink_register_socket(int rtnl_mgrp)
  96 {
  97   int sock = socket(AF_NETLINK,SOCK_RAW,NETLINK_ROUTE);
  98   struct sockaddr_nl addr;
  99
 100   if (sock<0) {
 101     OLSR_PRINTF(1,"could not create rtnetlink socket! %s (%d)", strerror(errno), errno);
 102     return -1;
 103   }
 104
 105   memset(&addr, 0, sizeof(addr));
 106   addr.nl_family = AF_NETLINK;
 107   addr.nl_pid = 0; //kernel will assign appropiate number instead of pid (which is already used by primaray rtnetlink socket to add/delete routes)
 108   addr.nl_groups = rtnl_mgrp;
 109
 110   if (bind(sock,(struct sockaddr *)&addr,sizeof(addr))<0) {
 111     OLSR_PRINTF(1,"could not bind rtnetlink socket! %s (%d)",strerror(errno), errno);
 112     return -1;
 113   }
 114
 115   add_olsr_socket(sock, NULL, &rtnetlink_read, NULL, SP_IMM_READ);
 116   return sock;
 117 }
 118
 119 static void netlink_process_link(struct nlmsghdr *h)
 120 {
 121   struct ifinfomsg *ifi = (struct ifinfomsg *) NLMSG_DATA(h);
 122   struct interface *iface;
 123   struct olsr_if *oif;
 124   char namebuffer[IF_NAMESIZE];
 125
 126   iface = if_ifwithindex(ifi->ifi_index);
 127   oif = NULL;
 128
 129   if (iface == NULL && (ifi->ifi_flags & (IFF_UP|IFF_RUNNING)) == (IFF_UP|IFF_RUNNING)) {
 130     if (if_indextoname(ifi->ifi_index, namebuffer)) {
 131       if ((oif = olsrif_ifwithname(namebuffer)) != NULL) {
 132         /* try to take interface up, will trigger ifchange */
 133         chk_if_up(oif, 3);
 134       }
 135     }
 136   }
 137   else if (iface != NULL && (ifi->ifi_flags & IFF_UP) == 0) {
 138     /* try to take interface down, will trigger ifchange */
 139     olsr_remove_interface(iface->olsr_if);
 140   }
 141
 142   if (iface == NULL && oif == NULL) {
 143     /* this is not an OLSR interface */
 144     if ((ifi->ifi_flags & IFF_UP) != 0 && (ifi->ifi_flags & IFF_RUNNING) != 0) {
 145       olsr_trigger_ifchange(ifi->ifi_index, NULL, IFCHG_IF_ADD);
 146     }
 147     else if ((ifi->ifi_flags & IFF_UP) == 0 && (ifi->ifi_flags & IFF_RUNNING) == 0){
 148       olsr_trigger_ifchange(ifi->ifi_index, NULL, IFCHG_IF_REMOVE);
 149     }
 150   }
 151 }
 152
 153 static void rtnetlink_read(int sock, void *data __attribute__ ((unused)), unsigned int flags __attribute__ ((unused)))
 154 {
 155   int len, plen;
 156   struct iovec iov;
 157   struct sockaddr_nl nladdr;
 158   struct msghdr msg = {
 159     &nladdr,
 160     sizeof(nladdr),
 161     &iov,
 162     1,
 163     NULL,
 164     0,
 165     0
 166   };
 167
 168   char buffer[4096];
 169   struct nlmsghdr *nlh = (struct nlmsghdr *)ARM_NOWARN_ALIGN(buffer);
 170   int ret;
 171
 172   iov.iov_base = (void *) buffer;
 173   iov.iov_len = sizeof(buffer);
 174
 175   while ((ret = recvmsg(sock, &msg, MSG_DONTWAIT)) >= 0) {
 176     /*check message*/
 177     len = nlh->nlmsg_len;
 178     plen = len - sizeof(nlh);
 179     if (len > ret || plen < 0) {
 180       OLSR_PRINTF(1,"Malformed netlink message: "
 181              "len=%d left=%d plen=%d\n",
 182               len, ret, plen);
 183       return;
 184     }
 185
 186     OLSR_PRINTF(3, "Netlink message received: type 0x%x\n", nlh->nlmsg_type);
 187     if ((nlh->nlmsg_type == RTM_NEWLINK) || ( nlh->nlmsg_type == RTM_DELLINK)) {
 188       /* handle ifup/ifdown */
 189       netlink_process_link(nlh);
 190     }
 191   }
 192
 193   if (errno != EAGAIN) {
 194     OLSR_PRINTF(1,"netlink listen error %u - %s\n",errno,strerror(errno));
 195   }
 196 }
 197
 198 static void
 199 olsr_netlink_addreq(struct nlmsghdr *n, size_t reqSize __attribute__ ((unused)), int type, const void *data, int len)
 200 {
 201   struct rtattr *rta = (struct rtattr *)ARM_NOWARN_ALIGN(((char *)n) + NLMSG_ALIGN(n->nlmsg_len));
 202   n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + RTA_LENGTH(len);
 203   //produces strange compile error
 204   //assert(n->nlmsg_len < reqSize);
 205   rta->rta_type = type;
 206   rta->rta_len = RTA_LENGTH(len);
 207   memcpy(RTA_DATA(rta), data, len);
 208 }
 209
 210 /*rt_entry and nexthop and family and table must only be specified with an flag != RT_NONE  && != RT_LO_IP*/
 211 static int
 212 olsr_netlink_send(struct nlmsghdr *nl_hdr)
 213 {
 214   char rcvbuf[1024];
 215   struct iovec iov;
 216   struct sockaddr_nl nladdr;
 217   struct msghdr msg;
 218   struct nlmsghdr *h;
 219   struct nlmsgerr *l_err;
 220   int ret;
 221
 222   memset(&nladdr, 0, sizeof(nladdr));
 223   memset(&msg, 0, sizeof(msg));
 224
 225   nladdr.nl_family = AF_NETLINK;
 226
 227   msg.msg_name = &nladdr;
 228   msg.msg_namelen = sizeof(nladdr);
 229   msg.msg_iov = &iov;
 230   msg.msg_iovlen = 1;
 231
 232   iov.iov_base = nl_hdr;
 233   iov.iov_len = nl_hdr->nlmsg_len;
 234   ret = sendmsg(olsr_cnf->rtnl_s, &msg, 0);
 235   if (ret <= 0) {
 236     olsr_syslog(OLSR_LOG_ERR, "Cannot send data to netlink socket (%d: %s)", errno, strerror(errno));
 237     return -1;
 238   }
 239
 240   iov.iov_base = rcvbuf;
 241   iov.iov_len = sizeof(rcvbuf);
 242   ret = recvmsg(olsr_cnf->rtnl_s, &msg, 0);
 243   if (ret <= 0) {
 244     olsr_syslog(OLSR_LOG_ERR, "Error while reading answer to netlink message (%d: %s)", errno, strerror(errno));
 245     return -1;
 246   }
 247
 248   h = (struct nlmsghdr *)ARM_NOWARN_ALIGN(rcvbuf);
 249   if (!NLMSG_OK(h, (unsigned int)ret)) {
 250     olsr_syslog(OLSR_LOG_ERR, "Received netlink message was malformed (ret=%d, %u)", ret, h->nlmsg_len);
 251     return -1;
 252   }
 253
 254   if (h->nlmsg_type != NLMSG_ERROR) {
 255     olsr_syslog(OLSR_LOG_INFO,
 256         "Received unknown netlink response: %u bytes, type %u (not %u) with seqnr %u and flags %u from %u",
 257         h->nlmsg_len, h->nlmsg_type, NLMSG_ERROR, h->nlmsg_seq, h->nlmsg_flags, h->nlmsg_pid);
 258     return -1;
 259   }
 260   if (NLMSG_LENGTH(sizeof(struct nlmsgerr)) > h->nlmsg_len) {
 261     olsr_syslog(OLSR_LOG_INFO,"Received invalid netlink message size %lu != %u",
 262         (unsigned long int)sizeof(struct nlmsgerr), h->nlmsg_len);
 263     return -1;
 264   }
 265
 266   l_err = (struct nlmsgerr *)NLMSG_DATA(h);
 267
 268   if (l_err->error) {
 269     olsr_syslog(OLSR_LOG_INFO,"Received netlink error code %s (%d)", strerror(-l_err->error), l_err->error);
 270   }
 271   return -l_err->error;
 272 }
 273
 274 int olsr_os_policy_rule(int family, int rttable, uint32_t priority, const char *if_name, bool set) {
 275   struct olsr_rtreq req;
 276   int err;
 277
 278   memset(&req, 0, sizeof(req));
 279
 280   req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
 281   req.n.nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE | NLM_F_EXCL | NLM_F_ACK;
 282
 283   req.n.nlmsg_type = set ? RTM_NEWRULE : RTM_DELRULE;
 284   req.r.rtm_family = family;
 285   req.r.rtm_table = rttable;
 286
 287   /* RTN_UNSPEC would be the wildcard, but blackhole broadcast or nat roules should usually not conflict */
 288   /* -> olsr only adds deletes unicast routes */
 289   req.r.rtm_type = RTN_UNICAST;
 290
 291   /* wildcard to delete routes of all protos if no simlar-delete correct proto will get set below */
 292   req.r.rtm_protocol = RTPROT_UNSPEC;
 293
 294   req.r.rtm_scope = RT_SCOPE_UNIVERSE;
 295
 296   olsr_netlink_addreq(&req.n, sizeof(req), RTA_PRIORITY, &priority, sizeof(priority));
 297
 298   if (if_name != NULL) {
 299     /*add interface name to rule*/
 300     olsr_netlink_addreq(&req.n, sizeof(req), RTA_IIF, if_name, strlen(if_name)+1);
 301   }
 302
 303   err = olsr_netlink_send(&req.n);
 304   if (err) {
 305     olsr_syslog(OLSR_LOG_ERR,"Error on %s policy rule aimed to activate RtTable %u!",
 306         set ? "inserting" : "deleting", rttable);
 307   }
 308
 309   return err;
 310 }
 311
 312 static int
 313 olsr_add_ip(int ifindex, union olsr_ip_addr *ip, const char *l, bool create)
 314 {
 315   struct olsr_ipadd_req req;
 316
 317   memset(&req, 0, sizeof(req));
 318
 319   req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
 320   if (create) {
 321    req.n.nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE | NLM_F_REPLACE | NLM_F_ACK;
 322    req.n.nlmsg_type = RTM_NEWADDR;
 323   } else {
 324    req.n.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
 325    req.n.nlmsg_type = RTM_DELADDR;
 326   }
 327   req.ifa.ifa_family = olsr_cnf->ip_version;
 328
 329   olsr_netlink_addreq(&req.n, sizeof(req), IFA_LOCAL, ip, olsr_cnf->ipsize);
 330   if (l) {
 331     olsr_netlink_addreq(&req.n, sizeof(req), IFA_LABEL, l, strlen(l) + 1);
 332   }
 333
 334   req.ifa.ifa_prefixlen = olsr_cnf->ipsize * 8;
 335
 336   req.ifa.ifa_index = ifindex;
 337
 338   return olsr_netlink_send(&req.n);
 339 }
 340
 341 int
 342 olsr_os_localhost_if(union olsr_ip_addr *ip, bool create)
 343 {
 344   static char l[] = "lo:olsr";
 345   return olsr_add_ip(if_nametoindex("lo"), ip, l, create);
 346 }
 347
 348 int olsr_os_ifip(int ifindex, union olsr_ip_addr *ip, bool create) {
 349   return olsr_add_ip(ifindex, ip, NULL, create);
 350 }
 351
 352 static int olsr_new_netlink_route(int family, int rttable, int if_index, int metric, int protocol,
 353     const union olsr_ip_addr *src, const union olsr_ip_addr *gw, const struct olsr_ip_prefix *dst,
 354     bool set, bool del_similar) {
 355
 356   struct olsr_rtreq req;
 357   int family_size;
 358   int err;
 359
 360   if (0) {
 361     struct ipaddr_str buf1, buf2;
 362
 363     olsr_syslog(OLSR_LOG_INFO, "new_netlink_route: family=%d,rttable=%d,if_index=%d,metric=%d,protocol=%d,src=%s,gw=%s,dst=%s,set=%s,del_similar=%s",
 364         family, rttable, if_index, metric, protocol, src == NULL ? "" : olsr_ip_to_string(&buf1, src),
 365         gw == NULL ? "" : olsr_ip_to_string(&buf2, gw), olsr_ip_prefix_to_string(dst),
 366         set ? "true" : "false", del_similar ? "true" : "false");
 367   }
 368   family_size = family == AF_INET ? sizeof(struct in_addr) : sizeof(struct in6_addr);
 369
 370   memset(&req, 0, sizeof(req));
 371
 372   req.r.rtm_flags = RTNH_F_ONLINK;
 373   req.r.rtm_family = family;
 374   req.r.rtm_table = rttable;
 375
 376   req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
 377   req.n.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
 378
 379   if (set) {
 380     req.n.nlmsg_flags |= NLM_F_CREATE | NLM_F_REPLACE;
 381     req.n.nlmsg_type = RTM_NEWROUTE;
 382   } else {
 383     req.n.nlmsg_type = RTM_DELROUTE;
 384   }
 385
 386   /* RTN_UNSPEC would be the wildcard, but blackhole broadcast or nat roules should usually not conflict */
 387   /* -> olsr only adds deletes unicast routes */
 388   req.r.rtm_type = RTN_UNICAST;
 389
 390   req.r.rtm_dst_len = dst->prefix_len;
 391
 392   if (set) {
 393     /* add protocol for setting a route */
 394     req.r.rtm_protocol = protocol;
 395   }
 396
 397   /* calculate scope of operation */
 398   if (!set && del_similar) {
 399     /* as wildcard for fuzzy deletion */
 400     req.r.rtm_scope = RT_SCOPE_NOWHERE;
 401   }
 402   else {
 403     /* for all our routes */
 404     req.r.rtm_scope = RT_SCOPE_UNIVERSE;
 405   }
 406
 407   if (set || !del_similar) {
 408     /* add interface*/
 409     olsr_netlink_addreq(&req.n, sizeof(req), RTA_OIF, &if_index, sizeof(if_index));
 410   }
 411
 412   if (set && src != NULL) {
 413     /* add src-ip */
 414     olsr_netlink_addreq(&req.n, sizeof(req), RTA_PREFSRC, src, family_size);
 415   }
 416
 417   if (metric != -1) {
 418     /* add metric */
 419     olsr_netlink_addreq(&req.n, sizeof(req), RTA_PRIORITY, &metric, sizeof(metric));
 420   }
 421
 422   if (gw) {
 423     /* add gateway */
 424     olsr_netlink_addreq(&req.n, sizeof(req), RTA_GATEWAY, gw, family_size);
 425   }
 426   else {
 427     /* use destination as gateway, to 'force' linux kernel to do proper source address selection */
 428     olsr_netlink_addreq(&req.n, sizeof(req), RTA_GATEWAY, &dst->prefix, family_size);
 429   }
 430
 431    /* add destination */
 432   olsr_netlink_addreq(&req.n, sizeof(req), RTA_DST, &dst->prefix, family_size);
 433
 434   err = olsr_netlink_send(&req.n);
 435   if (err) {
 436       struct ipaddr_str buf;
 437     if (gw) {
 438       olsr_syslog(OLSR_LOG_ERR, ". error: %s route to %s via %s dev %s onlink (%s %d)",
 439           set ? "add" : "del",
 440           olsr_ip_prefix_to_string(dst), olsr_ip_to_string(&buf, gw),
 441           if_ifwithindex_name(if_index), strerror(errno), errno);
 442     }
 443     else {
 444       olsr_syslog(OLSR_LOG_ERR, ". error: %s route to %s via %s dev %s onlink (%s %d)",
 445           set ? "add" : "del",
 446           olsr_ip_prefix_to_string(dst), olsr_ip_to_string(&buf, &dst->prefix), if_ifwithindex_name(if_index),
 447           strerror(errno), errno);
 448     }
 449   }
 450
 451   return err;
 452 }
 453
 454 void olsr_os_niit_6to4_route(const struct olsr_ip_prefix *dst_v6, bool set) {
 455   if (olsr_new_netlink_route(AF_INET6,
 456       ip_prefix_is_mappedv4_inetgw(dst_v6) ? olsr_cnf->rt_table_default : olsr_cnf->rt_table,
 457       olsr_cnf->niit6to4_if_index,
 458       RT_METRIC_DEFAULT, olsr_cnf->rt_proto, NULL, NULL, dst_v6, set, false)) {
 459     olsr_syslog(OLSR_LOG_ERR, ". error while %s static niit route to %s",
 460         set ? "setting" : "removing", olsr_ip_prefix_to_string(dst_v6));
 461   }
 462 }
 463
 464 void olsr_os_niit_4to6_route(const struct olsr_ip_prefix *dst_v4, bool set) {
 465   if (olsr_new_netlink_route(AF_INET,
 466       ip_prefix_is_v4_inetgw(dst_v4) ? olsr_cnf->rt_table_default : olsr_cnf->rt_table,
 467       olsr_cnf->niit4to6_if_index,
 468       RT_METRIC_DEFAULT, olsr_cnf->rt_proto, NULL, NULL, dst_v4, set, false)) {
 469     olsr_syslog(OLSR_LOG_ERR, ". error while %s niit route to %s",
 470         set ? "setting" : "removing", olsr_ip_prefix_to_string(dst_v4));
 471   }
 472 }
 473
 474 void olsr_os_inetgw_tunnel_route(uint32_t if_idx, bool ipv4, bool set) {
 475   const struct olsr_ip_prefix *dst;
 476
 477   assert(olsr_cnf->ip_version == AF_INET6 || ipv4);
 478
 479   dst = ipv4 ? &ipv4_internet_route : &ipv6_internet_route;
 480
 481   if (olsr_new_netlink_route(ipv4 ? AF_INET : AF_INET6, olsr_cnf->rt_table_tunnel,
 482       if_idx, RT_METRIC_DEFAULT, olsr_cnf->rt_proto, NULL, NULL, dst, set, false)) {
 483     olsr_syslog(OLSR_LOG_ERR, ". error while %s inetgw tunnel route to %s for if %d",
 484         set ? "setting" : "removing", olsr_ip_prefix_to_string(dst), if_idx);
 485   }
 486 }
 487
 488 static int olsr_os_process_rt_entry(int af_family, const struct rt_entry *rt, bool set) {
 489   int metric, table;
 490   const struct rt_nexthop *nexthop;
 491   union olsr_ip_addr *src;
 492   bool hostRoute;
 493   int err;
 494
 495   /* calculate metric */
 496   if (FIBM_FLAT == olsr_cnf->fib_metric) {
 497     metric = RT_METRIC_DEFAULT;
 498   }
 499   else {
 500     metric = set ? rt->rt_best->rtp_metric.hops : rt->rt_metric.hops;
 501   }
 502
 503   if (olsr_cnf->smart_gw_active && is_prefix_inetgw(&rt->rt_dst)) {
 504     /* make space for the tunnel gateway route */
 505     metric += 2;
 506   }
 507
 508   /* get table */
 509   table = is_prefix_inetgw(&rt->rt_dst)
 510       ? olsr_cnf->rt_table_default : olsr_cnf->rt_table;
 511
 512   /* get next hop */
 513   if (rt->rt_best && set) {
 514     nexthop = &rt->rt_best->rtp_nexthop;
 515   }
 516   else {
 517     nexthop = &rt->rt_nexthop;
 518   }
 519
 520   /* detect 1-hop hostroute */
 521   hostRoute = rt->rt_dst.prefix_len == olsr_cnf->ipsize * 8
 522       && ipequal(&nexthop->gateway, &rt->rt_dst.prefix);
 523
 524 #if 0
 525   {
 526     struct ipaddr_str buf1, buf2;
 527     olsr_syslog(OLSR_LOG_INFO, "hostroute (%s) = %d == %d && %s == %s",
 528         hostRoute ? "true" : "false",
 529         rt->rt_dst.prefix_len, (int)(olsr_cnf->ipsize * 8),
 530         olsr_ip_to_string(&buf1, &nexthop->gateway),
 531         olsr_ip_to_string(&buf2, &rt->rt_dst.prefix));
 532   }
 533 #endif
 534
 535   /* get src ip */
 536   if (olsr_cnf->use_src_ip_routes) {
 537     src = &olsr_cnf->unicast_src_ip;
 538   }
 539   else {
 540     src = NULL;
 541   }
 542
 543   /* create route */
 544   err = olsr_new_netlink_route(af_family, table, nexthop->iif_index, metric, olsr_cnf->rt_proto,
 545       src, hostRoute ? NULL : &nexthop->gateway, &rt->rt_dst, set, false);
 546
 547   /* resolve "File exist" (17) propblems (on orig and autogen routes)*/
 548   if (set && err == 17) {
 549     /* a similar route going over another gateway may be present, which has to be deleted! */
 550     olsr_syslog(OLSR_LOG_ERR, ". auto-deleting similar routes to resolve 'File exists' (17) while adding route!");
 551
 552     /* erase similar rule */
 553     err = olsr_new_netlink_route(af_family, table, 0, 0, -1, NULL, NULL, &rt->rt_dst, false, true);
 554
 555     if (!err) {
 556       /* create this rule a second time if delete worked*/
 557       err = olsr_new_netlink_route(af_family, table, nexthop->iif_index, metric, olsr_cnf->rt_proto,
 558           src, hostRoute ? NULL : &nexthop->gateway, &rt->rt_dst, set, false);
 559     }
 560     olsr_syslog(OLSR_LOG_ERR, ". %s (%d)", err == 0 ? "successful" : "failed", err);
 561   }
 562
 563   /* report success on "No such process" (3) */
 564   else if (!set && err == 3) {
 565     /* another similar (but slightly different) route may be present at this point,
 566      * if so this will get solved when adding new route to this destination */
 567     olsr_syslog(OLSR_LOG_ERR, ". ignoring 'No such process' (3) while deleting route!");
 568     err = 0;
 569   }
 570   /* insert route to gateway on the fly if "Network unreachable" (128) on 2.4 kernels
 571    * or on 2.6 kernel No such process (3) or Network unreachable (101) is reported in rtnetlink response
 572    * do this only with flat metric, as using metric values inherited from
 573    * a target behind the gateway is really strange, and could lead to multiple routes!
 574    * anyways if invalid gateway ips may happen we are f*cked up!!
 575    * but if not, these on the fly generated routes are no problem, and will only get used when needed */
 576   else if (!hostRoute && olsr_cnf->fib_metric == FIBM_FLAT
 577       && (err == 128 || err == 101 || err == 3)) {
 578     struct olsr_ip_prefix hostPrefix;
 579
 580     if (err == 128)  {
 581       olsr_syslog(OLSR_LOG_ERR, ". autogenerating route to handle 'Network unreachable' (128) while adding route!");
 582     }
 583     else if (err == 101) {
 584       olsr_syslog(OLSR_LOG_ERR, ". autogenerating route to handle 'Network unreachable' (101) while adding route!");
 585     }
 586     else {
 587       olsr_syslog(OLSR_LOG_ERR, ". autogenerating route to handle 'No such process' (3) while adding route!");
 588     }
 589
 590     /* create hostroute */
 591     hostPrefix.prefix = nexthop->gateway;
 592     hostPrefix.prefix_len = olsr_cnf->ipsize * 8;
 593
 594     err = olsr_new_netlink_route(af_family, olsr_cnf->rt_table, nexthop->iif_index,
 595         metric, olsr_cnf->rt_proto, src, NULL, &hostPrefix, true, false);
 596     if (err == 0) {
 597       /* create this rule a second time if hostrule generation was successful */
 598       err = olsr_new_netlink_route(af_family, table, nexthop->iif_index, metric, olsr_cnf->rt_proto,
 599           src, hostRoute ? NULL : &nexthop->gateway, &rt->rt_dst, set, false);
 600     }
 601     olsr_syslog(OLSR_LOG_ERR, ". %s (%d)", err == 0 ? "successful" : "failed", err);
 602   }
 603
 604   return err;
 605 }
 606
 607 /**
 608  * Insert a route in the kernel routing table
 609  *
 610  * @param destination the route to add
 611  *
 612  * @return negative on error
 613  */
 614 int
 615 olsr_ioctl_add_route(const struct rt_entry *rt)
 616 {
 617   OLSR_PRINTF(2, "KERN: Adding %s\n", olsr_rtp_to_string(rt->rt_best));
 618   return olsr_os_process_rt_entry(AF_INET, rt, true);
 619 }
 620
 621 /**
 622  *Insert a route in the kernel routing table
 623  *
 624  *@param destination the route to add
 625  *
 626  *@return negative on error
 627  */
 628 int
 629 olsr_ioctl_add_route6(const struct rt_entry *rt)
 630 {
 631   OLSR_PRINTF(2, "KERN: Adding %s\n", olsr_rtp_to_string(rt->rt_best));
 632   return olsr_os_process_rt_entry(AF_INET6, rt, true);
 633 }
 634
 635 /**
 636  *Remove a route from the kernel
 637  *
 638  *@param destination the route to remove
 639  *
 640  *@return negative on error
 641  */
 642 int
 643 olsr_ioctl_del_route(const struct rt_entry *rt)
 644 {
 645   OLSR_PRINTF(2, "KERN: Deleting %s\n", olsr_rt_to_string(rt));
 646   return olsr_os_process_rt_entry(AF_INET, rt, false);
 647 }
 648
 649 /**
 650  *Remove a route from the kernel
 651  *
 652  *@param destination the route to remove
 653  *
 654  *@return negative on error
 655  */
 656 int
 657 olsr_ioctl_del_route6(const struct rt_entry *rt)
 658 {
 659   OLSR_PRINTF(2, "KERN: Deleting %s\n", olsr_rt_to_string(rt));
 660   return olsr_os_process_rt_entry(AF_INET6, rt, false);
 661 }
 662
 663 #endif
 664 /*
 665  * Local Variables:
 666  * c-basic-offset: 2
 667  * indent-tabs-mode: nil
 668  * End:
 669  */