add rule priorities, and ability to set ip addr of interfaces
[olsrd.git] / src / linux / kernel_routes.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
46 /* values for control flag to handle recursive route corrections 
47  *  currently only requires in linux specific kernel_routes.c */
48
49 #define RT_ORIG_REQUEST 0
50 #define RT_RETRY_AFTER_ADD_GATEWAY 1
51 #define RT_RETRY_AFTER_DELETE_SIMILAR 2
52 #define RT_DELETE_SIMILAR_ROUTE 3
53 #define RT_AUTO_ADD_GATEWAY_ROUTE 4
54 #define RT_DELETE_SIMILAR_AUTO_ROUTE 5
55 #define RT_NIIT 6
56
57 #if !LINUX_POLICY_ROUTING
58
59 static int delete_all_inet_gws(void);
60
61 #else /* !LINUX_POLICY_ROUTING */
62
63 #include <assert.h>
64 #include <linux/types.h>
65 #include <linux/rtnetlink.h>
66
67 //ipip includes
68 #include <netinet/in.h>
69 #include <sys/ioctl.h>
70 #include <net/if.h>
71 #include <linux/ip.h>
72 #include <linux/if_tunnel.h>
73
74 //ifup includes
75 #include <sys/socket.h>
76 #include <sys/ioctl.h>
77 #include <sys/types.h>
78 #include <net/if.h>
79
80 extern struct rtnl_handle rth;
81
82 struct olsr_rtreq {
83   struct nlmsghdr n;
84   struct rtmsg r;
85   char buf[512];
86 };
87
88 /*takes up an interface*/
89 int olsr_dev_up(const char * dev,bool set_ip)
90 {
91   int s, r;
92   struct ifreq ifr;
93   s = socket(PF_INET, SOCK_DGRAM, 0);
94   if (s < 0) {
95     perror("socket");
96     return(-1);
97   }
98   memset(&ifr, 0, sizeof(ifr));
99   strncpy(ifr.ifr_name, dev, IFNAMSIZ);
100
101   if (set_ip){
102     struct sockaddr_in sin;
103     memset(&sin, 0, sizeof(struct sockaddr_in));
104     sin.sin_family = AF_INET;
105     sin.sin_addr.s_addr = 0x01020304;//!!??use originator address
106     memcpy(&ifr.ifr_addr, &sin, sizeof(struct sockaddr_in));
107
108     r = ioctl(s, SIOCSIFADDR, &ifr);
109     if (r < 0){
110       perror("ioctl");
111       return(-1);
112     }
113     /*reset ifreq fuild for IFFLGAS*/
114     memset(&sin, 0, sizeof( struct sockaddr_in) );
115   }
116
117   ifr.ifr_flags = IFF_UP; //!!?? read old flags and before setting new ones
118   r = ioctl(s, SIOCSIFFLAGS, &ifr);
119   if (r < 0) {
120     perror("ioctl");
121     return(-1);
122   }
123
124   return true;
125 }
126                                         
127 #if LINUX_RTNETLINK_LISTEN
128 #include "ifnet.h"
129 #include "socket_parser.h"
130
131 int rtnetlink_register_socket(int rtnl_mgrp)
132 {
133   int sock = socket(AF_NETLINK,SOCK_RAW,NETLINK_ROUTE);
134   struct sockaddr_nl addr;
135
136   if (sock<0) {
137     OLSR_PRINTF(1,"could not create rtnetlink socket! %d",sock);
138   }
139   else {
140     memset(&addr, 0, sizeof(addr));
141
142     addr.nl_family = AF_NETLINK;
143     addr.nl_pid = 0; //kernel will assign appropiate number instead of pid (which is already used by primaray rtnetlink socket to add/delete routes)
144     addr.nl_groups = rtnl_mgrp;
145     if (bind(sock,(struct sockaddr *)&addr,sizeof(addr))<0) {
146       OLSR_PRINTF(1,"could not bind socket! (%d %s)",errno,strerror(errno));
147     }
148     else {
149       add_olsr_socket(sock, &rtnetlink_read);
150     }
151     fcntl(sock, F_SETFL, O_NONBLOCK);
152   }
153   return sock;
154 }
155
156 static void netlink_process_link(struct nlmsghdr *h)
157 {
158   struct ifinfomsg *ifi = (struct ifinfomsg *) NLMSG_DATA(h);
159   struct interface *iface;
160   struct olsr_if *tmp_if;
161
162   iface = if_ifwithindex(ifi->ifi_index);
163   if (iface == NULL) {
164     return;
165   }
166   
167   //all IFF flags: LOOPBACK,BROADCAST;POINTOPOINT;MULTICAST;NOARP;ALLMULTI;PROMISC;MASTER;SLAVE;DEBUG;DYNAMIC;AUTOMEDIA;PORTSEL;NOTRAILERS;UP;LOWER_UP;DORMANT
168   /* check if interface is up and running? (a not running interface keeps its routes, so better not react like on ifdown!!??) */
169   if (ifi->ifi_flags&IFF_UP) {
170     OLSR_PRINTF(3,"interface %s changed but is still up! ", iface->int_name);
171     return; //we are currently only interested in interfaces that are/go down
172   } else {
173     OLSR_PRINTF(1,"interface %s is down! ", iface->int_name);
174   }
175
176   //only for still configured interfaces (ifup has to be detected with regular interface polling)
177   for (tmp_if = olsr_cnf->interfaces; tmp_if != NULL; tmp_if = tmp_if->next) {
178     if (tmp_if->interf==iface) {
179       OLSR_PRINTF(1,"-> removing %s from olsr config! ", iface->int_name);
180       RemoveInterface(tmp_if,true);
181       break;
182     }
183   }
184 }
185
186 void rtnetlink_read(int sock)
187 {
188   int len, plen;
189   struct iovec iov;
190   struct sockaddr_nl nladdr;
191   struct msghdr msg = {
192     &nladdr,
193     sizeof(nladdr),
194     &iov,
195     1,
196     NULL,
197     0,
198     0
199   };
200
201   char buffer[4096];
202   struct nlmsghdr *nlh = (struct nlmsghdr *)(ARM_NOWARN_ALIGN) buffer;
203   int ret;
204
205   iov.iov_base = (void *) buffer;
206   iov.iov_len = sizeof(buffer);
207
208   while (true) { //read until ret<0;
209     ret=recvmsg(sock, &msg, 0);
210     if (ret<0) {
211       if (errno != EAGAIN) OLSR_PRINTF(1,"\nnetlink listen error %u - %s",errno,strerror(errno));
212       return;
213     }
214     /*check message*/
215     len = nlh->nlmsg_len;
216     plen = len - sizeof(nlh);
217     if (len > ret || plen < 0) {
218       OLSR_PRINTF(1,"Malformed netlink message: "
219              "len=%d left=%d plen=%d",
220               len, ret, plen);
221       return;
222     }
223     if ( (nlh->nlmsg_type == RTM_NEWLINK) || ( nlh->nlmsg_type == RTM_DELLINK) ) netlink_process_link(nlh);
224   }
225 }
226
227 //!!?? listen on our own tunlx interfaces aswell
228
229 #endif /*linux_rtnetlink_listen*/
230
231 /*create or change a ipip tunnel ipv4 only*/
232 static int set_tunl(int cmd, unsigned long int ipv4)
233 {
234   struct ifreq ifr;
235   int fd;
236   int err;
237   struct ip_tunnel_parm p;
238
239   p.iph.version = 4;
240   p.iph.ihl = 5;
241   p.iph.protocol=IPPROTO_IPIP; //IPPROTO_IPV6
242   p.iph.saddr=0x00000000;
243   p.iph.daddr=ipv4;
244
245   strncpy(p.name, olsr_cnf->ipip_name, IFNAMSIZ);
246
247   //specify existing interface name
248   if (cmd!=SIOCADDTUNNEL) strncpy(ifr.ifr_name, olsr_cnf->ipip_name, IFNAMSIZ);
249
250   ifr.ifr_ifru.ifru_data = (void *) &p;
251   fd = socket(AF_INET, SOCK_DGRAM, 0);//warning hardcoded AF_INET
252   err = ioctl(fd, cmd, &ifr);
253   if (err) perror("ioctl");
254   close(fd);
255   return err;
256 }
257
258 static void
259 olsr_netlink_addreq(struct olsr_rtreq *req, int type, const void *data, int len)
260 {
261   struct rtattr *rta = (struct rtattr *)(ARM_NOWARN_ALIGN)(((char *)req) + NLMSG_ALIGN(req->n.nlmsg_len));
262   req->n.nlmsg_len = NLMSG_ALIGN(req->n.nlmsg_len) + RTA_LENGTH(len);
263   assert(req->n.nlmsg_len < sizeof(struct olsr_rtreq));
264   rta->rta_type = type;
265   rta->rta_len = RTA_LENGTH(len);
266   memcpy(RTA_DATA(rta), data, len);
267 }
268
269 /* returns
270  * -1 on unrecoverable error (calling function will have to handle it)
271  *  0 on unexpected but recoverable rtnetlink behaviour
272  *    but some of the implemented recovery methods only cure symptoms, 
273  *    not the cause, like unintelligent ordering of inserted routes.
274  *  1 on success */
275 static int
276 olsr_netlink_route_int(const struct rt_entry *rt, uint8_t family, uint8_t rttable, __u16 cmd, uint16_t flag)
277 {
278   int ret = 1; /* helper variable for rtnetlink_message processing */
279   int rt_ret = -2;  /* if no response from rtnetlink it must be considered as failed! */
280   struct olsr_rtreq req;
281   struct iovec iov;
282   struct sockaddr_nl nladdr;
283   struct msghdr msg = {
284     &nladdr,
285     sizeof(nladdr),
286     &iov,
287     1,
288     NULL,
289     0,
290     0
291   };
292
293   uint32_t metric = 0;
294   const struct rt_nexthop *nexthop = NULL;
295   if ( ( cmd != RTM_NEWRULE ) && ( cmd != RTM_DELRULE ) ) {
296     if (FIBM_FLAT == olsr_cnf->fib_metric) {
297       metric = RT_METRIC_DEFAULT;
298     }
299     else {
300       metric = (RTM_NEWROUTE == cmd) ? rt->rt_best->rtp_metric.hops : rt->rt_metric.hops;
301     }
302
303     if (( RTM_NEWROUTE == cmd ) ||
304         (( RTM_DELROUTE == cmd ) && ( RT_DELETE_SIMILAR_ROUTE == flag || RT_DELETE_SIMILAR_AUTO_ROUTE == flag ))) {
305       nexthop = &rt->rt_best->rtp_nexthop;
306     }
307     else {
308       nexthop = &rt->rt_nexthop;
309     }
310   }
311
312   memset(&req, 0, sizeof(req));
313
314   req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
315   req.n.nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE | NLM_F_EXCL | NLM_F_ACK;
316   req.n.nlmsg_type = cmd;
317   
318   /*sanity check for niit ipv4 over ipv6 routes*/
319   if (family == AF_INET && flag == RT_NIIT) {
320     olsr_syslog(OLSR_LOG_ERR,"niit makes no sense with olsrd running on ipv4!");
321     return -1;
322   }
323
324   if (flag == RT_NIIT) {
325     req.r.rtm_family=AF_INET; /*we create an ipv4 niit route*/
326   }
327   else {
328     req.r.rtm_family = family;
329   }
330
331   req.r.rtm_table = rttable;
332
333   /* RTN_UNSPEC would be the wildcard, but blackhole broadcast or nat roules should usually not conflict */
334   /* -> olsr only adds deletes unicast routes */
335   req.r.rtm_type = RTN_UNICAST;
336
337   /* wildcard to delete routes of all protos if no simlar-delete correct proto will get set below */
338   req.r.rtm_protocol = RTPROT_UNSPEC;
339
340   /* as wildcard for deletion */
341   req.r.rtm_scope = RT_SCOPE_NOWHERE;
342
343   if ( ( cmd == RTM_NEWRULE ) || ( cmd == RTM_DELRULE ) ) {
344     /* add or delete a rule */
345     req.r.rtm_scope = RT_SCOPE_UNIVERSE;
346     olsr_netlink_addreq(&req, RTA_PRIORITY, &flag, sizeof(flag));
347     if (rt!=NULL) {
348       /*add interface name to rule*/
349       //olsr_netlink_addreq(&req, RTA_interface, &rt, sizeof(?));
350       printf("rule interface %s ignored!",(const char *) rt);
351     } 
352   }
353   else {
354     req.r.rtm_dst_len = rt->rt_dst.prefix_len;
355
356     /* do not specify much as we wanna delete similar/conflicting routes */
357     if ( ( flag != RT_DELETE_SIMILAR_ROUTE ) && ( flag != RT_DELETE_SIMILAR_AUTO_ROUTE )) {
358       /* 0 gets replaced by OS-specifc default (3)
359        * 1 is reserved so we take 0 instead (this really makes some sense)
360        * other numbers are used 1:1 */
361       req.r.rtm_protocol = ( (olsr_cnf->rtproto<1) ? RTPROT_BOOT : ( (olsr_cnf->rtproto==1) ? 0 : olsr_cnf->rtproto) );
362       req.r.rtm_scope = RT_SCOPE_LINK;
363
364       /*add interface*/
365       if ((&olsr_cnf->smart_gateway_active) && (rt->rt_dst.prefix_len == 0) && (&olsr_cnf->ipip_if_index==NULL))
366       {
367         //create tunnel
368         set_tunl(SIOCADDTUNNEL,rt->rt_best->rtp_originator.v4.s_addr);
369 //!!?? currently it gets never deleted at shutdown, anyways reusing existing tunnel might be a safe approach if creating fails?
370         //set tunnel up with originator ip
371         olsr_dev_up(olsr_cnf->ipip_name,true);
372         //find out iifindex (maybe it works even if above failed (old tunnel))
373         olsr_cnf->ipip_if_index=if_nametoindex(olsr_cnf->ipip_name);
374       }
375
376       /*add interface*/
377       if ((&olsr_cnf->smart_gateway_active) && family != AF_INET)
378       {
379         printf("smart gateway not available for ipv6 currently");
380         return -1;
381       }
382       else if ((&olsr_cnf->smart_gateway_active) && (rt->rt_dst.prefix_len == 0) && (&olsr_cnf->ipip_if_index))
383       {
384         //change tunnel to new originator og potentially new gateway
385         if (olsr_cnf->ipip_remote_address != rt->rt_best->rtp_originator.v4.s_addr)
386         {
387           struct ipaddr_str buf;
388           printf("changing tunnel to %s",olsr_ip_to_string(&buf,&rt->rt_best->rtp_originator));
389           olsr_cnf->ipip_remote_address = rt->rt_best->rtp_originator.v4.s_addr;
390           set_tunl(SIOCCHGTUNNEL,olsr_cnf->ipip_remote_address);
391         }
392         //add interface
393         olsr_netlink_addreq(&req, RTA_OIF, &olsr_cnf->niit_if_index, sizeof(&olsr_cnf->ipip_if_index));
394       }
395       else if (flag == RT_NIIT) {
396         olsr_netlink_addreq(&req, RTA_OIF, &olsr_cnf->niit_if_index, sizeof(&olsr_cnf->niit_if_index));
397       }
398       else {
399         olsr_netlink_addreq(&req, RTA_OIF, &nexthop->iif_index, sizeof(nexthop->iif_index));
400       }
401
402 #if SOURCE_IP_ROUTES
403       /**
404        * source ip here is based on now static olsr_cnf->main_addr in this olsr-0.5.6-r4,
405        * should be based on orignator-id in newer olsrds
406        **/
407       if (flag != RT_NIIT) {
408         if (AF_INET == family) {
409           olsr_netlink_addreq(&req, RTA_PREFSRC, &olsr_cnf->main_addr.v4.s_addr, sizeof(olsr_cnf->main_addr.v4.s_addr));
410         }
411         else {
412           olsr_netlink_addreq(&req, RTA_PREFSRC, &olsr_cnf->main_addr.v6.s6_addr, sizeof(olsr_cnf->main_addr.v6.s6_addr));
413         }
414       }
415 #endif
416     }
417
418     /* metric is specified always as we can only delete one route per iteration, and wanna hit the correct one first */
419     if (FIBM_APPROX != olsr_cnf->fib_metric || (RTM_NEWROUTE == cmd) ) {
420       olsr_netlink_addreq(&req, RTA_PRIORITY, &metric, sizeof(metric));
421     }
422
423     /* make sure that netmask = maxplen (32 or 128) as this is an autogenarated (host)route */
424     if (( flag == RT_AUTO_ADD_GATEWAY_ROUTE ) || (flag == RT_DELETE_SIMILAR_AUTO_ROUTE) ) {
425       req.r.rtm_dst_len = olsr_cnf->maxplen;
426     }
427
428     /**
429      * for ipv4 or ipv6 we add gateway if one is specified,
430      * or leave gateway away if we want to delete similar routes aswell,
431      * or even use the gateway as target if we add a auto-generated route,
432      * or if delete-similar to make insertion of auto-generated route possible
433      **/
434     if (AF_INET == family) {
435       if ( !( (rt->rt_dst.prefix_len == 0) && (olsr_cnf->smart_gateway_active) )
436            && ( flag != RT_AUTO_ADD_GATEWAY_ROUTE ) && (flag != RT_DELETE_SIMILAR_ROUTE) && 
437            ( flag != RT_DELETE_SIMILAR_AUTO_ROUTE) && (rt->rt_dst.prefix.v4.s_addr != nexthop->gateway.v4.s_addr) ) {
438         olsr_netlink_addreq(&req, RTA_GATEWAY, &nexthop->gateway.v4, sizeof(nexthop->gateway.v4));
439         req.r.rtm_scope = RT_SCOPE_UNIVERSE;
440       }
441       olsr_netlink_addreq(&req, RTA_DST, ( (flag == RT_AUTO_ADD_GATEWAY_ROUTE) || (flag == RT_DELETE_SIMILAR_AUTO_ROUTE) ) ? 
442                           &nexthop->gateway.v4 : &rt->rt_dst.prefix.v4, sizeof(rt->rt_dst.prefix.v4));
443     } else {
444       if (flag == RT_NIIT) {
445         union olsr_ip_addr ipv4_addr;
446         /* create an ipv4 route */
447         olsr_syslog(OLSR_LOG_ERR,"niit suport not fully implemented!!"); 
448         olsr_netlink_addreq(&req, RTA_DST, olsr_ipv6_to_ipv4(&rt->rt_dst.prefix, &ipv4_addr), sizeof(ipv4_addr.v4));
449       }
450       else {
451         if ( !( (rt->rt_dst.prefix_len == 0) && (olsr_cnf->smart_gateway_active) ) 
452             && ( flag != RT_AUTO_ADD_GATEWAY_ROUTE ) && (flag != RT_DELETE_SIMILAR_ROUTE ) && ( flag != RT_DELETE_SIMILAR_AUTO_ROUTE) 
453             && (0 != memcmp(&rt->rt_dst.prefix.v6, &nexthop->gateway.v6, sizeof(nexthop->gateway.v6))) ) {
454           olsr_netlink_addreq(&req, RTA_GATEWAY, &nexthop->gateway.v6, sizeof(nexthop->gateway.v6));
455           req.r.rtm_scope = RT_SCOPE_UNIVERSE;
456         }
457         olsr_netlink_addreq(&req, RTA_DST, ( (flag == RT_AUTO_ADD_GATEWAY_ROUTE) || (flag == RT_DELETE_SIMILAR_AUTO_ROUTE) ) ? 
458                             &nexthop->gateway.v6 : &rt->rt_dst.prefix.v6, sizeof(rt->rt_dst.prefix.v6));
459       }
460     }
461   }
462
463   iov.iov_base = &req.n;
464   iov.iov_len = req.n.nlmsg_len;
465   memset(&nladdr, 0, sizeof(nladdr));
466   nladdr.nl_family = AF_NETLINK;
467   if (0 <= (ret = sendmsg(olsr_cnf->rtnl_s, &msg, 0))) {
468     iov.iov_base = req.buf;
469     iov.iov_len = sizeof(req.buf);
470     if (0 < (ret = recvmsg(olsr_cnf->rtnl_s, &msg, 0))) {
471       struct nlmsghdr *h = (struct nlmsghdr *)(ARM_NOWARN_ALIGN)req.buf;
472       while (NLMSG_OK(h, (unsigned int)ret)) {
473         if (NLMSG_DONE == h->nlmsg_type) {
474           /* seems to reached never */
475           olsr_syslog(OLSR_LOG_INFO, "_received NLMSG_DONE");
476           break;
477         }
478         if (NLMSG_ERROR == h->nlmsg_type) {
479           if (NLMSG_LENGTH(sizeof(struct nlmsgerr) <= h->nlmsg_len)) {
480             struct ipaddr_str ibuf;
481             struct ipaddr_str gbuf;
482             struct nlmsgerr *l_err = (struct nlmsgerr *)NLMSG_DATA(h);
483             errno = -l_err->error;
484             if (0 != errno) {
485               const char *const err_msg = strerror(errno);
486               struct ipaddr_str buf;
487               rt_ret = -1;
488
489               /* syslog debug output for various situations */
490               if ( cmd == RTM_NEWRULE ) {
491                 olsr_syslog(OLSR_LOG_ERR,"Error '%s' (%d) on inserting empty policy rule aimed to activate RtTable %u!", err_msg, errno, rttable);
492               }
493               else if ( cmd == RTM_DELRULE ) {
494                 olsr_syslog(OLSR_LOG_ERR,"Error '%s' (%d) on deleting empty policy rule aimed to activate rtTable %u!", err_msg, errno, rttable);
495               }
496               else if ( flag == RT_NIIT ) {
497                 olsr_syslog(OLSR_LOG_ERR,"Error '%s' (%d) on manipulating niit route of %s!", err_msg, errno, olsr_ip_to_string(&ibuf,&rt->rt_dst.prefix));
498               }
499               else if ( flag <= RT_RETRY_AFTER_DELETE_SIMILAR ) {
500                 if (rt->rt_dst.prefix.v4.s_addr!=nexthop->gateway.v4.s_addr) {
501                   olsr_syslog(OLSR_LOG_ERR, "error '%s' (%d) %s route to %s/%d via %s dev %s",
502                       err_msg, errno, (cmd == RTM_NEWROUTE) ? "add" : "del",
503                       olsr_ip_to_string(&ibuf,&rt->rt_dst.prefix), req.r.rtm_dst_len,
504                       olsr_ip_to_string(&gbuf,&nexthop->gateway), if_ifwithindex_name(nexthop->iif_index));
505                 }
506                 else {
507                   olsr_syslog(OLSR_LOG_ERR, "error '%s' (%d) %s route to %s/%d dev %s",
508                       err_msg, errno, (cmd == RTM_NEWROUTE) ? "add" : "del",
509                       olsr_ip_to_string(&ibuf,&rt->rt_dst.prefix), req.r.rtm_dst_len, if_ifwithindex_name(nexthop->iif_index));
510                 }
511               }
512               else if (flag == RT_AUTO_ADD_GATEWAY_ROUTE) {
513                 olsr_syslog(OLSR_LOG_ERR, ". error '%s' (%d) auto-add route to %s dev %s", err_msg, errno,
514                     olsr_ip_to_string(&ibuf,&nexthop->gateway), if_ifwithindex_name(nexthop->iif_index));
515               }
516               else if (flag == RT_DELETE_SIMILAR_ROUTE) {
517                 olsr_syslog(OLSR_LOG_ERR, ". error '%s' (%d) auto-delete route to %s dev %s", err_msg, errno,
518                     olsr_ip_to_string(&ibuf,&rt->rt_dst.prefix), if_ifwithindex_name(nexthop->iif_index));
519               }
520               else if (flag == RT_DELETE_SIMILAR_AUTO_ROUTE) {
521                 olsr_syslog(OLSR_LOG_ERR, ". . error '%s' (%d) auto-delete similar route to %s dev %s", err_msg, errno,
522                     olsr_ip_to_string(&ibuf,&nexthop->gateway), if_ifwithindex_name(nexthop->iif_index));
523               }
524               else {
525                 /* should never happen */
526                 olsr_syslog(OLSR_LOG_ERR, "# invalid internal route delete/add flag (%d) used!", flag);
527               }
528             }
529             else {
530               /* netlink acks requests with an errno=0 NLMSG_ERROR response! */
531               rt_ret = 1;
532             }
533
534             /* resolve "File exist" (17) propblems (on orig and autogen routes)*/       
535             if ((errno == 17) && (cmd == RTM_NEWROUTE) && ((flag == RT_ORIG_REQUEST) || (flag == RT_AUTO_ADD_GATEWAY_ROUTE))) {
536               /* a similar route going over another gateway may be present, which has to be deleted! */
537               olsr_syslog(OLSR_LOG_ERR, ". auto-deleting similar routes to resolve 'File exists' (17) while adding route!");
538               rt_ret = RT_DELETE_SIMILAR_ROUTE; /* processing will contiune after this loop */
539             }
540             /* report success on "No such process" (3) */
541             else if ((errno == 3) && (cmd == RTM_DELROUTE) && (flag == RT_ORIG_REQUEST)) {
542               /* another similar (but slightly different) route may be present at this point
543               * , if so this will get solved when adding new route to this destination */
544               olsr_syslog(OLSR_LOG_ERR, ". ignoring 'No such process' (3) while deleting route!");
545               rt_ret = 0;
546             }
547             /* insert route to gateway on the fly if "Network unreachable" (128) on 2.4 kernels
548              * or on 2.6 kernel No such process (3) or Network unreachable (101) is reported in rtnetlink response
549              * do this only with flat metric, as using metric values inherited from 
550              * a target behind the gateway is really strange, and could lead to multiple routes!
551              * anyways if invalid gateway ips may happen we are f*cked up!!
552              * but if not, these on the fly generated routes are no problem, and will only get used when needed */
553             else if ( ( (errno == 3) || (errno == 101) || (errno == 128) )
554                 && (flag == RT_ORIG_REQUEST) && (FIBM_FLAT == olsr_cnf->fib_metric)
555                      && (cmd == RTM_NEWROUTE) && (rt->rt_dst.prefix.v4.s_addr!=nexthop->gateway.v4.s_addr)) {
556               if (errno == 128)  {
557                 olsr_syslog(OLSR_LOG_ERR, ". autogenerating route to handle 'Network unreachable' (128) while adding route!");
558               }
559               else if (errno == 101) {
560                 olsr_syslog(OLSR_LOG_ERR, ". autogenerating route to handle 'Network unreachable' (101) while adding route!");
561               }
562               else {
563                 olsr_syslog(OLSR_LOG_ERR, ". autogenerating route to handle 'No such process' (3) while adding route!");
564               }
565
566               /* processing will contiune after this loop */
567               rt_ret = RT_AUTO_ADD_GATEWAY_ROUTE;
568             }
569           }
570           /* report invalid message size */
571           else {
572             olsr_syslog(OLSR_LOG_INFO,"_received invalid netlink message size %lu != %u",
573                 (unsigned long int)sizeof(struct nlmsgerr), h->nlmsg_len);
574           }
575         }
576         /* log all other messages */
577         else {
578           olsr_syslog(OLSR_LOG_INFO,"_received %u Byte rtnetlink response of type %u with seqnr %u and flags %u from %u (%u)",
579               h->nlmsg_len, h->nlmsg_type, h->nlmsg_seq, h->nlmsg_flags, h->nlmsg_pid, NLMSG_ERROR);
580         }
581 /*
582  * The ARM compile complains about alignment. Copied
583  * from /usr/include/linux/netlink.h and adapted for ARM
584  */
585 #define MY_NLMSG_NEXT(nlh,len)   ((len) -= NLMSG_ALIGN((nlh)->nlmsg_len), \
586                                   (struct nlmsghdr*)(ARM_NOWARN_ALIGN)(((char*)(nlh)) + NLMSG_ALIGN((nlh)->nlmsg_len)))
587         h = MY_NLMSG_NEXT(h, ret);
588       }
589     }
590   }
591   if ( rt_ret == RT_DELETE_SIMILAR_ROUTE ) {
592     /* delete all routes that may collide */
593
594     /* recursive call to delete simlar routes, using flag 2 to invoke deletion of similar, not only exact matches*/
595     rt_ret = olsr_netlink_route_int(rt, family, rttable, RTM_DELROUTE, 
596         flag == RT_AUTO_ADD_GATEWAY_ROUTE ? RT_DELETE_SIMILAR_AUTO_ROUTE : RT_DELETE_SIMILAR_ROUTE);
597
598     /* retry insert original route, if deleting similar succeeded, using flag=1 to prevent recursions */
599     if (rt_ret > 0) {
600       rt_ret = olsr_netlink_route_int(rt, family, rttable, RTM_NEWROUTE, RT_RETRY_AFTER_DELETE_SIMILAR);
601     }
602     else {
603       olsr_syslog(OLSR_LOG_ERR, ". failed on auto-deleting similar route conflicting with above route!");
604     }
605
606     /* set appropriate return code for original request, while returning simple -1/1 if called recursive */
607     if (flag != RT_AUTO_ADD_GATEWAY_ROUTE) {
608       if (rt_ret > 0) {
609         /* successful recovery */
610         rt_ret = 0;
611       }
612       else {
613         /* unrecoverable error */
614         rt_ret = -1;
615       }
616     }
617   }
618   if ( rt_ret == RT_AUTO_ADD_GATEWAY_ROUTE ) {
619     /* autoadd route via gateway */
620
621     /* recursive call to invoke creation of a route to the gateway */
622     rt_ret = olsr_netlink_route_int(rt, family, rttable, RTM_NEWROUTE, RT_AUTO_ADD_GATEWAY_ROUTE);
623
624     /* retry insert original route, if above succeeded without problems */
625     if (rt_ret > 0) {
626       rt_ret = olsr_netlink_route_int(rt, family, rttable, RTM_NEWROUTE, RT_RETRY_AFTER_ADD_GATEWAY);
627     }
628     else {
629       olsr_syslog(OLSR_LOG_ERR, ". failed on inserting auto-generated route to gateway of above route!");
630     }
631
632     /* set appropriate return code for original request*/
633     if (rt_ret > 0) {
634       /* successful recovery */
635       rt_ret = 0;
636     }
637     else {
638       /* unrecoverable error */
639       rt_ret = -1;
640     }
641   }
642   /* send ipc update on success */
643   if ( ( cmd != RTM_NEWRULE ) && ( cmd != RTM_DELRULE )
644       && (flag == RT_ORIG_REQUEST) && (0 <= rt_ret && olsr_cnf->ipc_connections > 0) ) {
645     ipc_route_send_rtentry(&rt->rt_dst.prefix, &nexthop->gateway, metric,
646         RTM_NEWROUTE == cmd, if_ifwithindex_name(nexthop->iif_index));
647   }
648   if (rt_ret == -2) {
649     olsr_syslog(OLSR_LOG_ERR,"no rtnetlink response! (no system ressources left?, everything may happen now ...)");
650   }
651   return rt_ret;
652 }
653
654 /* external wrapper function for above patched multi purpose rtnetlink function */
655 int
656 olsr_netlink_rule(uint8_t family, uint8_t rttable, uint16_t cmd, uint32_t priority, char* dev)
657 {
658   printf("rule priority not supported");
659   return olsr_netlink_route_int((const struct rt_entry *) dev, family, rttable, cmd, priority);
660 }
661
662 /* internal wrapper function for above patched function */
663 static int
664 olsr_netlink_route(const struct rt_entry *rt, uint8_t family, uint8_t rttable, __u16 cmd)
665 {
666   /*create/delete niit route if we have an niit device*/
667   if ((olsr_cnf->niit_if_index!=0) && (family != AF_INET) && (olsr_is_niit_ip(&rt->rt_dst.prefix))) {
668     olsr_netlink_route_int(rt, family, rttable, cmd, RT_NIIT);
669   }
670
671   return olsr_netlink_route_int(rt, family, rttable, cmd, RT_ORIG_REQUEST);
672 }
673
674 #endif /* LINUX_POLICY_ROUTING */
675
676 /**
677  * Insert a route in the kernel routing table
678  *
679  * @param destination the route to add
680  *
681  * @return negative on error
682  */
683 int
684 olsr_ioctl_add_route(const struct rt_entry *rt)
685 {
686 #if !LINUX_POLICY_ROUTING
687   struct rtentry kernel_route;
688   union olsr_ip_addr mask;
689   int rslt;
690 #endif /* LINUX_POLICY_ROUTING */
691
692   OLSR_PRINTF(2, "KERN: Adding %s\n", olsr_rtp_to_string(rt->rt_best));
693
694 #if !LINUX_POLICY_ROUTING
695   memset(&kernel_route, 0, sizeof(struct rtentry));
696
697   ((struct sockaddr_in *)&kernel_route.rt_dst)->sin_family = AF_INET;
698   ((struct sockaddr_in *)&kernel_route.rt_gateway)->sin_family = AF_INET;
699   ((struct sockaddr_in *)&kernel_route.rt_genmask)->sin_family = AF_INET;
700
701   ((struct sockaddr_in *)&kernel_route.rt_dst)->sin_addr = rt->rt_dst.prefix.v4;
702
703   if (!olsr_prefix_to_netmask(&mask, rt->rt_dst.prefix_len)) {
704     return -1;
705   }
706   ((struct sockaddr_in *)&kernel_route.rt_genmask)->sin_addr = mask.v4;
707
708   if (rt->rt_dst.prefix.v4.s_addr != rt->rt_best->rtp_nexthop.gateway.v4.s_addr) {
709     ((struct sockaddr_in *)&kernel_route.rt_gateway)->sin_addr = rt->rt_best->rtp_nexthop.gateway.v4;
710   }
711
712   kernel_route.rt_flags = olsr_rt_flags(rt);
713   kernel_route.rt_metric = olsr_fib_metric(&rt->rt_best->rtp_metric.hops);
714
715   /*
716    * Set interface
717    */
718   kernel_route.rt_dev = if_ifwithindex_name(rt->rt_best->rtp_nexthop.iif_index);
719
720   /* delete existing default route before ? */
721   if ((olsr_cnf->del_gws) && (rt->rt_dst.prefix.v4.s_addr == INADDR_ANY) && (rt->rt_dst.prefix_len == INADDR_ANY)) {
722     delete_all_inet_gws();
723     olsr_cnf->del_gws = false;
724   }
725
726   if ((rslt = ioctl(olsr_cnf->ioctl_s, SIOCADDRT, &kernel_route)) >= 0) {
727
728     /*
729      * Send IPC route update message
730      */
731     ipc_route_send_rtentry(&rt->rt_dst.prefix, &rt->rt_best->rtp_nexthop.gateway, rt->rt_best->rtp_metric.hops, 1,
732                            if_ifwithindex_name(rt->rt_best->rtp_nexthop.iif_index));
733   }
734
735   return rslt;
736 #else /* !LINUX_POLICY_ROUTING */
737   if (0 == olsr_cnf->rttable_default && 0 == rt->rt_dst.prefix_len && 253 > olsr_cnf->rttable) {
738     /*
739      * Users start whining about not having internet with policy
740      * routing activated and no static default route in table 254.
741      * We maintain a fallback defroute in the default=253 table.
742      */
743     olsr_netlink_route(rt, AF_INET, 253, RTM_NEWROUTE);
744   }
745   if (0 == rt->rt_dst.prefix_len && olsr_cnf->rttable_default != 0) {
746     return olsr_netlink_route(rt, AF_INET, olsr_cnf->rttable_default, RTM_NEWROUTE);
747   }
748   else {
749     return olsr_netlink_route(rt, AF_INET, olsr_cnf->rttable, RTM_NEWROUTE);
750   }
751 #endif /* LINUX_POLICY_ROUTING */
752 }
753
754 /**
755  *Insert a route in the kernel routing table
756  *
757  *@param destination the route to add
758  *
759  *@return negative on error
760  */
761 int
762 olsr_ioctl_add_route6(const struct rt_entry *rt)
763 {
764 #if !LINUX_POLICY_ROUTING
765   struct in6_rtmsg kernel_route;
766   int rslt;
767
768   OLSR_PRINTF(2, "KERN: Adding %s\n", olsr_rtp_to_string(rt->rt_best));
769
770   memset(&kernel_route, 0, sizeof(struct in6_rtmsg));
771
772   kernel_route.rtmsg_dst = rt->rt_dst.prefix.v6;
773   kernel_route.rtmsg_dst_len = rt->rt_dst.prefix_len;
774
775   kernel_route.rtmsg_gateway = rt->rt_best->rtp_nexthop.gateway.v6;
776
777   kernel_route.rtmsg_flags = olsr_rt_flags(rt);
778   kernel_route.rtmsg_metric = olsr_fib_metric(&rt->rt_best->rtp_metric.hops);
779
780   /*
781    * set interface
782    */
783   kernel_route.rtmsg_ifindex = rt->rt_best->rtp_nexthop.iif_index;
784
785   /* XXX delete 0/0 route before ? */
786
787   if ((rslt = ioctl(olsr_cnf->ioctl_s, SIOCADDRT, &kernel_route)) >= 0) {
788
789     /*
790      * Send IPC route update message
791      */
792     ipc_route_send_rtentry(&rt->rt_dst.prefix, &rt->rt_best->rtp_nexthop.gateway, rt->rt_best->rtp_metric.hops, 1,
793                            if_ifwithindex_name(rt->rt_best->rtp_nexthop.iif_index));
794   }
795   return rslt;
796 #else /* !LINUX_POLICY_ROUTING */
797   if (0 == rt->rt_dst.prefix_len && olsr_cnf->rttable_default != 0) {
798     return olsr_netlink_route(rt, AF_INET6, olsr_cnf->rttable_default, RTM_NEWROUTE);
799   }
800   else {
801     return olsr_netlink_route(rt, AF_INET6, olsr_cnf->rttable, RTM_NEWROUTE);
802   }
803 #endif /* LINUX_POLICY_ROUTING */
804 }
805
806 /**
807  *Remove a route from the kernel
808  *
809  *@param destination the route to remove
810  *
811  *@return negative on error
812  */
813 int
814 olsr_ioctl_del_route(const struct rt_entry *rt)
815 {
816 #if !LINUX_POLICY_ROUTING
817   struct rtentry kernel_route;
818   union olsr_ip_addr mask;
819   int rslt;
820 #endif /* LINUX_POLICY_ROUTING */
821
822   OLSR_PRINTF(2, "KERN: Deleting %s\n", olsr_rt_to_string(rt));
823
824 #if !LINUX_POLICY_ROUTING
825   memset(&kernel_route, 0, sizeof(struct rtentry));
826
827   ((struct sockaddr_in *)&kernel_route.rt_dst)->sin_family = AF_INET;
828   ((struct sockaddr_in *)&kernel_route.rt_gateway)->sin_family = AF_INET;
829   ((struct sockaddr_in *)&kernel_route.rt_genmask)->sin_family = AF_INET;
830
831   ((struct sockaddr_in *)&kernel_route.rt_dst)->sin_addr = rt->rt_dst.prefix.v4;
832
833   if (rt->rt_dst.prefix.v4.s_addr != rt->rt_nexthop.gateway.v4.s_addr) {
834     ((struct sockaddr_in *)&kernel_route.rt_gateway)->sin_addr = rt->rt_nexthop.gateway.v4;
835   }
836
837   if (!olsr_prefix_to_netmask(&mask, rt->rt_dst.prefix_len)) {
838     return -1;
839   } else {
840     ((struct sockaddr_in *)&kernel_route.rt_genmask)->sin_addr = mask.v4;
841   }
842
843   kernel_route.rt_flags = olsr_rt_flags(rt);
844   kernel_route.rt_metric = olsr_fib_metric(&rt->rt_metric.hops);
845
846   /*
847    * Set interface
848    */
849   kernel_route.rt_dev = NULL;
850
851   if ((rslt = ioctl(olsr_cnf->ioctl_s, SIOCDELRT, &kernel_route)) >= 0) {
852
853     /*
854      * Send IPC route update message
855      */
856     ipc_route_send_rtentry(&rt->rt_dst.prefix, NULL, 0, 0, NULL);
857   }
858
859   return rslt;
860 #else /* !LINUX_POLICY_ROUTING */
861   if (0 == olsr_cnf->rttable_default && 0 == rt->rt_dst.prefix_len && 253 > olsr_cnf->rttable) {
862     /*
863      * Also remove the fallback default route
864      */
865     olsr_netlink_route(rt, AF_INET, 253, RTM_DELROUTE);
866   }
867   if (0 == rt->rt_dst.prefix_len && olsr_cnf->rttable_default != 0) {
868     return olsr_netlink_route(rt, AF_INET, olsr_cnf->rttable_default, RTM_DELROUTE);
869   }
870   else {
871     return olsr_netlink_route(rt, AF_INET, olsr_cnf->rttable, RTM_DELROUTE);
872   }
873 #endif /* LINUX_POLICY_ROUTING */
874 }
875
876 /**
877  *Remove a route from the kernel
878  *
879  *@param destination the route to remove
880  *
881  *@return negative on error
882  */
883 int
884 olsr_ioctl_del_route6(const struct rt_entry *rt)
885 {
886 #if !LINUX_POLICY_ROUTING
887   struct in6_rtmsg kernel_route;
888   int rslt;
889 #endif /* LINUX_POLICY_ROUTING */
890
891   OLSR_PRINTF(2, "KERN: Deleting %s\n", olsr_rt_to_string(rt));
892
893 #if !LINUX_POLICY_ROUTING
894   memset(&kernel_route, 0, sizeof(struct in6_rtmsg));
895
896   kernel_route.rtmsg_dst = rt->rt_dst.prefix.v6;
897   kernel_route.rtmsg_dst_len = rt->rt_dst.prefix_len;
898
899   kernel_route.rtmsg_gateway = rt->rt_best->rtp_nexthop.gateway.v6;
900
901   kernel_route.rtmsg_flags = olsr_rt_flags(rt);
902   kernel_route.rtmsg_metric = olsr_fib_metric(&rt->rt_best->rtp_metric.hops);
903
904   if ((rslt = ioctl(olsr_cnf->ioctl_s, SIOCDELRT, &kernel_route) >= 0)) {
905
906     /*
907      * Send IPC route update message
908      */
909     ipc_route_send_rtentry(&rt->rt_dst.prefix, NULL, 0, 0, NULL);
910   }
911
912   return rslt;
913 #else /* !LINUX_POLICY_ROUTING */
914   if (0 == rt->rt_dst.prefix_len && olsr_cnf->rttable_default != 0) {
915     return olsr_netlink_route(rt, AF_INET6, olsr_cnf->rttable_default, RTM_DELROUTE);
916   }
917   else {
918     return olsr_netlink_route(rt, AF_INET6, olsr_cnf->rttable, RTM_DELROUTE);
919   }
920 #endif /* LINUX_POLICY_ROUTING */
921 }
922
923 #if !LINUX_POLICY_ROUTING
924 static int
925 delete_all_inet_gws(void)
926 {
927   int s;
928   char buf[BUFSIZ], *cp, *cplim;
929   struct ifconf ifc;
930   struct ifreq *ifr;
931
932   OLSR_PRINTF(1, "Internet gateway detected...\nTrying to delete default gateways\n");
933
934   /* Get a socket */
935   if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
936     olsr_syslog(OLSR_LOG_ERR, "socket: %m");
937     return -1;
938   }
939
940   ifc.ifc_len = sizeof(buf);
941   ifc.ifc_buf = buf;
942   if (ioctl(s, SIOCGIFCONF, (char *)&ifc) < 0) {
943     olsr_syslog(OLSR_LOG_ERR, "ioctl (get interface configuration)");
944     close(s);
945     return -1;
946   }
947
948   ifr = ifc.ifc_req;
949   cplim = buf + ifc.ifc_len;    /*skip over if's with big ifr_addr's */
950   for (cp = buf; cp < cplim; cp += sizeof(ifr->ifr_name) + sizeof(ifr->ifr_addr)) {
951     struct rtentry kernel_route;
952     ifr = (struct ifreq *)cp;
953
954     if (strcmp(ifr->ifr_ifrn.ifrn_name, "lo") == 0) {
955       OLSR_PRINTF(1, "Skipping loopback...\n");
956       continue;
957     }
958
959     OLSR_PRINTF(1, "Trying 0.0.0.0/0 %s...", ifr->ifr_ifrn.ifrn_name);
960
961     memset(&kernel_route, 0, sizeof(struct rtentry));
962
963     ((struct sockaddr_in *)&kernel_route.rt_dst)->sin_addr.s_addr = 0;
964     ((struct sockaddr_in *)&kernel_route.rt_dst)->sin_family = AF_INET;
965     ((struct sockaddr_in *)&kernel_route.rt_genmask)->sin_addr.s_addr = 0;
966     ((struct sockaddr_in *)&kernel_route.rt_genmask)->sin_family = AF_INET;
967
968     ((struct sockaddr_in *)&kernel_route.rt_gateway)->sin_addr.s_addr = INADDR_ANY;
969     ((struct sockaddr_in *)&kernel_route.rt_gateway)->sin_family = AF_INET;
970
971     kernel_route.rt_flags = RTF_UP | RTF_GATEWAY;
972
973     kernel_route.rt_dev = ifr->ifr_ifrn.ifrn_name;
974
975     if ((ioctl(s, SIOCDELRT, &kernel_route)) < 0)
976       OLSR_PRINTF(1, "NO\n");
977     else
978       OLSR_PRINTF(1, "YES\n");
979   }
980   close(s);
981   return 0;
982 }
983 #endif /* LINUX_POLICY_ROUTING */
984
985 /*
986  * Local Variables:
987  * c-basic-offset: 2
988  * indent-tabs-mode: nil
989  * End:
990  */