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