net/ipv4/fib_frontend.c

   1 /*
   2  * INET         An implementation of the TCP/IP protocol suite for the LINUX
   3  *              operating system.  INET is implemented using the  BSD Socket
   4  *              interface as the means of communication with the user level.
   5  *
   6  *              IPv4 Forwarding Information Base: FIB frontend.
   7  *
   8  * Version:     $Id: fib_frontend.c,v 1.21 1999/12/15 22:39:07 davem Exp $
   9  *
  10  * Authors:     Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  11  *
  12  *              This program is free software; you can redistribute it and/or
  13  *              modify it under the terms of the GNU General Public License
  14  *              as published by the Free Software Foundation; either version
  15  *              2 of the License, or (at your option) any later version.
  16  */
  17
  18 #include <linux/config.h>
  19 #include <asm/uaccess.h>
  20 #include <asm/system.h>
  21 #include <asm/bitops.h>
  22 #include <linux/types.h>
  23 #include <linux/kernel.h>
  24 #include <linux/sched.h>
  25 #include <linux/mm.h>
  26 #include <linux/string.h>
  27 #include <linux/socket.h>
  28 #include <linux/sockios.h>
  29 #include <linux/errno.h>
  30 #include <linux/in.h>
  31 #include <linux/inet.h>
  32 #include <linux/netdevice.h>
  33 #include <linux/if_arp.h>
  34 #include <linux/proc_fs.h>
  35 #include <linux/skbuff.h>
  36 #include <linux/netlink.h>
  37 #include <linux/init.h>
  38
  39 #include <net/ip.h>
  40 #include <net/protocol.h>
  41 #include <net/route.h>
  42 #include <net/tcp.h>
  43 #include <net/sock.h>
  44 #include <net/icmp.h>
  45 #include <net/arp.h>
  46 #include <net/ip_fib.h>
  47
  48 #define FFprint(a...) printk(KERN_DEBUG a)
  49
  50 #ifndef CONFIG_IP_MULTIPLE_TABLES
  51
  52 #define RT_TABLE_MIN RT_TABLE_MAIN
  53
  54 struct fib_table *local_table;
  55 struct fib_table *main_table;
  56
  57 #else
  58
  59 #define RT_TABLE_MIN 1
  60
  61 struct fib_table *fib_tables[RT_TABLE_MAX+1];
  62
  63 struct fib_table *__fib_new_table(int id)
  64 {
  65         struct fib_table *tb;
  66
  67         tb = fib_hash_init(id);
  68         if (!tb)
  69                 return NULL;
  70         fib_tables[id] = tb;
  71         return tb;
  72 }
  73
  74
  75 #endif /* CONFIG_IP_MULTIPLE_TABLES */
  76
  77
  78 void fib_flush(void)
  79 {
  80         int flushed = 0;
  81 #ifdef CONFIG_IP_MULTIPLE_TABLES
  82         struct fib_table *tb;
  83         int id;
  84
  85         for (id = RT_TABLE_MAX; id>0; id--) {
  86                 if ((tb = fib_get_table(id))==NULL)
  87                         continue;
  88                 flushed += tb->tb_flush(tb);
  89         }
  90 #else /* CONFIG_IP_MULTIPLE_TABLES */
  91         flushed += main_table->tb_flush(main_table);
  92         flushed += local_table->tb_flush(local_table);
  93 #endif /* CONFIG_IP_MULTIPLE_TABLES */
  94
  95         if (flushed)
  96                 rt_cache_flush(-1);
  97 }
  98
  99
 100 #ifdef CONFIG_PROC_FS
 101
 102 /*
 103  *      Called from the PROCfs module. This outputs /proc/net/route.
 104  *
 105  *      It always works in backward compatibility mode.
 106  *      The format of the file is not supposed to be changed.
 107  */
 108
 109 static int
 110 fib_get_procinfo(char *buffer, char **start, off_t offset, int length)
 111 {
 112         int first = offset/128;
 113         char *ptr = buffer;
 114         int count = (length+127)/128;
 115         int len;
 116
 117         *start = buffer + offset%128;
 118
 119         if (--first < 0) {
 120                 sprintf(buffer, "%-127s\n", "Iface\tDestination\tGateway \tFlags\tRefCnt\tUse\tMetric\tMask\t\tMTU\tWindow\tIRTT");
 121                 --count;
 122                 ptr += 128;
 123                 first = 0;
 124         }
 125
 126         if (main_table && count > 0) {
 127                 int n = main_table->tb_get_info(main_table, ptr, first, count);
 128                 count -= n;
 129                 ptr += n*128;
 130         }
 131         len = ptr - *start;
 132         if (len >= length)
 133                 return length;
 134         if (len >= 0)
 135                 return len;
 136         return 0;
 137 }
 138
 139 #endif /* CONFIG_PROC_FS */
 140
 141 /*
 142  *      Find the first device with a given source address.
 143  */
 144
 145 struct net_device * ip_dev_find(u32 addr)
 146 {
 147         struct rt_key key;
 148         struct fib_result res;
 149         struct net_device *dev = NULL;
 150
 151         memset(&key, 0, sizeof(key));
 152         key.dst = addr;
 153 #ifdef CONFIG_IP_MULTIPLE_TABLES
 154         res.r = NULL;
 155 #endif
 156
 157         if (!local_table || local_table->tb_lookup(local_table, &key, &res)) {
 158                 return NULL;
 159         }
 160         if (res.type != RTN_LOCAL)
 161                 goto out;
 162         dev = FIB_RES_DEV(res);
 163         if (dev)
 164                 atomic_inc(&dev->refcnt);
 165
 166 out:
 167         fib_res_put(&res);
 168         return dev;
 169 }
 170
 171 unsigned inet_addr_type(u32 addr)
 172 {
 173         struct rt_key           key;
 174         struct fib_result       res;
 175         unsigned ret = RTN_BROADCAST;
 176
 177         if (ZERONET(addr) || BADCLASS(addr))
 178                 return RTN_BROADCAST;
 179         if (MULTICAST(addr))
 180                 return RTN_MULTICAST;
 181
 182         memset(&key, 0, sizeof(key));
 183         key.dst = addr;
 184 #ifdef CONFIG_IP_MULTIPLE_TABLES
 185         res.r = NULL;
 186 #endif
 187
 188         if (local_table) {
 189                 ret = RTN_UNICAST;
 190                 if (local_table->tb_lookup(local_table, &key, &res) == 0) {
 191                         ret = res.type;
 192                         fib_res_put(&res);
 193                 }
 194         }
 195         return ret;
 196 }
 197
 198 /* Given (packet source, input interface) and optional (dst, oif, tos):
 199    - (main) check, that source is valid i.e. not broadcast or our local
 200      address.
 201    - figure out what "logical" interface this packet arrived
 202      and calculate "specific destination" address.
 203    - check, that packet arrived from expected physical interface.
 204  */
 205
 206 int fib_validate_source(u32 src, u32 dst, u8 tos, int oif,
 207                         struct net_device *dev, u32 *spec_dst, u32 *itag)
 208 {
 209         struct in_device *in_dev;
 210         struct rt_key key;
 211         struct fib_result res;
 212         int no_addr, rpf;
 213         int ret;
 214
 215         key.dst = src;
 216         key.src = dst;
 217         key.tos = tos;
 218         key.oif = 0;
 219         key.iif = oif;
 220         key.scope = RT_SCOPE_UNIVERSE;
 221
 222         no_addr = rpf = 0;
 223         read_lock(&inetdev_lock);
 224         in_dev = __in_dev_get(dev);
 225         if (in_dev) {
 226                 no_addr = in_dev->ifa_list == NULL;
 227                 rpf = IN_DEV_RPFILTER(in_dev);
 228         }
 229         read_unlock(&inetdev_lock);
 230
 231         if (in_dev == NULL)
 232                 goto e_inval;
 233
 234         if (fib_lookup(&key, &res))
 235                 goto last_resort;
 236         if (res.type != RTN_UNICAST)
 237                 goto e_inval_res;
 238         *spec_dst = FIB_RES_PREFSRC(res);
 239         if (itag)
 240                 fib_combine_itag(itag, &res);
 241 #ifdef CONFIG_IP_ROUTE_MULTIPATH
 242         if (FIB_RES_DEV(res) == dev || res.fi->fib_nhs > 1)
 243 #else
 244         if (FIB_RES_DEV(res) == dev)
 245 #endif
 246         {
 247                 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
 248                 fib_res_put(&res);
 249                 return ret;
 250         }
 251         fib_res_put(&res);
 252         if (no_addr)
 253                 goto last_resort;
 254         if (rpf)
 255                 goto e_inval;
 256         key.oif = dev->ifindex;
 257
 258         ret = 0;
 259         if (fib_lookup(&key, &res) == 0) {
 260                 if (res.type == RTN_UNICAST) {
 261                         *spec_dst = FIB_RES_PREFSRC(res);
 262                         ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
 263                 }
 264                 fib_res_put(&res);
 265         }
 266         return ret;
 267
 268 last_resort:
 269         if (rpf)
 270                 goto e_inval;
 271         *spec_dst = inet_select_addr(dev, 0, RT_SCOPE_UNIVERSE);
 272         *itag = 0;
 273         return 0;
 274
 275 e_inval_res:
 276         fib_res_put(&res);
 277 e_inval:
 278         return -EINVAL;
 279 }
 280
 281 #ifndef CONFIG_IP_NOSIOCRT
 282
 283 /*
 284  *      Handle IP routing ioctl calls. These are used to manipulate the routing tables
 285  */
 286
 287 int ip_rt_ioctl(unsigned int cmd, void *arg)
 288 {
 289         int err;
 290         struct kern_rta rta;
 291         struct rtentry  r;
 292         struct {
 293                 struct nlmsghdr nlh;
 294                 struct rtmsg    rtm;
 295         } req;
 296
 297         switch (cmd) {
 298         case SIOCADDRT:         /* Add a route */
 299         case SIOCDELRT:         /* Delete a route */
 300                 if (!capable(CAP_NET_ADMIN))
 301                         return -EPERM;
 302                 if (copy_from_user(&r, arg, sizeof(struct rtentry)))
 303                         return -EFAULT;
 304                 rtnl_lock();
 305                 err = fib_convert_rtentry(cmd, &req.nlh, &req.rtm, &rta, &r);
 306                 if (err == 0) {
 307                         if (cmd == SIOCDELRT) {
 308                                 struct fib_table *tb = fib_get_table(req.rtm.rtm_table);
 309                                 err = -ESRCH;
 310                                 if (tb)
 311                                         err = tb->tb_delete(tb, &req.rtm, &rta, &req.nlh, NULL);
 312                         } else {
 313                                 struct fib_table *tb = fib_new_table(req.rtm.rtm_table);
 314                                 err = -ENOBUFS;
 315                                 if (tb)
 316                                         err = tb->tb_insert(tb, &req.rtm, &rta, &req.nlh, NULL);
 317                         }
 318                         if (rta.rta_mx)
 319                                 kfree(rta.rta_mx);
 320                 }
 321                 rtnl_unlock();
 322                 return err;
 323         }
 324         return -EINVAL;
 325 }
 326
 327 #else
 328
 329 int ip_rt_ioctl(unsigned int cmd, void *arg)
 330 {
 331         return -EINVAL;
 332 }
 333
 334 #endif
 335
 336 #ifdef CONFIG_RTNETLINK
 337
 338 static int inet_check_attr(struct rtmsg *r, struct rtattr **rta)
 339 {
 340         int i;
 341
 342         for (i=1; i<=RTA_MAX; i++) {
 343                 struct rtattr *attr = rta[i-1];
 344                 if (attr) {
 345                         if (RTA_PAYLOAD(attr) < 4)
 346                                 return -EINVAL;
 347                         if (i != RTA_MULTIPATH && i != RTA_METRICS)
 348                                 rta[i-1] = (struct rtattr*)RTA_DATA(attr);
 349                 }
 350         }
 351         return 0;
 352 }
 353
 354 int inet_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
 355 {
 356         struct fib_table * tb;
 357         struct rtattr **rta = arg;
 358         struct rtmsg *r = NLMSG_DATA(nlh);
 359
 360         if (inet_check_attr(r, rta))
 361                 return -EINVAL;
 362
 363         tb = fib_get_table(r->rtm_table);
 364         if (tb)
 365                 return tb->tb_delete(tb, r, (struct kern_rta*)rta, nlh, &NETLINK_CB(skb));
 366         return -ESRCH;
 367 }
 368
 369 int inet_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
 370 {
 371         struct fib_table * tb;
 372         struct rtattr **rta = arg;
 373         struct rtmsg *r = NLMSG_DATA(nlh);
 374
 375         if (inet_check_attr(r, rta))
 376                 return -EINVAL;
 377
 378         tb = fib_new_table(r->rtm_table);
 379         if (tb)
 380                 return tb->tb_insert(tb, r, (struct kern_rta*)rta, nlh, &NETLINK_CB(skb));
 381         return -ENOBUFS;
 382 }
 383
 384 int inet_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)
 385 {
 386         int t;
 387         int s_t;
 388         struct fib_table *tb;
 389
 390         if (NLMSG_PAYLOAD(cb->nlh, 0) >= sizeof(struct rtmsg) &&
 391             ((struct rtmsg*)NLMSG_DATA(cb->nlh))->rtm_flags&RTM_F_CLONED)
 392                 return ip_rt_dump(skb, cb);
 393
 394         s_t = cb->args[0];
 395         if (s_t == 0)
 396                 s_t = cb->args[0] = RT_TABLE_MIN;
 397
 398         for (t=s_t; t<=RT_TABLE_MAX; t++) {
 399                 if (t < s_t) continue;
 400                 if (t > s_t)
 401                         memset(&cb->args[1], 0, sizeof(cb->args)-sizeof(cb->args[0]));
 402                 if ((tb = fib_get_table(t))==NULL)
 403                         continue;
 404                 if (tb->tb_dump(tb, skb, cb) < 0)
 405                         break;
 406         }
 407
 408         cb->args[0] = t;
 409
 410         return skb->len;
 411 }
 412
 413 #endif
 414
 415 /* Prepare and feed intra-kernel routing request.
 416    Really, it should be netlink message, but :-( netlink
 417    can be not configured, so that we feed it directly
 418    to fib engine. It is legal, because all events occur
 419    only when netlink is already locked.
 420  */
 421
 422 static void fib_magic(int cmd, int type, u32 dst, int dst_len, struct in_ifaddr *ifa)
 423 {
 424         struct fib_table * tb;
 425         struct {
 426                 struct nlmsghdr nlh;
 427                 struct rtmsg    rtm;
 428         } req;
 429         struct kern_rta rta;
 430
 431         memset(&req.rtm, 0, sizeof(req.rtm));
 432         memset(&rta, 0, sizeof(rta));
 433
 434         if (type == RTN_UNICAST)
 435                 tb = fib_new_table(RT_TABLE_MAIN);
 436         else
 437                 tb = fib_new_table(RT_TABLE_LOCAL);
 438
 439         if (tb == NULL)
 440                 return;
 441
 442         req.nlh.nlmsg_len = sizeof(req);
 443         req.nlh.nlmsg_type = cmd;
 444         req.nlh.nlmsg_flags = NLM_F_REQUEST|NLM_F_CREATE|NLM_F_APPEND;
 445         req.nlh.nlmsg_pid = 0;
 446         req.nlh.nlmsg_seq = 0;
 447
 448         req.rtm.rtm_dst_len = dst_len;
 449         req.rtm.rtm_table = tb->tb_id;
 450         req.rtm.rtm_protocol = RTPROT_KERNEL;
 451         req.rtm.rtm_scope = (type != RTN_LOCAL ? RT_SCOPE_LINK : RT_SCOPE_HOST);
 452         req.rtm.rtm_type = type;
 453
 454         rta.rta_dst = &dst;
 455         rta.rta_prefsrc = &ifa->ifa_local;
 456         rta.rta_oif = &ifa->ifa_dev->dev->ifindex;
 457
 458         if (cmd == RTM_NEWROUTE)
 459                 tb->tb_insert(tb, &req.rtm, &rta, &req.nlh, NULL);
 460         else
 461                 tb->tb_delete(tb, &req.rtm, &rta, &req.nlh, NULL);
 462 }
 463
 464 static void fib_add_ifaddr(struct in_ifaddr *ifa)
 465 {
 466         struct in_device *in_dev = ifa->ifa_dev;
 467         struct net_device *dev = in_dev->dev;
 468         struct in_ifaddr *prim = ifa;
 469         u32 mask = ifa->ifa_mask;
 470         u32 addr = ifa->ifa_local;
 471         u32 prefix = ifa->ifa_address&mask;
 472
 473         if (ifa->ifa_flags&IFA_F_SECONDARY) {
 474                 prim = inet_ifa_byprefix(in_dev, prefix, mask);
 475                 if (prim == NULL) {
 476                         printk(KERN_DEBUG "fib_add_ifaddr: bug: prim == NULL\n");
 477                         return;
 478                 }
 479         }
 480
 481         fib_magic(RTM_NEWROUTE, RTN_LOCAL, addr, 32, prim);
 482
 483         if (!(dev->flags&IFF_UP))
 484                 return;
 485
 486         /* Add broadcast address, if it is explicitly assigned. */
 487         if (ifa->ifa_broadcast && ifa->ifa_broadcast != 0xFFFFFFFF)
 488                 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
 489
 490         if (!ZERONET(prefix) && !(ifa->ifa_flags&IFA_F_SECONDARY) &&
 491             (prefix != addr || ifa->ifa_prefixlen < 32)) {
 492                 fib_magic(RTM_NEWROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
 493                           RTN_UNICAST, prefix, ifa->ifa_prefixlen, prim);
 494
 495                 /* Add network specific broadcasts, when it takes a sense */
 496                 if (ifa->ifa_prefixlen < 31) {
 497                         fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix, 32, prim);
 498                         fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix|~mask, 32, prim);
 499                 }
 500         }
 501 }
 502
 503 static void fib_del_ifaddr(struct in_ifaddr *ifa)
 504 {
 505         struct in_device *in_dev = ifa->ifa_dev;
 506         struct net_device *dev = in_dev->dev;
 507         struct in_ifaddr *ifa1;
 508         struct in_ifaddr *prim = ifa;
 509         u32 brd = ifa->ifa_address|~ifa->ifa_mask;
 510         u32 any = ifa->ifa_address&ifa->ifa_mask;
 511 #define LOCAL_OK        1
 512 #define BRD_OK          2
 513 #define BRD0_OK         4
 514 #define BRD1_OK         8
 515         unsigned ok = 0;
 516
 517         if (!(ifa->ifa_flags&IFA_F_SECONDARY))
 518                 fib_magic(RTM_DELROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
 519                           RTN_UNICAST, any, ifa->ifa_prefixlen, prim);
 520         else {
 521                 prim = inet_ifa_byprefix(in_dev, any, ifa->ifa_mask);
 522                 if (prim == NULL) {
 523                         printk(KERN_DEBUG "fib_del_ifaddr: bug: prim == NULL\n");
 524                         return;
 525                 }
 526         }
 527
 528         /* Deletion is more complicated than add.
 529            We should take care of not to delete too much :-)
 530
 531            Scan address list to be sure that addresses are really gone.
 532          */
 533
 534         for (ifa1 = in_dev->ifa_list; ifa1; ifa1 = ifa1->ifa_next) {
 535                 if (ifa->ifa_local == ifa1->ifa_local)
 536                         ok |= LOCAL_OK;
 537                 if (ifa->ifa_broadcast == ifa1->ifa_broadcast)
 538                         ok |= BRD_OK;
 539                 if (brd == ifa1->ifa_broadcast)
 540                         ok |= BRD1_OK;
 541                 if (any == ifa1->ifa_broadcast)
 542                         ok |= BRD0_OK;
 543         }
 544
 545         if (!(ok&BRD_OK))
 546                 fib_magic(RTM_DELROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
 547         if (!(ok&BRD1_OK))
 548                 fib_magic(RTM_DELROUTE, RTN_BROADCAST, brd, 32, prim);
 549         if (!(ok&BRD0_OK))
 550                 fib_magic(RTM_DELROUTE, RTN_BROADCAST, any, 32, prim);
 551         if (!(ok&LOCAL_OK)) {
 552                 fib_magic(RTM_DELROUTE, RTN_LOCAL, ifa->ifa_local, 32, prim);
 553
 554                 /* Check, that this local address finally disappeared. */
 555                 if (inet_addr_type(ifa->ifa_local) != RTN_LOCAL) {
 556                         /* And the last, but not the least thing.
 557                            We must flush stray FIB entries.
 558
 559                            First of all, we scan fib_info list searching
 560                            for stray nexthop entries, then ignite fib_flush.
 561                         */
 562                         if (fib_sync_down(ifa->ifa_local, NULL, 0))
 563                                 fib_flush();
 564                 }
 565         }
 566 #undef LOCAL_OK
 567 #undef BRD_OK
 568 #undef BRD0_OK
 569 #undef BRD1_OK
 570 }
 571
 572 static void fib_disable_ip(struct net_device *dev, int force)
 573 {
 574         if (fib_sync_down(0, dev, force))
 575                 fib_flush();
 576         rt_cache_flush(0);
 577         arp_ifdown(dev);
 578 }
 579
 580 static int fib_inetaddr_event(struct notifier_block *this, unsigned long event, void *ptr)
 581 {
 582         struct in_ifaddr *ifa = (struct in_ifaddr*)ptr;
 583
 584         switch (event) {
 585         case NETDEV_UP:
 586                 fib_add_ifaddr(ifa);
 587                 rt_cache_flush(-1);
 588                 break;
 589         case NETDEV_DOWN:
 590                 if (ifa->ifa_dev && ifa->ifa_dev->ifa_list == NULL) {
 591                         /* Last address was deleted from this interface.
 592                            Disable IP.
 593                          */
 594                         fib_disable_ip(ifa->ifa_dev->dev, 1);
 595                 } else {
 596                         fib_del_ifaddr(ifa);
 597                         rt_cache_flush(-1);
 598                 }
 599                 break;
 600         }
 601         return NOTIFY_DONE;
 602 }
 603
 604 static int fib_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
 605 {
 606         struct net_device *dev = ptr;
 607         struct in_device *in_dev = __in_dev_get(dev);
 608
 609         if (!in_dev)
 610                 return NOTIFY_DONE;
 611
 612         switch (event) {
 613         case NETDEV_UP:
 614                 for_ifa(in_dev) {
 615                         fib_add_ifaddr(ifa);
 616                 } endfor_ifa(in_dev);
 617 #ifdef CONFIG_IP_ROUTE_MULTIPATH
 618                 fib_sync_up(dev);
 619 #endif
 620                 rt_cache_flush(-1);
 621                 break;
 622         case NETDEV_DOWN:
 623                 fib_disable_ip(dev, 0);
 624                 break;
 625         case NETDEV_UNREGISTER:
 626                 fib_disable_ip(dev, 1);
 627                 break;
 628         case NETDEV_CHANGEMTU:
 629         case NETDEV_CHANGE:
 630                 rt_cache_flush(0);
 631                 break;
 632         }
 633         return NOTIFY_DONE;
 634 }
 635
 636 struct notifier_block fib_inetaddr_notifier = {
 637         fib_inetaddr_event,
 638         NULL,
 639         0
 640 };
 641
 642 struct notifier_block fib_netdev_notifier = {
 643         fib_netdev_event,
 644         NULL,
 645         0
 646 };
 647
 648 void __init ip_fib_init(void)
 649 {
 650 #ifdef CONFIG_PROC_FS
 651         proc_net_create("route",0,fib_get_procinfo);
 652 #endif          /* CONFIG_PROC_FS */
 653
 654 #ifndef CONFIG_IP_MULTIPLE_TABLES
 655         local_table = fib_hash_init(RT_TABLE_LOCAL);
 656         main_table = fib_hash_init(RT_TABLE_MAIN);
 657 #else
 658         fib_rules_init();
 659 #endif
 660
 661         register_netdevice_notifier(&fib_netdev_notifier);
 662         register_inetaddr_notifier(&fib_inetaddr_notifier);
 663 }
 664