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 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru> 9 * 10 * This program is free software; you can redistribute it and/or 11 * modify it under the terms of the GNU General Public License 12 * as published by the Free Software Foundation; either version 13 * 2 of the License, or (at your option) any later version. 14 */ 15 16 #include <linux/module.h> 17 #include <asm/uaccess.h> 18 #include <asm/system.h> 19 #include <linux/bitops.h> 20 #include <linux/capability.h> 21 #include <linux/types.h> 22 #include <linux/kernel.h> 23 #include <linux/mm.h> 24 #include <linux/string.h> 25 #include <linux/socket.h> 26 #include <linux/sockios.h> 27 #include <linux/errno.h> 28 #include <linux/in.h> 29 #include <linux/inet.h> 30 #include <linux/inetdevice.h> 31 #include <linux/netdevice.h> 32 #include <linux/if_addr.h> 33 #include <linux/if_arp.h> 34 #include <linux/skbuff.h> 35 #include <linux/init.h> 36 #include <linux/list.h> 37 38 #include <net/ip.h> 39 #include <net/protocol.h> 40 #include <net/route.h> 41 #include <net/tcp.h> 42 #include <net/sock.h> 43 #include <net/arp.h> 44 #include <net/ip_fib.h> 45 #include <net/rtnetlink.h> 46 47 #ifndef CONFIG_IP_MULTIPLE_TABLES 48 49 static int __net_init fib4_rules_init(struct net *net) 50 { 51 struct fib_table *local_table, *main_table; 52 53 local_table = fib_hash_table(RT_TABLE_LOCAL); 54 if (local_table == NULL) 55 return -ENOMEM; 56 57 main_table = fib_hash_table(RT_TABLE_MAIN); 58 if (main_table == NULL) 59 goto fail; 60 61 hlist_add_head_rcu(&local_table->tb_hlist, 62 &net->ipv4.fib_table_hash[TABLE_LOCAL_INDEX]); 63 hlist_add_head_rcu(&main_table->tb_hlist, 64 &net->ipv4.fib_table_hash[TABLE_MAIN_INDEX]); 65 return 0; 66 67 fail: 68 kfree(local_table); 69 return -ENOMEM; 70 } 71 #else 72 73 struct fib_table *fib_new_table(struct net *net, u32 id) 74 { 75 struct fib_table *tb; 76 unsigned int h; 77 78 if (id == 0) 79 id = RT_TABLE_MAIN; 80 tb = fib_get_table(net, id); 81 if (tb) 82 return tb; 83 84 tb = fib_hash_table(id); 85 if (!tb) 86 return NULL; 87 h = id & (FIB_TABLE_HASHSZ - 1); 88 hlist_add_head_rcu(&tb->tb_hlist, &net->ipv4.fib_table_hash[h]); 89 return tb; 90 } 91 92 struct fib_table *fib_get_table(struct net *net, u32 id) 93 { 94 struct fib_table *tb; 95 struct hlist_node *node; 96 struct hlist_head *head; 97 unsigned int h; 98 99 if (id == 0) 100 id = RT_TABLE_MAIN; 101 h = id & (FIB_TABLE_HASHSZ - 1); 102 103 rcu_read_lock(); 104 head = &net->ipv4.fib_table_hash[h]; 105 hlist_for_each_entry_rcu(tb, node, head, tb_hlist) { 106 if (tb->tb_id == id) { 107 rcu_read_unlock(); 108 return tb; 109 } 110 } 111 rcu_read_unlock(); 112 return NULL; 113 } 114 #endif /* CONFIG_IP_MULTIPLE_TABLES */ 115 116 void fib_select_default(struct net *net, 117 const struct flowi *flp, struct fib_result *res) 118 { 119 struct fib_table *tb; 120 int table = RT_TABLE_MAIN; 121 #ifdef CONFIG_IP_MULTIPLE_TABLES 122 if (res->r == NULL || res->r->action != FR_ACT_TO_TBL) 123 return; 124 table = res->r->table; 125 #endif 126 tb = fib_get_table(net, table); 127 if (FIB_RES_GW(*res) && FIB_RES_NH(*res).nh_scope == RT_SCOPE_LINK) 128 fib_table_select_default(tb, flp, res); 129 } 130 131 static void fib_flush(struct net *net) 132 { 133 int flushed = 0; 134 struct fib_table *tb; 135 struct hlist_node *node; 136 struct hlist_head *head; 137 unsigned int h; 138 139 for (h = 0; h < FIB_TABLE_HASHSZ; h++) { 140 head = &net->ipv4.fib_table_hash[h]; 141 hlist_for_each_entry(tb, node, head, tb_hlist) 142 flushed += fib_table_flush(tb); 143 } 144 145 if (flushed) 146 rt_cache_flush(net, -1); 147 } 148 149 /* 150 * Find the first device with a given source address. 151 */ 152 153 struct net_device * ip_dev_find(struct net *net, __be32 addr) 154 { 155 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = addr } } }; 156 struct fib_result res; 157 struct net_device *dev = NULL; 158 struct fib_table *local_table; 159 160 #ifdef CONFIG_IP_MULTIPLE_TABLES 161 res.r = NULL; 162 #endif 163 164 local_table = fib_get_table(net, RT_TABLE_LOCAL); 165 if (!local_table || fib_table_lookup(local_table, &fl, &res)) 166 return NULL; 167 if (res.type != RTN_LOCAL) 168 goto out; 169 dev = FIB_RES_DEV(res); 170 171 if (dev) 172 dev_hold(dev); 173 out: 174 fib_res_put(&res); 175 return dev; 176 } 177 178 /* 179 * Find address type as if only "dev" was present in the system. If 180 * on_dev is NULL then all interfaces are taken into consideration. 181 */ 182 static inline unsigned __inet_dev_addr_type(struct net *net, 183 const struct net_device *dev, 184 __be32 addr) 185 { 186 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = addr } } }; 187 struct fib_result res; 188 unsigned ret = RTN_BROADCAST; 189 struct fib_table *local_table; 190 191 if (ipv4_is_zeronet(addr) || ipv4_is_lbcast(addr)) 192 return RTN_BROADCAST; 193 if (ipv4_is_multicast(addr)) 194 return RTN_MULTICAST; 195 196 #ifdef CONFIG_IP_MULTIPLE_TABLES 197 res.r = NULL; 198 #endif 199 200 local_table = fib_get_table(net, RT_TABLE_LOCAL); 201 if (local_table) { 202 ret = RTN_UNICAST; 203 if (!fib_table_lookup(local_table, &fl, &res)) { 204 if (!dev || dev == res.fi->fib_dev) 205 ret = res.type; 206 fib_res_put(&res); 207 } 208 } 209 return ret; 210 } 211 212 unsigned int inet_addr_type(struct net *net, __be32 addr) 213 { 214 return __inet_dev_addr_type(net, NULL, addr); 215 } 216 217 unsigned int inet_dev_addr_type(struct net *net, const struct net_device *dev, 218 __be32 addr) 219 { 220 return __inet_dev_addr_type(net, dev, addr); 221 } 222 223 /* Given (packet source, input interface) and optional (dst, oif, tos): 224 - (main) check, that source is valid i.e. not broadcast or our local 225 address. 226 - figure out what "logical" interface this packet arrived 227 and calculate "specific destination" address. 228 - check, that packet arrived from expected physical interface. 229 */ 230 231 int fib_validate_source(__be32 src, __be32 dst, u8 tos, int oif, 232 struct net_device *dev, __be32 *spec_dst, 233 u32 *itag, u32 mark) 234 { 235 struct in_device *in_dev; 236 struct flowi fl = { .nl_u = { .ip4_u = 237 { .daddr = src, 238 .saddr = dst, 239 .tos = tos } }, 240 .mark = mark, 241 .iif = oif }; 242 243 struct fib_result res; 244 int no_addr, rpf, accept_local; 245 int ret; 246 struct net *net; 247 248 no_addr = rpf = accept_local = 0; 249 rcu_read_lock(); 250 in_dev = __in_dev_get_rcu(dev); 251 if (in_dev) { 252 no_addr = in_dev->ifa_list == NULL; 253 rpf = IN_DEV_RPFILTER(in_dev); 254 accept_local = IN_DEV_ACCEPT_LOCAL(in_dev); 255 } 256 rcu_read_unlock(); 257 258 if (in_dev == NULL) 259 goto e_inval; 260 261 net = dev_net(dev); 262 if (fib_lookup(net, &fl, &res)) 263 goto last_resort; 264 if (res.type != RTN_UNICAST) { 265 if (res.type != RTN_LOCAL || !accept_local) 266 goto e_inval_res; 267 } 268 *spec_dst = FIB_RES_PREFSRC(res); 269 fib_combine_itag(itag, &res); 270 #ifdef CONFIG_IP_ROUTE_MULTIPATH 271 if (FIB_RES_DEV(res) == dev || res.fi->fib_nhs > 1) 272 #else 273 if (FIB_RES_DEV(res) == dev) 274 #endif 275 { 276 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST; 277 fib_res_put(&res); 278 return ret; 279 } 280 fib_res_put(&res); 281 if (no_addr) 282 goto last_resort; 283 if (rpf == 1) 284 goto e_inval; 285 fl.oif = dev->ifindex; 286 287 ret = 0; 288 if (fib_lookup(net, &fl, &res) == 0) { 289 if (res.type == RTN_UNICAST) { 290 *spec_dst = FIB_RES_PREFSRC(res); 291 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST; 292 } 293 fib_res_put(&res); 294 } 295 return ret; 296 297 last_resort: 298 if (rpf) 299 goto e_inval; 300 *spec_dst = inet_select_addr(dev, 0, RT_SCOPE_UNIVERSE); 301 *itag = 0; 302 return 0; 303 304 e_inval_res: 305 fib_res_put(&res); 306 e_inval: 307 return -EINVAL; 308 } 309 310 static inline __be32 sk_extract_addr(struct sockaddr *addr) 311 { 312 return ((struct sockaddr_in *) addr)->sin_addr.s_addr; 313 } 314 315 static int put_rtax(struct nlattr *mx, int len, int type, u32 value) 316 { 317 struct nlattr *nla; 318 319 nla = (struct nlattr *) ((char *) mx + len); 320 nla->nla_type = type; 321 nla->nla_len = nla_attr_size(4); 322 *(u32 *) nla_data(nla) = value; 323 324 return len + nla_total_size(4); 325 } 326 327 static int rtentry_to_fib_config(struct net *net, int cmd, struct rtentry *rt, 328 struct fib_config *cfg) 329 { 330 __be32 addr; 331 int plen; 332 333 memset(cfg, 0, sizeof(*cfg)); 334 cfg->fc_nlinfo.nl_net = net; 335 336 if (rt->rt_dst.sa_family != AF_INET) 337 return -EAFNOSUPPORT; 338 339 /* 340 * Check mask for validity: 341 * a) it must be contiguous. 342 * b) destination must have all host bits clear. 343 * c) if application forgot to set correct family (AF_INET), 344 * reject request unless it is absolutely clear i.e. 345 * both family and mask are zero. 346 */ 347 plen = 32; 348 addr = sk_extract_addr(&rt->rt_dst); 349 if (!(rt->rt_flags & RTF_HOST)) { 350 __be32 mask = sk_extract_addr(&rt->rt_genmask); 351 352 if (rt->rt_genmask.sa_family != AF_INET) { 353 if (mask || rt->rt_genmask.sa_family) 354 return -EAFNOSUPPORT; 355 } 356 357 if (bad_mask(mask, addr)) 358 return -EINVAL; 359 360 plen = inet_mask_len(mask); 361 } 362 363 cfg->fc_dst_len = plen; 364 cfg->fc_dst = addr; 365 366 if (cmd != SIOCDELRT) { 367 cfg->fc_nlflags = NLM_F_CREATE; 368 cfg->fc_protocol = RTPROT_BOOT; 369 } 370 371 if (rt->rt_metric) 372 cfg->fc_priority = rt->rt_metric - 1; 373 374 if (rt->rt_flags & RTF_REJECT) { 375 cfg->fc_scope = RT_SCOPE_HOST; 376 cfg->fc_type = RTN_UNREACHABLE; 377 return 0; 378 } 379 380 cfg->fc_scope = RT_SCOPE_NOWHERE; 381 cfg->fc_type = RTN_UNICAST; 382 383 if (rt->rt_dev) { 384 char *colon; 385 struct net_device *dev; 386 char devname[IFNAMSIZ]; 387 388 if (copy_from_user(devname, rt->rt_dev, IFNAMSIZ-1)) 389 return -EFAULT; 390 391 devname[IFNAMSIZ-1] = 0; 392 colon = strchr(devname, ':'); 393 if (colon) 394 *colon = 0; 395 dev = __dev_get_by_name(net, devname); 396 if (!dev) 397 return -ENODEV; 398 cfg->fc_oif = dev->ifindex; 399 if (colon) { 400 struct in_ifaddr *ifa; 401 struct in_device *in_dev = __in_dev_get_rtnl(dev); 402 if (!in_dev) 403 return -ENODEV; 404 *colon = ':'; 405 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) 406 if (strcmp(ifa->ifa_label, devname) == 0) 407 break; 408 if (ifa == NULL) 409 return -ENODEV; 410 cfg->fc_prefsrc = ifa->ifa_local; 411 } 412 } 413 414 addr = sk_extract_addr(&rt->rt_gateway); 415 if (rt->rt_gateway.sa_family == AF_INET && addr) { 416 cfg->fc_gw = addr; 417 if (rt->rt_flags & RTF_GATEWAY && 418 inet_addr_type(net, addr) == RTN_UNICAST) 419 cfg->fc_scope = RT_SCOPE_UNIVERSE; 420 } 421 422 if (cmd == SIOCDELRT) 423 return 0; 424 425 if (rt->rt_flags & RTF_GATEWAY && !cfg->fc_gw) 426 return -EINVAL; 427 428 if (cfg->fc_scope == RT_SCOPE_NOWHERE) 429 cfg->fc_scope = RT_SCOPE_LINK; 430 431 if (rt->rt_flags & (RTF_MTU | RTF_WINDOW | RTF_IRTT)) { 432 struct nlattr *mx; 433 int len = 0; 434 435 mx = kzalloc(3 * nla_total_size(4), GFP_KERNEL); 436 if (mx == NULL) 437 return -ENOMEM; 438 439 if (rt->rt_flags & RTF_MTU) 440 len = put_rtax(mx, len, RTAX_ADVMSS, rt->rt_mtu - 40); 441 442 if (rt->rt_flags & RTF_WINDOW) 443 len = put_rtax(mx, len, RTAX_WINDOW, rt->rt_window); 444 445 if (rt->rt_flags & RTF_IRTT) 446 len = put_rtax(mx, len, RTAX_RTT, rt->rt_irtt << 3); 447 448 cfg->fc_mx = mx; 449 cfg->fc_mx_len = len; 450 } 451 452 return 0; 453 } 454 455 /* 456 * Handle IP routing ioctl calls. These are used to manipulate the routing tables 457 */ 458 459 int ip_rt_ioctl(struct net *net, unsigned int cmd, void __user *arg) 460 { 461 struct fib_config cfg; 462 struct rtentry rt; 463 int err; 464 465 switch (cmd) { 466 case SIOCADDRT: /* Add a route */ 467 case SIOCDELRT: /* Delete a route */ 468 if (!capable(CAP_NET_ADMIN)) 469 return -EPERM; 470 471 if (copy_from_user(&rt, arg, sizeof(rt))) 472 return -EFAULT; 473 474 rtnl_lock(); 475 err = rtentry_to_fib_config(net, cmd, &rt, &cfg); 476 if (err == 0) { 477 struct fib_table *tb; 478 479 if (cmd == SIOCDELRT) { 480 tb = fib_get_table(net, cfg.fc_table); 481 if (tb) 482 err = fib_table_delete(tb, &cfg); 483 else 484 err = -ESRCH; 485 } else { 486 tb = fib_new_table(net, cfg.fc_table); 487 if (tb) 488 err = fib_table_insert(tb, &cfg); 489 else 490 err = -ENOBUFS; 491 } 492 493 /* allocated by rtentry_to_fib_config() */ 494 kfree(cfg.fc_mx); 495 } 496 rtnl_unlock(); 497 return err; 498 } 499 return -EINVAL; 500 } 501 502 const struct nla_policy rtm_ipv4_policy[RTA_MAX+1] = { 503 [RTA_DST] = { .type = NLA_U32 }, 504 [RTA_SRC] = { .type = NLA_U32 }, 505 [RTA_IIF] = { .type = NLA_U32 }, 506 [RTA_OIF] = { .type = NLA_U32 }, 507 [RTA_GATEWAY] = { .type = NLA_U32 }, 508 [RTA_PRIORITY] = { .type = NLA_U32 }, 509 [RTA_PREFSRC] = { .type = NLA_U32 }, 510 [RTA_METRICS] = { .type = NLA_NESTED }, 511 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) }, 512 [RTA_FLOW] = { .type = NLA_U32 }, 513 }; 514 515 static int rtm_to_fib_config(struct net *net, struct sk_buff *skb, 516 struct nlmsghdr *nlh, struct fib_config *cfg) 517 { 518 struct nlattr *attr; 519 int err, remaining; 520 struct rtmsg *rtm; 521 522 err = nlmsg_validate(nlh, sizeof(*rtm), RTA_MAX, rtm_ipv4_policy); 523 if (err < 0) 524 goto errout; 525 526 memset(cfg, 0, sizeof(*cfg)); 527 528 rtm = nlmsg_data(nlh); 529 cfg->fc_dst_len = rtm->rtm_dst_len; 530 cfg->fc_tos = rtm->rtm_tos; 531 cfg->fc_table = rtm->rtm_table; 532 cfg->fc_protocol = rtm->rtm_protocol; 533 cfg->fc_scope = rtm->rtm_scope; 534 cfg->fc_type = rtm->rtm_type; 535 cfg->fc_flags = rtm->rtm_flags; 536 cfg->fc_nlflags = nlh->nlmsg_flags; 537 538 cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid; 539 cfg->fc_nlinfo.nlh = nlh; 540 cfg->fc_nlinfo.nl_net = net; 541 542 if (cfg->fc_type > RTN_MAX) { 543 err = -EINVAL; 544 goto errout; 545 } 546 547 nlmsg_for_each_attr(attr, nlh, sizeof(struct rtmsg), remaining) { 548 switch (nla_type(attr)) { 549 case RTA_DST: 550 cfg->fc_dst = nla_get_be32(attr); 551 break; 552 case RTA_OIF: 553 cfg->fc_oif = nla_get_u32(attr); 554 break; 555 case RTA_GATEWAY: 556 cfg->fc_gw = nla_get_be32(attr); 557 break; 558 case RTA_PRIORITY: 559 cfg->fc_priority = nla_get_u32(attr); 560 break; 561 case RTA_PREFSRC: 562 cfg->fc_prefsrc = nla_get_be32(attr); 563 break; 564 case RTA_METRICS: 565 cfg->fc_mx = nla_data(attr); 566 cfg->fc_mx_len = nla_len(attr); 567 break; 568 case RTA_MULTIPATH: 569 cfg->fc_mp = nla_data(attr); 570 cfg->fc_mp_len = nla_len(attr); 571 break; 572 case RTA_FLOW: 573 cfg->fc_flow = nla_get_u32(attr); 574 break; 575 case RTA_TABLE: 576 cfg->fc_table = nla_get_u32(attr); 577 break; 578 } 579 } 580 581 return 0; 582 errout: 583 return err; 584 } 585 586 static int inet_rtm_delroute(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg) 587 { 588 struct net *net = sock_net(skb->sk); 589 struct fib_config cfg; 590 struct fib_table *tb; 591 int err; 592 593 err = rtm_to_fib_config(net, skb, nlh, &cfg); 594 if (err < 0) 595 goto errout; 596 597 tb = fib_get_table(net, cfg.fc_table); 598 if (tb == NULL) { 599 err = -ESRCH; 600 goto errout; 601 } 602 603 err = fib_table_delete(tb, &cfg); 604 errout: 605 return err; 606 } 607 608 static int inet_rtm_newroute(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg) 609 { 610 struct net *net = sock_net(skb->sk); 611 struct fib_config cfg; 612 struct fib_table *tb; 613 int err; 614 615 err = rtm_to_fib_config(net, skb, nlh, &cfg); 616 if (err < 0) 617 goto errout; 618 619 tb = fib_new_table(net, cfg.fc_table); 620 if (tb == NULL) { 621 err = -ENOBUFS; 622 goto errout; 623 } 624 625 err = fib_table_insert(tb, &cfg); 626 errout: 627 return err; 628 } 629 630 static int inet_dump_fib(struct sk_buff *skb, struct netlink_callback *cb) 631 { 632 struct net *net = sock_net(skb->sk); 633 unsigned int h, s_h; 634 unsigned int e = 0, s_e; 635 struct fib_table *tb; 636 struct hlist_node *node; 637 struct hlist_head *head; 638 int dumped = 0; 639 640 if (nlmsg_len(cb->nlh) >= sizeof(struct rtmsg) && 641 ((struct rtmsg *) nlmsg_data(cb->nlh))->rtm_flags & RTM_F_CLONED) 642 return ip_rt_dump(skb, cb); 643 644 s_h = cb->args[0]; 645 s_e = cb->args[1]; 646 647 for (h = s_h; h < FIB_TABLE_HASHSZ; h++, s_e = 0) { 648 e = 0; 649 head = &net->ipv4.fib_table_hash[h]; 650 hlist_for_each_entry(tb, node, head, tb_hlist) { 651 if (e < s_e) 652 goto next; 653 if (dumped) 654 memset(&cb->args[2], 0, sizeof(cb->args) - 655 2 * sizeof(cb->args[0])); 656 if (fib_table_dump(tb, skb, cb) < 0) 657 goto out; 658 dumped = 1; 659 next: 660 e++; 661 } 662 } 663 out: 664 cb->args[1] = e; 665 cb->args[0] = h; 666 667 return skb->len; 668 } 669 670 /* Prepare and feed intra-kernel routing request. 671 Really, it should be netlink message, but :-( netlink 672 can be not configured, so that we feed it directly 673 to fib engine. It is legal, because all events occur 674 only when netlink is already locked. 675 */ 676 677 static void fib_magic(int cmd, int type, __be32 dst, int dst_len, struct in_ifaddr *ifa) 678 { 679 struct net *net = dev_net(ifa->ifa_dev->dev); 680 struct fib_table *tb; 681 struct fib_config cfg = { 682 .fc_protocol = RTPROT_KERNEL, 683 .fc_type = type, 684 .fc_dst = dst, 685 .fc_dst_len = dst_len, 686 .fc_prefsrc = ifa->ifa_local, 687 .fc_oif = ifa->ifa_dev->dev->ifindex, 688 .fc_nlflags = NLM_F_CREATE | NLM_F_APPEND, 689 .fc_nlinfo = { 690 .nl_net = net, 691 }, 692 }; 693 694 if (type == RTN_UNICAST) 695 tb = fib_new_table(net, RT_TABLE_MAIN); 696 else 697 tb = fib_new_table(net, RT_TABLE_LOCAL); 698 699 if (tb == NULL) 700 return; 701 702 cfg.fc_table = tb->tb_id; 703 704 if (type != RTN_LOCAL) 705 cfg.fc_scope = RT_SCOPE_LINK; 706 else 707 cfg.fc_scope = RT_SCOPE_HOST; 708 709 if (cmd == RTM_NEWROUTE) 710 fib_table_insert(tb, &cfg); 711 else 712 fib_table_delete(tb, &cfg); 713 } 714 715 void fib_add_ifaddr(struct in_ifaddr *ifa) 716 { 717 struct in_device *in_dev = ifa->ifa_dev; 718 struct net_device *dev = in_dev->dev; 719 struct in_ifaddr *prim = ifa; 720 __be32 mask = ifa->ifa_mask; 721 __be32 addr = ifa->ifa_local; 722 __be32 prefix = ifa->ifa_address&mask; 723 724 if (ifa->ifa_flags&IFA_F_SECONDARY) { 725 prim = inet_ifa_byprefix(in_dev, prefix, mask); 726 if (prim == NULL) { 727 printk(KERN_WARNING "fib_add_ifaddr: bug: prim == NULL\n"); 728 return; 729 } 730 } 731 732 fib_magic(RTM_NEWROUTE, RTN_LOCAL, addr, 32, prim); 733 734 if (!(dev->flags&IFF_UP)) 735 return; 736 737 /* Add broadcast address, if it is explicitly assigned. */ 738 if (ifa->ifa_broadcast && ifa->ifa_broadcast != htonl(0xFFFFFFFF)) 739 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim); 740 741 if (!ipv4_is_zeronet(prefix) && !(ifa->ifa_flags&IFA_F_SECONDARY) && 742 (prefix != addr || ifa->ifa_prefixlen < 32)) { 743 fib_magic(RTM_NEWROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL : 744 RTN_UNICAST, prefix, ifa->ifa_prefixlen, prim); 745 746 /* Add network specific broadcasts, when it takes a sense */ 747 if (ifa->ifa_prefixlen < 31) { 748 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix, 32, prim); 749 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix|~mask, 32, prim); 750 } 751 } 752 } 753 754 static void fib_del_ifaddr(struct in_ifaddr *ifa) 755 { 756 struct in_device *in_dev = ifa->ifa_dev; 757 struct net_device *dev = in_dev->dev; 758 struct in_ifaddr *ifa1; 759 struct in_ifaddr *prim = ifa; 760 __be32 brd = ifa->ifa_address|~ifa->ifa_mask; 761 __be32 any = ifa->ifa_address&ifa->ifa_mask; 762 #define LOCAL_OK 1 763 #define BRD_OK 2 764 #define BRD0_OK 4 765 #define BRD1_OK 8 766 unsigned ok = 0; 767 768 if (!(ifa->ifa_flags&IFA_F_SECONDARY)) 769 fib_magic(RTM_DELROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL : 770 RTN_UNICAST, any, ifa->ifa_prefixlen, prim); 771 else { 772 prim = inet_ifa_byprefix(in_dev, any, ifa->ifa_mask); 773 if (prim == NULL) { 774 printk(KERN_WARNING "fib_del_ifaddr: bug: prim == NULL\n"); 775 return; 776 } 777 } 778 779 /* Deletion is more complicated than add. 780 We should take care of not to delete too much :-) 781 782 Scan address list to be sure that addresses are really gone. 783 */ 784 785 for (ifa1 = in_dev->ifa_list; ifa1; ifa1 = ifa1->ifa_next) { 786 if (ifa->ifa_local == ifa1->ifa_local) 787 ok |= LOCAL_OK; 788 if (ifa->ifa_broadcast == ifa1->ifa_broadcast) 789 ok |= BRD_OK; 790 if (brd == ifa1->ifa_broadcast) 791 ok |= BRD1_OK; 792 if (any == ifa1->ifa_broadcast) 793 ok |= BRD0_OK; 794 } 795 796 if (!(ok&BRD_OK)) 797 fib_magic(RTM_DELROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim); 798 if (!(ok&BRD1_OK)) 799 fib_magic(RTM_DELROUTE, RTN_BROADCAST, brd, 32, prim); 800 if (!(ok&BRD0_OK)) 801 fib_magic(RTM_DELROUTE, RTN_BROADCAST, any, 32, prim); 802 if (!(ok&LOCAL_OK)) { 803 fib_magic(RTM_DELROUTE, RTN_LOCAL, ifa->ifa_local, 32, prim); 804 805 /* Check, that this local address finally disappeared. */ 806 if (inet_addr_type(dev_net(dev), ifa->ifa_local) != RTN_LOCAL) { 807 /* And the last, but not the least thing. 808 We must flush stray FIB entries. 809 810 First of all, we scan fib_info list searching 811 for stray nexthop entries, then ignite fib_flush. 812 */ 813 if (fib_sync_down_addr(dev_net(dev), ifa->ifa_local)) 814 fib_flush(dev_net(dev)); 815 } 816 } 817 #undef LOCAL_OK 818 #undef BRD_OK 819 #undef BRD0_OK 820 #undef BRD1_OK 821 } 822 823 static void nl_fib_lookup(struct fib_result_nl *frn, struct fib_table *tb ) 824 { 825 826 struct fib_result res; 827 struct flowi fl = { .mark = frn->fl_mark, 828 .nl_u = { .ip4_u = { .daddr = frn->fl_addr, 829 .tos = frn->fl_tos, 830 .scope = frn->fl_scope } } }; 831 832 #ifdef CONFIG_IP_MULTIPLE_TABLES 833 res.r = NULL; 834 #endif 835 836 frn->err = -ENOENT; 837 if (tb) { 838 local_bh_disable(); 839 840 frn->tb_id = tb->tb_id; 841 frn->err = fib_table_lookup(tb, &fl, &res); 842 843 if (!frn->err) { 844 frn->prefixlen = res.prefixlen; 845 frn->nh_sel = res.nh_sel; 846 frn->type = res.type; 847 frn->scope = res.scope; 848 fib_res_put(&res); 849 } 850 local_bh_enable(); 851 } 852 } 853 854 static void nl_fib_input(struct sk_buff *skb) 855 { 856 struct net *net; 857 struct fib_result_nl *frn; 858 struct nlmsghdr *nlh; 859 struct fib_table *tb; 860 u32 pid; 861 862 net = sock_net(skb->sk); 863 nlh = nlmsg_hdr(skb); 864 if (skb->len < NLMSG_SPACE(0) || skb->len < nlh->nlmsg_len || 865 nlh->nlmsg_len < NLMSG_LENGTH(sizeof(*frn))) 866 return; 867 868 skb = skb_clone(skb, GFP_KERNEL); 869 if (skb == NULL) 870 return; 871 nlh = nlmsg_hdr(skb); 872 873 frn = (struct fib_result_nl *) NLMSG_DATA(nlh); 874 tb = fib_get_table(net, frn->tb_id_in); 875 876 nl_fib_lookup(frn, tb); 877 878 pid = NETLINK_CB(skb).pid; /* pid of sending process */ 879 NETLINK_CB(skb).pid = 0; /* from kernel */ 880 NETLINK_CB(skb).dst_group = 0; /* unicast */ 881 netlink_unicast(net->ipv4.fibnl, skb, pid, MSG_DONTWAIT); 882 } 883 884 static int nl_fib_lookup_init(struct net *net) 885 { 886 struct sock *sk; 887 sk = netlink_kernel_create(net, NETLINK_FIB_LOOKUP, 0, 888 nl_fib_input, NULL, THIS_MODULE); 889 if (sk == NULL) 890 return -EAFNOSUPPORT; 891 net->ipv4.fibnl = sk; 892 return 0; 893 } 894 895 static void nl_fib_lookup_exit(struct net *net) 896 { 897 netlink_kernel_release(net->ipv4.fibnl); 898 net->ipv4.fibnl = NULL; 899 } 900 901 static void fib_disable_ip(struct net_device *dev, int force, int delay) 902 { 903 if (fib_sync_down_dev(dev, force)) 904 fib_flush(dev_net(dev)); 905 rt_cache_flush(dev_net(dev), delay); 906 arp_ifdown(dev); 907 } 908 909 static int fib_inetaddr_event(struct notifier_block *this, unsigned long event, void *ptr) 910 { 911 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr; 912 struct net_device *dev = ifa->ifa_dev->dev; 913 914 switch (event) { 915 case NETDEV_UP: 916 fib_add_ifaddr(ifa); 917 #ifdef CONFIG_IP_ROUTE_MULTIPATH 918 fib_sync_up(dev); 919 #endif 920 rt_cache_flush(dev_net(dev), -1); 921 break; 922 case NETDEV_DOWN: 923 fib_del_ifaddr(ifa); 924 if (ifa->ifa_dev->ifa_list == NULL) { 925 /* Last address was deleted from this interface. 926 Disable IP. 927 */ 928 fib_disable_ip(dev, 1, 0); 929 } else { 930 rt_cache_flush(dev_net(dev), -1); 931 } 932 break; 933 } 934 return NOTIFY_DONE; 935 } 936 937 static int fib_netdev_event(struct notifier_block *this, unsigned long event, void *ptr) 938 { 939 struct net_device *dev = ptr; 940 struct in_device *in_dev = __in_dev_get_rtnl(dev); 941 942 if (event == NETDEV_UNREGISTER) { 943 fib_disable_ip(dev, 2, -1); 944 return NOTIFY_DONE; 945 } 946 947 if (!in_dev) 948 return NOTIFY_DONE; 949 950 switch (event) { 951 case NETDEV_UP: 952 for_ifa(in_dev) { 953 fib_add_ifaddr(ifa); 954 } endfor_ifa(in_dev); 955 #ifdef CONFIG_IP_ROUTE_MULTIPATH 956 fib_sync_up(dev); 957 #endif 958 rt_cache_flush(dev_net(dev), -1); 959 break; 960 case NETDEV_DOWN: 961 fib_disable_ip(dev, 0, 0); 962 break; 963 case NETDEV_CHANGEMTU: 964 case NETDEV_CHANGE: 965 rt_cache_flush(dev_net(dev), 0); 966 break; 967 case NETDEV_UNREGISTER_BATCH: 968 rt_cache_flush_batch(); 969 break; 970 } 971 return NOTIFY_DONE; 972 } 973 974 static struct notifier_block fib_inetaddr_notifier = { 975 .notifier_call = fib_inetaddr_event, 976 }; 977 978 static struct notifier_block fib_netdev_notifier = { 979 .notifier_call = fib_netdev_event, 980 }; 981 982 static int __net_init ip_fib_net_init(struct net *net) 983 { 984 int err; 985 unsigned int i; 986 987 net->ipv4.fib_table_hash = kzalloc( 988 sizeof(struct hlist_head)*FIB_TABLE_HASHSZ, GFP_KERNEL); 989 if (net->ipv4.fib_table_hash == NULL) 990 return -ENOMEM; 991 992 for (i = 0; i < FIB_TABLE_HASHSZ; i++) 993 INIT_HLIST_HEAD(&net->ipv4.fib_table_hash[i]); 994 995 err = fib4_rules_init(net); 996 if (err < 0) 997 goto fail; 998 return 0; 999 1000 fail: 1001 kfree(net->ipv4.fib_table_hash); 1002 return err; 1003 } 1004 1005 static void __net_exit ip_fib_net_exit(struct net *net) 1006 { 1007 unsigned int i; 1008 1009 #ifdef CONFIG_IP_MULTIPLE_TABLES 1010 fib4_rules_exit(net); 1011 #endif 1012 1013 for (i = 0; i < FIB_TABLE_HASHSZ; i++) { 1014 struct fib_table *tb; 1015 struct hlist_head *head; 1016 struct hlist_node *node, *tmp; 1017 1018 head = &net->ipv4.fib_table_hash[i]; 1019 hlist_for_each_entry_safe(tb, node, tmp, head, tb_hlist) { 1020 hlist_del(node); 1021 fib_table_flush(tb); 1022 kfree(tb); 1023 } 1024 } 1025 kfree(net->ipv4.fib_table_hash); 1026 } 1027 1028 static int __net_init fib_net_init(struct net *net) 1029 { 1030 int error; 1031 1032 error = ip_fib_net_init(net); 1033 if (error < 0) 1034 goto out; 1035 error = nl_fib_lookup_init(net); 1036 if (error < 0) 1037 goto out_nlfl; 1038 error = fib_proc_init(net); 1039 if (error < 0) 1040 goto out_proc; 1041 out: 1042 return error; 1043 1044 out_proc: 1045 nl_fib_lookup_exit(net); 1046 out_nlfl: 1047 ip_fib_net_exit(net); 1048 goto out; 1049 } 1050 1051 static void __net_exit fib_net_exit(struct net *net) 1052 { 1053 fib_proc_exit(net); 1054 nl_fib_lookup_exit(net); 1055 ip_fib_net_exit(net); 1056 } 1057 1058 static struct pernet_operations fib_net_ops = { 1059 .init = fib_net_init, 1060 .exit = fib_net_exit, 1061 }; 1062 1063 void __init ip_fib_init(void) 1064 { 1065 rtnl_register(PF_INET, RTM_NEWROUTE, inet_rtm_newroute, NULL); 1066 rtnl_register(PF_INET, RTM_DELROUTE, inet_rtm_delroute, NULL); 1067 rtnl_register(PF_INET, RTM_GETROUTE, NULL, inet_dump_fib); 1068 1069 register_pernet_subsys(&fib_net_ops); 1070 register_netdevice_notifier(&fib_netdev_notifier); 1071 register_inetaddr_notifier(&fib_inetaddr_notifier); 1072 1073 fib_hash_init(); 1074 } 1075 1076 EXPORT_SYMBOL(inet_addr_type); 1077 EXPORT_SYMBOL(inet_dev_addr_type); 1078 EXPORT_SYMBOL(ip_dev_find); 1079