ndisc.c revision eb857186eb771998fc9ab4bfd398a6fedb5a295c
1/* 2 * Neighbour Discovery for IPv6 3 * Linux INET6 implementation 4 * 5 * Authors: 6 * Pedro Roque <roque@di.fc.ul.pt> 7 * Mike Shaver <shaver@ingenia.com> 8 * 9 * This program is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU General Public License 11 * as published by the Free Software Foundation; either version 12 * 2 of the License, or (at your option) any later version. 13 */ 14 15/* 16 * Changes: 17 * 18 * Pierre Ynard : export userland ND options 19 * through netlink (RDNSS support) 20 * Lars Fenneberg : fixed MTU setting on receipt 21 * of an RA. 22 * Janos Farkas : kmalloc failure checks 23 * Alexey Kuznetsov : state machine reworked 24 * and moved to net/core. 25 * Pekka Savola : RFC2461 validation 26 * YOSHIFUJI Hideaki @USAGI : Verify ND options properly 27 */ 28 29/* Set to 3 to get tracing... */ 30#define ND_DEBUG 1 31 32#define ND_PRINTK(fmt, args...) do { if (net_ratelimit()) { printk(fmt, ## args); } } while(0) 33#define ND_NOPRINTK(x...) do { ; } while(0) 34#define ND_PRINTK0 ND_PRINTK 35#define ND_PRINTK1 ND_NOPRINTK 36#define ND_PRINTK2 ND_NOPRINTK 37#define ND_PRINTK3 ND_NOPRINTK 38#if ND_DEBUG >= 1 39#undef ND_PRINTK1 40#define ND_PRINTK1 ND_PRINTK 41#endif 42#if ND_DEBUG >= 2 43#undef ND_PRINTK2 44#define ND_PRINTK2 ND_PRINTK 45#endif 46#if ND_DEBUG >= 3 47#undef ND_PRINTK3 48#define ND_PRINTK3 ND_PRINTK 49#endif 50 51#include <linux/module.h> 52#include <linux/errno.h> 53#include <linux/types.h> 54#include <linux/socket.h> 55#include <linux/sockios.h> 56#include <linux/sched.h> 57#include <linux/net.h> 58#include <linux/in6.h> 59#include <linux/route.h> 60#include <linux/init.h> 61#include <linux/rcupdate.h> 62#include <linux/slab.h> 63#ifdef CONFIG_SYSCTL 64#include <linux/sysctl.h> 65#endif 66 67#include <linux/if_addr.h> 68#include <linux/if_arp.h> 69#include <linux/ipv6.h> 70#include <linux/icmpv6.h> 71#include <linux/jhash.h> 72 73#include <net/sock.h> 74#include <net/snmp.h> 75 76#include <net/ipv6.h> 77#include <net/protocol.h> 78#include <net/ndisc.h> 79#include <net/ip6_route.h> 80#include <net/addrconf.h> 81#include <net/icmp.h> 82 83#include <net/netlink.h> 84#include <linux/rtnetlink.h> 85 86#include <net/flow.h> 87#include <net/ip6_checksum.h> 88#include <net/inet_common.h> 89#include <linux/proc_fs.h> 90 91#include <linux/netfilter.h> 92#include <linux/netfilter_ipv6.h> 93 94static u32 ndisc_hash(const void *pkey, 95 const struct net_device *dev, 96 __u32 *hash_rnd); 97static int ndisc_constructor(struct neighbour *neigh); 98static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb); 99static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb); 100static int pndisc_constructor(struct pneigh_entry *n); 101static void pndisc_destructor(struct pneigh_entry *n); 102static void pndisc_redo(struct sk_buff *skb); 103 104static const struct neigh_ops ndisc_generic_ops = { 105 .family = AF_INET6, 106 .solicit = ndisc_solicit, 107 .error_report = ndisc_error_report, 108 .output = neigh_resolve_output, 109 .connected_output = neigh_connected_output, 110}; 111 112static const struct neigh_ops ndisc_hh_ops = { 113 .family = AF_INET6, 114 .solicit = ndisc_solicit, 115 .error_report = ndisc_error_report, 116 .output = neigh_resolve_output, 117 .connected_output = neigh_resolve_output, 118}; 119 120 121static const struct neigh_ops ndisc_direct_ops = { 122 .family = AF_INET6, 123 .output = neigh_direct_output, 124 .connected_output = neigh_direct_output, 125}; 126 127struct neigh_table nd_tbl = { 128 .family = AF_INET6, 129 .key_len = sizeof(struct in6_addr), 130 .hash = ndisc_hash, 131 .constructor = ndisc_constructor, 132 .pconstructor = pndisc_constructor, 133 .pdestructor = pndisc_destructor, 134 .proxy_redo = pndisc_redo, 135 .id = "ndisc_cache", 136 .parms = { 137 .tbl = &nd_tbl, 138 .base_reachable_time = ND_REACHABLE_TIME, 139 .retrans_time = ND_RETRANS_TIMER, 140 .gc_staletime = 60 * HZ, 141 .reachable_time = ND_REACHABLE_TIME, 142 .delay_probe_time = 5 * HZ, 143 .queue_len_bytes = 64*1024, 144 .ucast_probes = 3, 145 .mcast_probes = 3, 146 .anycast_delay = 1 * HZ, 147 .proxy_delay = (8 * HZ) / 10, 148 .proxy_qlen = 64, 149 }, 150 .gc_interval = 30 * HZ, 151 .gc_thresh1 = 128, 152 .gc_thresh2 = 512, 153 .gc_thresh3 = 1024, 154}; 155 156/* ND options */ 157struct ndisc_options { 158 struct nd_opt_hdr *nd_opt_array[__ND_OPT_ARRAY_MAX]; 159#ifdef CONFIG_IPV6_ROUTE_INFO 160 struct nd_opt_hdr *nd_opts_ri; 161 struct nd_opt_hdr *nd_opts_ri_end; 162#endif 163 struct nd_opt_hdr *nd_useropts; 164 struct nd_opt_hdr *nd_useropts_end; 165}; 166 167#define nd_opts_src_lladdr nd_opt_array[ND_OPT_SOURCE_LL_ADDR] 168#define nd_opts_tgt_lladdr nd_opt_array[ND_OPT_TARGET_LL_ADDR] 169#define nd_opts_pi nd_opt_array[ND_OPT_PREFIX_INFO] 170#define nd_opts_pi_end nd_opt_array[__ND_OPT_PREFIX_INFO_END] 171#define nd_opts_rh nd_opt_array[ND_OPT_REDIRECT_HDR] 172#define nd_opts_mtu nd_opt_array[ND_OPT_MTU] 173 174#define NDISC_OPT_SPACE(len) (((len)+2+7)&~7) 175 176/* 177 * Return the padding between the option length and the start of the 178 * link addr. Currently only IP-over-InfiniBand needs this, although 179 * if RFC 3831 IPv6-over-Fibre Channel is ever implemented it may 180 * also need a pad of 2. 181 */ 182static int ndisc_addr_option_pad(unsigned short type) 183{ 184 switch (type) { 185 case ARPHRD_INFINIBAND: return 2; 186 default: return 0; 187 } 188} 189 190static inline int ndisc_opt_addr_space(struct net_device *dev) 191{ 192 return NDISC_OPT_SPACE(dev->addr_len + ndisc_addr_option_pad(dev->type)); 193} 194 195static u8 *ndisc_fill_addr_option(u8 *opt, int type, void *data, int data_len, 196 unsigned short addr_type) 197{ 198 int space = NDISC_OPT_SPACE(data_len); 199 int pad = ndisc_addr_option_pad(addr_type); 200 201 opt[0] = type; 202 opt[1] = space>>3; 203 204 memset(opt + 2, 0, pad); 205 opt += pad; 206 space -= pad; 207 208 memcpy(opt+2, data, data_len); 209 data_len += 2; 210 opt += data_len; 211 if ((space -= data_len) > 0) 212 memset(opt, 0, space); 213 return opt + space; 214} 215 216static struct nd_opt_hdr *ndisc_next_option(struct nd_opt_hdr *cur, 217 struct nd_opt_hdr *end) 218{ 219 int type; 220 if (!cur || !end || cur >= end) 221 return NULL; 222 type = cur->nd_opt_type; 223 do { 224 cur = ((void *)cur) + (cur->nd_opt_len << 3); 225 } while(cur < end && cur->nd_opt_type != type); 226 return cur <= end && cur->nd_opt_type == type ? cur : NULL; 227} 228 229static inline int ndisc_is_useropt(struct nd_opt_hdr *opt) 230{ 231 return opt->nd_opt_type == ND_OPT_RDNSS; 232} 233 234static struct nd_opt_hdr *ndisc_next_useropt(struct nd_opt_hdr *cur, 235 struct nd_opt_hdr *end) 236{ 237 if (!cur || !end || cur >= end) 238 return NULL; 239 do { 240 cur = ((void *)cur) + (cur->nd_opt_len << 3); 241 } while(cur < end && !ndisc_is_useropt(cur)); 242 return cur <= end && ndisc_is_useropt(cur) ? cur : NULL; 243} 244 245static struct ndisc_options *ndisc_parse_options(u8 *opt, int opt_len, 246 struct ndisc_options *ndopts) 247{ 248 struct nd_opt_hdr *nd_opt = (struct nd_opt_hdr *)opt; 249 250 if (!nd_opt || opt_len < 0 || !ndopts) 251 return NULL; 252 memset(ndopts, 0, sizeof(*ndopts)); 253 while (opt_len) { 254 int l; 255 if (opt_len < sizeof(struct nd_opt_hdr)) 256 return NULL; 257 l = nd_opt->nd_opt_len << 3; 258 if (opt_len < l || l == 0) 259 return NULL; 260 switch (nd_opt->nd_opt_type) { 261 case ND_OPT_SOURCE_LL_ADDR: 262 case ND_OPT_TARGET_LL_ADDR: 263 case ND_OPT_MTU: 264 case ND_OPT_REDIRECT_HDR: 265 if (ndopts->nd_opt_array[nd_opt->nd_opt_type]) { 266 ND_PRINTK2(KERN_WARNING 267 "%s(): duplicated ND6 option found: type=%d\n", 268 __func__, 269 nd_opt->nd_opt_type); 270 } else { 271 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt; 272 } 273 break; 274 case ND_OPT_PREFIX_INFO: 275 ndopts->nd_opts_pi_end = nd_opt; 276 if (!ndopts->nd_opt_array[nd_opt->nd_opt_type]) 277 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt; 278 break; 279#ifdef CONFIG_IPV6_ROUTE_INFO 280 case ND_OPT_ROUTE_INFO: 281 ndopts->nd_opts_ri_end = nd_opt; 282 if (!ndopts->nd_opts_ri) 283 ndopts->nd_opts_ri = nd_opt; 284 break; 285#endif 286 default: 287 if (ndisc_is_useropt(nd_opt)) { 288 ndopts->nd_useropts_end = nd_opt; 289 if (!ndopts->nd_useropts) 290 ndopts->nd_useropts = nd_opt; 291 } else { 292 /* 293 * Unknown options must be silently ignored, 294 * to accommodate future extension to the 295 * protocol. 296 */ 297 ND_PRINTK2(KERN_NOTICE 298 "%s(): ignored unsupported option; type=%d, len=%d\n", 299 __func__, 300 nd_opt->nd_opt_type, nd_opt->nd_opt_len); 301 } 302 } 303 opt_len -= l; 304 nd_opt = ((void *)nd_opt) + l; 305 } 306 return ndopts; 307} 308 309static inline u8 *ndisc_opt_addr_data(struct nd_opt_hdr *p, 310 struct net_device *dev) 311{ 312 u8 *lladdr = (u8 *)(p + 1); 313 int lladdrlen = p->nd_opt_len << 3; 314 int prepad = ndisc_addr_option_pad(dev->type); 315 if (lladdrlen != NDISC_OPT_SPACE(dev->addr_len + prepad)) 316 return NULL; 317 return lladdr + prepad; 318} 319 320int ndisc_mc_map(const struct in6_addr *addr, char *buf, struct net_device *dev, int dir) 321{ 322 switch (dev->type) { 323 case ARPHRD_ETHER: 324 case ARPHRD_IEEE802: /* Not sure. Check it later. --ANK */ 325 case ARPHRD_FDDI: 326 ipv6_eth_mc_map(addr, buf); 327 return 0; 328 case ARPHRD_IEEE802_TR: 329 ipv6_tr_mc_map(addr,buf); 330 return 0; 331 case ARPHRD_ARCNET: 332 ipv6_arcnet_mc_map(addr, buf); 333 return 0; 334 case ARPHRD_INFINIBAND: 335 ipv6_ib_mc_map(addr, dev->broadcast, buf); 336 return 0; 337 case ARPHRD_IPGRE: 338 return ipv6_ipgre_mc_map(addr, dev->broadcast, buf); 339 default: 340 if (dir) { 341 memcpy(buf, dev->broadcast, dev->addr_len); 342 return 0; 343 } 344 } 345 return -EINVAL; 346} 347 348EXPORT_SYMBOL(ndisc_mc_map); 349 350static u32 ndisc_hash(const void *pkey, 351 const struct net_device *dev, 352 __u32 *hash_rnd) 353{ 354 return ndisc_hashfn(pkey, dev, hash_rnd); 355} 356 357static int ndisc_constructor(struct neighbour *neigh) 358{ 359 struct in6_addr *addr = (struct in6_addr*)&neigh->primary_key; 360 struct net_device *dev = neigh->dev; 361 struct inet6_dev *in6_dev; 362 struct neigh_parms *parms; 363 int is_multicast = ipv6_addr_is_multicast(addr); 364 365 in6_dev = in6_dev_get(dev); 366 if (in6_dev == NULL) { 367 return -EINVAL; 368 } 369 370 parms = in6_dev->nd_parms; 371 __neigh_parms_put(neigh->parms); 372 neigh->parms = neigh_parms_clone(parms); 373 374 neigh->type = is_multicast ? RTN_MULTICAST : RTN_UNICAST; 375 if (!dev->header_ops) { 376 neigh->nud_state = NUD_NOARP; 377 neigh->ops = &ndisc_direct_ops; 378 neigh->output = neigh_direct_output; 379 } else { 380 if (is_multicast) { 381 neigh->nud_state = NUD_NOARP; 382 ndisc_mc_map(addr, neigh->ha, dev, 1); 383 } else if (dev->flags&(IFF_NOARP|IFF_LOOPBACK)) { 384 neigh->nud_state = NUD_NOARP; 385 memcpy(neigh->ha, dev->dev_addr, dev->addr_len); 386 if (dev->flags&IFF_LOOPBACK) 387 neigh->type = RTN_LOCAL; 388 } else if (dev->flags&IFF_POINTOPOINT) { 389 neigh->nud_state = NUD_NOARP; 390 memcpy(neigh->ha, dev->broadcast, dev->addr_len); 391 } 392 if (dev->header_ops->cache) 393 neigh->ops = &ndisc_hh_ops; 394 else 395 neigh->ops = &ndisc_generic_ops; 396 if (neigh->nud_state&NUD_VALID) 397 neigh->output = neigh->ops->connected_output; 398 else 399 neigh->output = neigh->ops->output; 400 } 401 in6_dev_put(in6_dev); 402 return 0; 403} 404 405static int pndisc_constructor(struct pneigh_entry *n) 406{ 407 struct in6_addr *addr = (struct in6_addr*)&n->key; 408 struct in6_addr maddr; 409 struct net_device *dev = n->dev; 410 411 if (dev == NULL || __in6_dev_get(dev) == NULL) 412 return -EINVAL; 413 addrconf_addr_solict_mult(addr, &maddr); 414 ipv6_dev_mc_inc(dev, &maddr); 415 return 0; 416} 417 418static void pndisc_destructor(struct pneigh_entry *n) 419{ 420 struct in6_addr *addr = (struct in6_addr*)&n->key; 421 struct in6_addr maddr; 422 struct net_device *dev = n->dev; 423 424 if (dev == NULL || __in6_dev_get(dev) == NULL) 425 return; 426 addrconf_addr_solict_mult(addr, &maddr); 427 ipv6_dev_mc_dec(dev, &maddr); 428} 429 430struct sk_buff *ndisc_build_skb(struct net_device *dev, 431 const struct in6_addr *daddr, 432 const struct in6_addr *saddr, 433 struct icmp6hdr *icmp6h, 434 const struct in6_addr *target, 435 int llinfo) 436{ 437 struct net *net = dev_net(dev); 438 struct sock *sk = net->ipv6.ndisc_sk; 439 struct sk_buff *skb; 440 struct icmp6hdr *hdr; 441 int hlen = LL_RESERVED_SPACE(dev); 442 int tlen = dev->needed_tailroom; 443 int len; 444 int err; 445 u8 *opt; 446 447 if (!dev->addr_len) 448 llinfo = 0; 449 450 len = sizeof(struct icmp6hdr) + (target ? sizeof(*target) : 0); 451 if (llinfo) 452 len += ndisc_opt_addr_space(dev); 453 454 skb = sock_alloc_send_skb(sk, 455 (MAX_HEADER + sizeof(struct ipv6hdr) + 456 len + hlen + tlen), 457 1, &err); 458 if (!skb) { 459 ND_PRINTK0(KERN_ERR 460 "ICMPv6 ND: %s() failed to allocate an skb, err=%d.\n", 461 __func__, err); 462 return NULL; 463 } 464 465 skb_reserve(skb, hlen); 466 ip6_nd_hdr(sk, skb, dev, saddr, daddr, IPPROTO_ICMPV6, len); 467 468 skb->transport_header = skb->tail; 469 skb_put(skb, len); 470 471 hdr = (struct icmp6hdr *)skb_transport_header(skb); 472 memcpy(hdr, icmp6h, sizeof(*hdr)); 473 474 opt = skb_transport_header(skb) + sizeof(struct icmp6hdr); 475 if (target) { 476 *(struct in6_addr *)opt = *target; 477 opt += sizeof(*target); 478 } 479 480 if (llinfo) 481 ndisc_fill_addr_option(opt, llinfo, dev->dev_addr, 482 dev->addr_len, dev->type); 483 484 hdr->icmp6_cksum = csum_ipv6_magic(saddr, daddr, len, 485 IPPROTO_ICMPV6, 486 csum_partial(hdr, 487 len, 0)); 488 489 return skb; 490} 491 492EXPORT_SYMBOL(ndisc_build_skb); 493 494void ndisc_send_skb(struct sk_buff *skb, 495 struct net_device *dev, 496 struct neighbour *neigh, 497 const struct in6_addr *daddr, 498 const struct in6_addr *saddr, 499 struct icmp6hdr *icmp6h) 500{ 501 struct flowi6 fl6; 502 struct dst_entry *dst; 503 struct net *net = dev_net(dev); 504 struct sock *sk = net->ipv6.ndisc_sk; 505 struct inet6_dev *idev; 506 int err; 507 u8 type; 508 509 type = icmp6h->icmp6_type; 510 511 icmpv6_flow_init(sk, &fl6, type, saddr, daddr, dev->ifindex); 512 dst = icmp6_dst_alloc(dev, neigh, &fl6); 513 if (IS_ERR(dst)) { 514 kfree_skb(skb); 515 return; 516 } 517 518 skb_dst_set(skb, dst); 519 520 rcu_read_lock(); 521 idev = __in6_dev_get(dst->dev); 522 IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len); 523 524 err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, skb, NULL, dst->dev, 525 dst_output); 526 if (!err) { 527 ICMP6MSGOUT_INC_STATS(net, idev, type); 528 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS); 529 } 530 531 rcu_read_unlock(); 532} 533 534EXPORT_SYMBOL(ndisc_send_skb); 535 536/* 537 * Send a Neighbour Discover packet 538 */ 539static void __ndisc_send(struct net_device *dev, 540 struct neighbour *neigh, 541 const struct in6_addr *daddr, 542 const struct in6_addr *saddr, 543 struct icmp6hdr *icmp6h, const struct in6_addr *target, 544 int llinfo) 545{ 546 struct sk_buff *skb; 547 548 skb = ndisc_build_skb(dev, daddr, saddr, icmp6h, target, llinfo); 549 if (!skb) 550 return; 551 552 ndisc_send_skb(skb, dev, neigh, daddr, saddr, icmp6h); 553} 554 555static void ndisc_send_na(struct net_device *dev, struct neighbour *neigh, 556 const struct in6_addr *daddr, 557 const struct in6_addr *solicited_addr, 558 int router, int solicited, int override, int inc_opt) 559{ 560 struct in6_addr tmpaddr; 561 struct inet6_ifaddr *ifp; 562 const struct in6_addr *src_addr; 563 struct icmp6hdr icmp6h = { 564 .icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT, 565 }; 566 567 /* for anycast or proxy, solicited_addr != src_addr */ 568 ifp = ipv6_get_ifaddr(dev_net(dev), solicited_addr, dev, 1); 569 if (ifp) { 570 src_addr = solicited_addr; 571 if (ifp->flags & IFA_F_OPTIMISTIC) 572 override = 0; 573 inc_opt |= ifp->idev->cnf.force_tllao; 574 in6_ifa_put(ifp); 575 } else { 576 if (ipv6_dev_get_saddr(dev_net(dev), dev, daddr, 577 inet6_sk(dev_net(dev)->ipv6.ndisc_sk)->srcprefs, 578 &tmpaddr)) 579 return; 580 src_addr = &tmpaddr; 581 } 582 583 icmp6h.icmp6_router = router; 584 icmp6h.icmp6_solicited = solicited; 585 icmp6h.icmp6_override = override; 586 587 __ndisc_send(dev, neigh, daddr, src_addr, 588 &icmp6h, solicited_addr, 589 inc_opt ? ND_OPT_TARGET_LL_ADDR : 0); 590} 591 592static void ndisc_send_unsol_na(struct net_device *dev) 593{ 594 struct inet6_dev *idev; 595 struct inet6_ifaddr *ifa; 596 struct in6_addr mcaddr; 597 598 idev = in6_dev_get(dev); 599 if (!idev) 600 return; 601 602 read_lock_bh(&idev->lock); 603 list_for_each_entry(ifa, &idev->addr_list, if_list) { 604 addrconf_addr_solict_mult(&ifa->addr, &mcaddr); 605 ndisc_send_na(dev, NULL, &mcaddr, &ifa->addr, 606 /*router=*/ !!idev->cnf.forwarding, 607 /*solicited=*/ false, /*override=*/ true, 608 /*inc_opt=*/ true); 609 } 610 read_unlock_bh(&idev->lock); 611 612 in6_dev_put(idev); 613} 614 615void ndisc_send_ns(struct net_device *dev, struct neighbour *neigh, 616 const struct in6_addr *solicit, 617 const struct in6_addr *daddr, const struct in6_addr *saddr) 618{ 619 struct in6_addr addr_buf; 620 struct icmp6hdr icmp6h = { 621 .icmp6_type = NDISC_NEIGHBOUR_SOLICITATION, 622 }; 623 624 if (saddr == NULL) { 625 if (ipv6_get_lladdr(dev, &addr_buf, 626 (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC))) 627 return; 628 saddr = &addr_buf; 629 } 630 631 __ndisc_send(dev, neigh, daddr, saddr, 632 &icmp6h, solicit, 633 !ipv6_addr_any(saddr) ? ND_OPT_SOURCE_LL_ADDR : 0); 634} 635 636void ndisc_send_rs(struct net_device *dev, const struct in6_addr *saddr, 637 const struct in6_addr *daddr) 638{ 639 struct icmp6hdr icmp6h = { 640 .icmp6_type = NDISC_ROUTER_SOLICITATION, 641 }; 642 int send_sllao = dev->addr_len; 643 644#ifdef CONFIG_IPV6_OPTIMISTIC_DAD 645 /* 646 * According to section 2.2 of RFC 4429, we must not 647 * send router solicitations with a sllao from 648 * optimistic addresses, but we may send the solicitation 649 * if we don't include the sllao. So here we check 650 * if our address is optimistic, and if so, we 651 * suppress the inclusion of the sllao. 652 */ 653 if (send_sllao) { 654 struct inet6_ifaddr *ifp = ipv6_get_ifaddr(dev_net(dev), saddr, 655 dev, 1); 656 if (ifp) { 657 if (ifp->flags & IFA_F_OPTIMISTIC) { 658 send_sllao = 0; 659 } 660 in6_ifa_put(ifp); 661 } else { 662 send_sllao = 0; 663 } 664 } 665#endif 666 __ndisc_send(dev, NULL, daddr, saddr, 667 &icmp6h, NULL, 668 send_sllao ? ND_OPT_SOURCE_LL_ADDR : 0); 669} 670 671 672static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb) 673{ 674 /* 675 * "The sender MUST return an ICMP 676 * destination unreachable" 677 */ 678 dst_link_failure(skb); 679 kfree_skb(skb); 680} 681 682/* Called with locked neigh: either read or both */ 683 684static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb) 685{ 686 struct in6_addr *saddr = NULL; 687 struct in6_addr mcaddr; 688 struct net_device *dev = neigh->dev; 689 struct in6_addr *target = (struct in6_addr *)&neigh->primary_key; 690 int probes = atomic_read(&neigh->probes); 691 692 if (skb && ipv6_chk_addr(dev_net(dev), &ipv6_hdr(skb)->saddr, dev, 1)) 693 saddr = &ipv6_hdr(skb)->saddr; 694 695 if ((probes -= neigh->parms->ucast_probes) < 0) { 696 if (!(neigh->nud_state & NUD_VALID)) { 697 ND_PRINTK1(KERN_DEBUG "%s(): trying to ucast probe in NUD_INVALID: %pI6\n", 698 __func__, target); 699 } 700 ndisc_send_ns(dev, neigh, target, target, saddr); 701 } else if ((probes -= neigh->parms->app_probes) < 0) { 702#ifdef CONFIG_ARPD 703 neigh_app_ns(neigh); 704#endif 705 } else { 706 addrconf_addr_solict_mult(target, &mcaddr); 707 ndisc_send_ns(dev, NULL, target, &mcaddr, saddr); 708 } 709} 710 711static int pndisc_is_router(const void *pkey, 712 struct net_device *dev) 713{ 714 struct pneigh_entry *n; 715 int ret = -1; 716 717 read_lock_bh(&nd_tbl.lock); 718 n = __pneigh_lookup(&nd_tbl, dev_net(dev), pkey, dev); 719 if (n) 720 ret = !!(n->flags & NTF_ROUTER); 721 read_unlock_bh(&nd_tbl.lock); 722 723 return ret; 724} 725 726static void ndisc_recv_ns(struct sk_buff *skb) 727{ 728 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb); 729 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr; 730 const struct in6_addr *daddr = &ipv6_hdr(skb)->daddr; 731 u8 *lladdr = NULL; 732 u32 ndoptlen = skb->tail - (skb->transport_header + 733 offsetof(struct nd_msg, opt)); 734 struct ndisc_options ndopts; 735 struct net_device *dev = skb->dev; 736 struct inet6_ifaddr *ifp; 737 struct inet6_dev *idev = NULL; 738 struct neighbour *neigh; 739 int dad = ipv6_addr_any(saddr); 740 int inc; 741 int is_router = -1; 742 743 if (ipv6_addr_is_multicast(&msg->target)) { 744 ND_PRINTK2(KERN_WARNING 745 "ICMPv6 NS: multicast target address"); 746 return; 747 } 748 749 /* 750 * RFC2461 7.1.1: 751 * DAD has to be destined for solicited node multicast address. 752 */ 753 if (dad && 754 !(daddr->s6_addr32[0] == htonl(0xff020000) && 755 daddr->s6_addr32[1] == htonl(0x00000000) && 756 daddr->s6_addr32[2] == htonl(0x00000001) && 757 daddr->s6_addr [12] == 0xff )) { 758 ND_PRINTK2(KERN_WARNING 759 "ICMPv6 NS: bad DAD packet (wrong destination)\n"); 760 return; 761 } 762 763 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) { 764 ND_PRINTK2(KERN_WARNING 765 "ICMPv6 NS: invalid ND options\n"); 766 return; 767 } 768 769 if (ndopts.nd_opts_src_lladdr) { 770 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev); 771 if (!lladdr) { 772 ND_PRINTK2(KERN_WARNING 773 "ICMPv6 NS: invalid link-layer address length\n"); 774 return; 775 } 776 777 /* RFC2461 7.1.1: 778 * If the IP source address is the unspecified address, 779 * there MUST NOT be source link-layer address option 780 * in the message. 781 */ 782 if (dad) { 783 ND_PRINTK2(KERN_WARNING 784 "ICMPv6 NS: bad DAD packet (link-layer address option)\n"); 785 return; 786 } 787 } 788 789 inc = ipv6_addr_is_multicast(daddr); 790 791 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1); 792 if (ifp) { 793 794 if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) { 795 if (dad) { 796 if (dev->type == ARPHRD_IEEE802_TR) { 797 const unsigned char *sadr; 798 sadr = skb_mac_header(skb); 799 if (((sadr[8] ^ dev->dev_addr[0]) & 0x7f) == 0 && 800 sadr[9] == dev->dev_addr[1] && 801 sadr[10] == dev->dev_addr[2] && 802 sadr[11] == dev->dev_addr[3] && 803 sadr[12] == dev->dev_addr[4] && 804 sadr[13] == dev->dev_addr[5]) { 805 /* looped-back to us */ 806 goto out; 807 } 808 } 809 810 /* 811 * We are colliding with another node 812 * who is doing DAD 813 * so fail our DAD process 814 */ 815 addrconf_dad_failure(ifp); 816 return; 817 } else { 818 /* 819 * This is not a dad solicitation. 820 * If we are an optimistic node, 821 * we should respond. 822 * Otherwise, we should ignore it. 823 */ 824 if (!(ifp->flags & IFA_F_OPTIMISTIC)) 825 goto out; 826 } 827 } 828 829 idev = ifp->idev; 830 } else { 831 struct net *net = dev_net(dev); 832 833 idev = in6_dev_get(dev); 834 if (!idev) { 835 /* XXX: count this drop? */ 836 return; 837 } 838 839 if (ipv6_chk_acast_addr(net, dev, &msg->target) || 840 (idev->cnf.forwarding && 841 (net->ipv6.devconf_all->proxy_ndp || idev->cnf.proxy_ndp) && 842 (is_router = pndisc_is_router(&msg->target, dev)) >= 0)) { 843 if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) && 844 skb->pkt_type != PACKET_HOST && 845 inc != 0 && 846 idev->nd_parms->proxy_delay != 0) { 847 /* 848 * for anycast or proxy, 849 * sender should delay its response 850 * by a random time between 0 and 851 * MAX_ANYCAST_DELAY_TIME seconds. 852 * (RFC2461) -- yoshfuji 853 */ 854 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC); 855 if (n) 856 pneigh_enqueue(&nd_tbl, idev->nd_parms, n); 857 goto out; 858 } 859 } else 860 goto out; 861 } 862 863 if (is_router < 0) 864 is_router = !!idev->cnf.forwarding; 865 866 if (dad) { 867 ndisc_send_na(dev, NULL, &in6addr_linklocal_allnodes, &msg->target, 868 is_router, 0, (ifp != NULL), 1); 869 goto out; 870 } 871 872 if (inc) 873 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast); 874 else 875 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast); 876 877 /* 878 * update / create cache entry 879 * for the source address 880 */ 881 neigh = __neigh_lookup(&nd_tbl, saddr, dev, 882 !inc || lladdr || !dev->addr_len); 883 if (neigh) 884 neigh_update(neigh, lladdr, NUD_STALE, 885 NEIGH_UPDATE_F_WEAK_OVERRIDE| 886 NEIGH_UPDATE_F_OVERRIDE); 887 if (neigh || !dev->header_ops) { 888 ndisc_send_na(dev, neigh, saddr, &msg->target, 889 is_router, 890 1, (ifp != NULL && inc), inc); 891 if (neigh) 892 neigh_release(neigh); 893 } 894 895out: 896 if (ifp) 897 in6_ifa_put(ifp); 898 else 899 in6_dev_put(idev); 900} 901 902static void ndisc_recv_na(struct sk_buff *skb) 903{ 904 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb); 905 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr; 906 const struct in6_addr *daddr = &ipv6_hdr(skb)->daddr; 907 u8 *lladdr = NULL; 908 u32 ndoptlen = skb->tail - (skb->transport_header + 909 offsetof(struct nd_msg, opt)); 910 struct ndisc_options ndopts; 911 struct net_device *dev = skb->dev; 912 struct inet6_ifaddr *ifp; 913 struct neighbour *neigh; 914 915 if (skb->len < sizeof(struct nd_msg)) { 916 ND_PRINTK2(KERN_WARNING 917 "ICMPv6 NA: packet too short\n"); 918 return; 919 } 920 921 if (ipv6_addr_is_multicast(&msg->target)) { 922 ND_PRINTK2(KERN_WARNING 923 "ICMPv6 NA: target address is multicast.\n"); 924 return; 925 } 926 927 if (ipv6_addr_is_multicast(daddr) && 928 msg->icmph.icmp6_solicited) { 929 ND_PRINTK2(KERN_WARNING 930 "ICMPv6 NA: solicited NA is multicasted.\n"); 931 return; 932 } 933 934 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) { 935 ND_PRINTK2(KERN_WARNING 936 "ICMPv6 NS: invalid ND option\n"); 937 return; 938 } 939 if (ndopts.nd_opts_tgt_lladdr) { 940 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev); 941 if (!lladdr) { 942 ND_PRINTK2(KERN_WARNING 943 "ICMPv6 NA: invalid link-layer address length\n"); 944 return; 945 } 946 } 947 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1); 948 if (ifp) { 949 if (skb->pkt_type != PACKET_LOOPBACK 950 && (ifp->flags & IFA_F_TENTATIVE)) { 951 addrconf_dad_failure(ifp); 952 return; 953 } 954 /* What should we make now? The advertisement 955 is invalid, but ndisc specs say nothing 956 about it. It could be misconfiguration, or 957 an smart proxy agent tries to help us :-) 958 959 We should not print the error if NA has been 960 received from loopback - it is just our own 961 unsolicited advertisement. 962 */ 963 if (skb->pkt_type != PACKET_LOOPBACK) 964 ND_PRINTK1(KERN_WARNING 965 "ICMPv6 NA: someone advertises our address %pI6 on %s!\n", 966 &ifp->addr, ifp->idev->dev->name); 967 in6_ifa_put(ifp); 968 return; 969 } 970 neigh = neigh_lookup(&nd_tbl, &msg->target, dev); 971 972 if (neigh) { 973 u8 old_flags = neigh->flags; 974 struct net *net = dev_net(dev); 975 976 if (neigh->nud_state & NUD_FAILED) 977 goto out; 978 979 /* 980 * Don't update the neighbor cache entry on a proxy NA from 981 * ourselves because either the proxied node is off link or it 982 * has already sent a NA to us. 983 */ 984 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) && 985 net->ipv6.devconf_all->forwarding && net->ipv6.devconf_all->proxy_ndp && 986 pneigh_lookup(&nd_tbl, net, &msg->target, dev, 0)) { 987 /* XXX: idev->cnf.prixy_ndp */ 988 goto out; 989 } 990 991 neigh_update(neigh, lladdr, 992 msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE, 993 NEIGH_UPDATE_F_WEAK_OVERRIDE| 994 (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)| 995 NEIGH_UPDATE_F_OVERRIDE_ISROUTER| 996 (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0)); 997 998 if ((old_flags & ~neigh->flags) & NTF_ROUTER) { 999 /* 1000 * Change: router to host 1001 */ 1002 struct rt6_info *rt; 1003 rt = rt6_get_dflt_router(saddr, dev); 1004 if (rt) 1005 ip6_del_rt(rt); 1006 } 1007 1008out: 1009 neigh_release(neigh); 1010 } 1011} 1012 1013static void ndisc_recv_rs(struct sk_buff *skb) 1014{ 1015 struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb); 1016 unsigned long ndoptlen = skb->len - sizeof(*rs_msg); 1017 struct neighbour *neigh; 1018 struct inet6_dev *idev; 1019 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr; 1020 struct ndisc_options ndopts; 1021 u8 *lladdr = NULL; 1022 1023 if (skb->len < sizeof(*rs_msg)) 1024 return; 1025 1026 idev = __in6_dev_get(skb->dev); 1027 if (!idev) { 1028 if (net_ratelimit()) 1029 ND_PRINTK1("ICMP6 RS: can't find in6 device\n"); 1030 return; 1031 } 1032 1033 /* Don't accept RS if we're not in router mode */ 1034 if (!idev->cnf.forwarding) 1035 goto out; 1036 1037 /* 1038 * Don't update NCE if src = ::; 1039 * this implies that the source node has no ip address assigned yet. 1040 */ 1041 if (ipv6_addr_any(saddr)) 1042 goto out; 1043 1044 /* Parse ND options */ 1045 if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) { 1046 if (net_ratelimit()) 1047 ND_PRINTK2("ICMP6 NS: invalid ND option, ignored\n"); 1048 goto out; 1049 } 1050 1051 if (ndopts.nd_opts_src_lladdr) { 1052 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, 1053 skb->dev); 1054 if (!lladdr) 1055 goto out; 1056 } 1057 1058 neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1); 1059 if (neigh) { 1060 neigh_update(neigh, lladdr, NUD_STALE, 1061 NEIGH_UPDATE_F_WEAK_OVERRIDE| 1062 NEIGH_UPDATE_F_OVERRIDE| 1063 NEIGH_UPDATE_F_OVERRIDE_ISROUTER); 1064 neigh_release(neigh); 1065 } 1066out: 1067 return; 1068} 1069 1070static void ndisc_ra_useropt(struct sk_buff *ra, struct nd_opt_hdr *opt) 1071{ 1072 struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb_transport_header(ra); 1073 struct sk_buff *skb; 1074 struct nlmsghdr *nlh; 1075 struct nduseroptmsg *ndmsg; 1076 struct net *net = dev_net(ra->dev); 1077 int err; 1078 int base_size = NLMSG_ALIGN(sizeof(struct nduseroptmsg) 1079 + (opt->nd_opt_len << 3)); 1080 size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr)); 1081 1082 skb = nlmsg_new(msg_size, GFP_ATOMIC); 1083 if (skb == NULL) { 1084 err = -ENOBUFS; 1085 goto errout; 1086 } 1087 1088 nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0); 1089 if (nlh == NULL) { 1090 goto nla_put_failure; 1091 } 1092 1093 ndmsg = nlmsg_data(nlh); 1094 ndmsg->nduseropt_family = AF_INET6; 1095 ndmsg->nduseropt_ifindex = ra->dev->ifindex; 1096 ndmsg->nduseropt_icmp_type = icmp6h->icmp6_type; 1097 ndmsg->nduseropt_icmp_code = icmp6h->icmp6_code; 1098 ndmsg->nduseropt_opts_len = opt->nd_opt_len << 3; 1099 1100 memcpy(ndmsg + 1, opt, opt->nd_opt_len << 3); 1101 1102 NLA_PUT(skb, NDUSEROPT_SRCADDR, sizeof(struct in6_addr), 1103 &ipv6_hdr(ra)->saddr); 1104 nlmsg_end(skb, nlh); 1105 1106 rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL, GFP_ATOMIC); 1107 return; 1108 1109nla_put_failure: 1110 nlmsg_free(skb); 1111 err = -EMSGSIZE; 1112errout: 1113 rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err); 1114} 1115 1116static inline int accept_ra(struct inet6_dev *in6_dev) 1117{ 1118 /* 1119 * If forwarding is enabled, RA are not accepted unless the special 1120 * hybrid mode (accept_ra=2) is enabled. 1121 */ 1122 if (in6_dev->cnf.forwarding && in6_dev->cnf.accept_ra < 2) 1123 return 0; 1124 1125 return in6_dev->cnf.accept_ra; 1126} 1127 1128static void ndisc_router_discovery(struct sk_buff *skb) 1129{ 1130 struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb); 1131 struct neighbour *neigh = NULL; 1132 struct inet6_dev *in6_dev; 1133 struct rt6_info *rt = NULL; 1134 int lifetime; 1135 struct ndisc_options ndopts; 1136 int optlen; 1137 unsigned int pref = 0; 1138 1139 __u8 * opt = (__u8 *)(ra_msg + 1); 1140 1141 optlen = (skb->tail - skb->transport_header) - sizeof(struct ra_msg); 1142 1143 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) { 1144 ND_PRINTK2(KERN_WARNING 1145 "ICMPv6 RA: source address is not link-local.\n"); 1146 return; 1147 } 1148 if (optlen < 0) { 1149 ND_PRINTK2(KERN_WARNING 1150 "ICMPv6 RA: packet too short\n"); 1151 return; 1152 } 1153 1154#ifdef CONFIG_IPV6_NDISC_NODETYPE 1155 if (skb->ndisc_nodetype == NDISC_NODETYPE_HOST) { 1156 ND_PRINTK2(KERN_WARNING 1157 "ICMPv6 RA: from host or unauthorized router\n"); 1158 return; 1159 } 1160#endif 1161 1162 /* 1163 * set the RA_RECV flag in the interface 1164 */ 1165 1166 in6_dev = __in6_dev_get(skb->dev); 1167 if (in6_dev == NULL) { 1168 ND_PRINTK0(KERN_ERR 1169 "ICMPv6 RA: can't find inet6 device for %s.\n", 1170 skb->dev->name); 1171 return; 1172 } 1173 1174 if (!ndisc_parse_options(opt, optlen, &ndopts)) { 1175 ND_PRINTK2(KERN_WARNING 1176 "ICMP6 RA: invalid ND options\n"); 1177 return; 1178 } 1179 1180 if (!accept_ra(in6_dev)) 1181 goto skip_linkparms; 1182 1183#ifdef CONFIG_IPV6_NDISC_NODETYPE 1184 /* skip link-specific parameters from interior routers */ 1185 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT) 1186 goto skip_linkparms; 1187#endif 1188 1189 if (in6_dev->if_flags & IF_RS_SENT) { 1190 /* 1191 * flag that an RA was received after an RS was sent 1192 * out on this interface. 1193 */ 1194 in6_dev->if_flags |= IF_RA_RCVD; 1195 } 1196 1197 /* 1198 * Remember the managed/otherconf flags from most recently 1199 * received RA message (RFC 2462) -- yoshfuji 1200 */ 1201 in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED | 1202 IF_RA_OTHERCONF)) | 1203 (ra_msg->icmph.icmp6_addrconf_managed ? 1204 IF_RA_MANAGED : 0) | 1205 (ra_msg->icmph.icmp6_addrconf_other ? 1206 IF_RA_OTHERCONF : 0); 1207 1208 if (!in6_dev->cnf.accept_ra_defrtr) 1209 goto skip_defrtr; 1210 1211 if (ipv6_chk_addr(dev_net(in6_dev->dev), &ipv6_hdr(skb)->saddr, NULL, 0)) 1212 goto skip_defrtr; 1213 1214 lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime); 1215 1216#ifdef CONFIG_IPV6_ROUTER_PREF 1217 pref = ra_msg->icmph.icmp6_router_pref; 1218 /* 10b is handled as if it were 00b (medium) */ 1219 if (pref == ICMPV6_ROUTER_PREF_INVALID || 1220 !in6_dev->cnf.accept_ra_rtr_pref) 1221 pref = ICMPV6_ROUTER_PREF_MEDIUM; 1222#endif 1223 1224 rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev); 1225 1226 if (rt) { 1227 neigh = dst_neigh_lookup(&rt->dst, &ipv6_hdr(skb)->saddr); 1228 if (!neigh) { 1229 ND_PRINTK0(KERN_ERR 1230 "ICMPv6 RA: %s() got default router without neighbour.\n", 1231 __func__); 1232 dst_release(&rt->dst); 1233 return; 1234 } 1235 } 1236 if (rt && lifetime == 0) { 1237 ip6_del_rt(rt); 1238 rt = NULL; 1239 } 1240 1241 if (rt == NULL && lifetime) { 1242 ND_PRINTK3(KERN_DEBUG 1243 "ICMPv6 RA: adding default router.\n"); 1244 1245 rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref); 1246 if (rt == NULL) { 1247 ND_PRINTK0(KERN_ERR 1248 "ICMPv6 RA: %s() failed to add default route.\n", 1249 __func__); 1250 return; 1251 } 1252 1253 neigh = dst_neigh_lookup(&rt->dst, &ipv6_hdr(skb)->saddr); 1254 if (neigh == NULL) { 1255 ND_PRINTK0(KERN_ERR 1256 "ICMPv6 RA: %s() got default router without neighbour.\n", 1257 __func__); 1258 dst_release(&rt->dst); 1259 return; 1260 } 1261 neigh->flags |= NTF_ROUTER; 1262 } else if (rt) { 1263 rt->rt6i_flags = (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref); 1264 } 1265 1266 if (rt) 1267 rt->dst.expires = jiffies + (HZ * lifetime); 1268 1269 if (ra_msg->icmph.icmp6_hop_limit) { 1270 in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit; 1271 if (rt) 1272 dst_metric_set(&rt->dst, RTAX_HOPLIMIT, 1273 ra_msg->icmph.icmp6_hop_limit); 1274 } 1275 1276skip_defrtr: 1277 1278 /* 1279 * Update Reachable Time and Retrans Timer 1280 */ 1281 1282 if (in6_dev->nd_parms) { 1283 unsigned long rtime = ntohl(ra_msg->retrans_timer); 1284 1285 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) { 1286 rtime = (rtime*HZ)/1000; 1287 if (rtime < HZ/10) 1288 rtime = HZ/10; 1289 in6_dev->nd_parms->retrans_time = rtime; 1290 in6_dev->tstamp = jiffies; 1291 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev); 1292 } 1293 1294 rtime = ntohl(ra_msg->reachable_time); 1295 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) { 1296 rtime = (rtime*HZ)/1000; 1297 1298 if (rtime < HZ/10) 1299 rtime = HZ/10; 1300 1301 if (rtime != in6_dev->nd_parms->base_reachable_time) { 1302 in6_dev->nd_parms->base_reachable_time = rtime; 1303 in6_dev->nd_parms->gc_staletime = 3 * rtime; 1304 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime); 1305 in6_dev->tstamp = jiffies; 1306 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev); 1307 } 1308 } 1309 } 1310 1311skip_linkparms: 1312 1313 /* 1314 * Process options. 1315 */ 1316 1317 if (!neigh) 1318 neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr, 1319 skb->dev, 1); 1320 if (neigh) { 1321 u8 *lladdr = NULL; 1322 if (ndopts.nd_opts_src_lladdr) { 1323 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, 1324 skb->dev); 1325 if (!lladdr) { 1326 ND_PRINTK2(KERN_WARNING 1327 "ICMPv6 RA: invalid link-layer address length\n"); 1328 goto out; 1329 } 1330 } 1331 neigh_update(neigh, lladdr, NUD_STALE, 1332 NEIGH_UPDATE_F_WEAK_OVERRIDE| 1333 NEIGH_UPDATE_F_OVERRIDE| 1334 NEIGH_UPDATE_F_OVERRIDE_ISROUTER| 1335 NEIGH_UPDATE_F_ISROUTER); 1336 } 1337 1338 if (!accept_ra(in6_dev)) 1339 goto out; 1340 1341#ifdef CONFIG_IPV6_ROUTE_INFO 1342 if (ipv6_chk_addr(dev_net(in6_dev->dev), &ipv6_hdr(skb)->saddr, NULL, 0)) 1343 goto skip_routeinfo; 1344 1345 if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) { 1346 struct nd_opt_hdr *p; 1347 for (p = ndopts.nd_opts_ri; 1348 p; 1349 p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) { 1350 struct route_info *ri = (struct route_info *)p; 1351#ifdef CONFIG_IPV6_NDISC_NODETYPE 1352 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT && 1353 ri->prefix_len == 0) 1354 continue; 1355#endif 1356 if (ri->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen) 1357 continue; 1358 rt6_route_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3, 1359 &ipv6_hdr(skb)->saddr); 1360 } 1361 } 1362 1363skip_routeinfo: 1364#endif 1365 1366#ifdef CONFIG_IPV6_NDISC_NODETYPE 1367 /* skip link-specific ndopts from interior routers */ 1368 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT) 1369 goto out; 1370#endif 1371 1372 if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) { 1373 struct nd_opt_hdr *p; 1374 for (p = ndopts.nd_opts_pi; 1375 p; 1376 p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) { 1377 addrconf_prefix_rcv(skb->dev, (u8 *)p, 1378 (p->nd_opt_len) << 3, 1379 ndopts.nd_opts_src_lladdr != NULL); 1380 } 1381 } 1382 1383 if (ndopts.nd_opts_mtu) { 1384 __be32 n; 1385 u32 mtu; 1386 1387 memcpy(&n, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu)); 1388 mtu = ntohl(n); 1389 1390 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) { 1391 ND_PRINTK2(KERN_WARNING 1392 "ICMPv6 RA: invalid mtu: %d\n", 1393 mtu); 1394 } else if (in6_dev->cnf.mtu6 != mtu) { 1395 in6_dev->cnf.mtu6 = mtu; 1396 1397 if (rt) 1398 dst_metric_set(&rt->dst, RTAX_MTU, mtu); 1399 1400 rt6_mtu_change(skb->dev, mtu); 1401 } 1402 } 1403 1404 if (ndopts.nd_useropts) { 1405 struct nd_opt_hdr *p; 1406 for (p = ndopts.nd_useropts; 1407 p; 1408 p = ndisc_next_useropt(p, ndopts.nd_useropts_end)) { 1409 ndisc_ra_useropt(skb, p); 1410 } 1411 } 1412 1413 if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) { 1414 ND_PRINTK2(KERN_WARNING 1415 "ICMPv6 RA: invalid RA options"); 1416 } 1417out: 1418 if (rt) 1419 dst_release(&rt->dst); 1420 if (neigh) 1421 neigh_release(neigh); 1422} 1423 1424static void ndisc_redirect_rcv(struct sk_buff *skb) 1425{ 1426 struct inet6_dev *in6_dev; 1427 struct icmp6hdr *icmph; 1428 const struct in6_addr *dest; 1429 const struct in6_addr *target; /* new first hop to destination */ 1430 struct neighbour *neigh; 1431 int on_link = 0; 1432 struct ndisc_options ndopts; 1433 int optlen; 1434 u8 *lladdr = NULL; 1435 1436#ifdef CONFIG_IPV6_NDISC_NODETYPE 1437 switch (skb->ndisc_nodetype) { 1438 case NDISC_NODETYPE_HOST: 1439 case NDISC_NODETYPE_NODEFAULT: 1440 ND_PRINTK2(KERN_WARNING 1441 "ICMPv6 Redirect: from host or unauthorized router\n"); 1442 return; 1443 } 1444#endif 1445 1446 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) { 1447 ND_PRINTK2(KERN_WARNING 1448 "ICMPv6 Redirect: source address is not link-local.\n"); 1449 return; 1450 } 1451 1452 optlen = skb->tail - skb->transport_header; 1453 optlen -= sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr); 1454 1455 if (optlen < 0) { 1456 ND_PRINTK2(KERN_WARNING 1457 "ICMPv6 Redirect: packet too short\n"); 1458 return; 1459 } 1460 1461 icmph = icmp6_hdr(skb); 1462 target = (const struct in6_addr *) (icmph + 1); 1463 dest = target + 1; 1464 1465 if (ipv6_addr_is_multicast(dest)) { 1466 ND_PRINTK2(KERN_WARNING 1467 "ICMPv6 Redirect: destination address is multicast.\n"); 1468 return; 1469 } 1470 1471 if (ipv6_addr_equal(dest, target)) { 1472 on_link = 1; 1473 } else if (ipv6_addr_type(target) != 1474 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) { 1475 ND_PRINTK2(KERN_WARNING 1476 "ICMPv6 Redirect: target address is not link-local unicast.\n"); 1477 return; 1478 } 1479 1480 in6_dev = __in6_dev_get(skb->dev); 1481 if (!in6_dev) 1482 return; 1483 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects) 1484 return; 1485 1486 /* RFC2461 8.1: 1487 * The IP source address of the Redirect MUST be the same as the current 1488 * first-hop router for the specified ICMP Destination Address. 1489 */ 1490 1491 if (!ndisc_parse_options((u8*)(dest + 1), optlen, &ndopts)) { 1492 ND_PRINTK2(KERN_WARNING 1493 "ICMPv6 Redirect: invalid ND options\n"); 1494 return; 1495 } 1496 if (ndopts.nd_opts_tgt_lladdr) { 1497 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, 1498 skb->dev); 1499 if (!lladdr) { 1500 ND_PRINTK2(KERN_WARNING 1501 "ICMPv6 Redirect: invalid link-layer address length\n"); 1502 return; 1503 } 1504 } 1505 1506 neigh = __neigh_lookup(&nd_tbl, target, skb->dev, 1); 1507 if (neigh) { 1508 rt6_redirect(dest, &ipv6_hdr(skb)->daddr, 1509 &ipv6_hdr(skb)->saddr, neigh, lladdr, 1510 on_link); 1511 neigh_release(neigh); 1512 } 1513} 1514 1515void ndisc_send_redirect(struct sk_buff *skb, struct neighbour *neigh, 1516 const struct in6_addr *target) 1517{ 1518 struct net_device *dev = skb->dev; 1519 struct net *net = dev_net(dev); 1520 struct sock *sk = net->ipv6.ndisc_sk; 1521 int len = sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr); 1522 struct sk_buff *buff; 1523 struct icmp6hdr *icmph; 1524 struct in6_addr saddr_buf; 1525 struct in6_addr *addrp; 1526 struct rt6_info *rt; 1527 struct dst_entry *dst; 1528 struct inet6_dev *idev; 1529 struct flowi6 fl6; 1530 u8 *opt; 1531 int hlen, tlen; 1532 int rd_len; 1533 int err; 1534 u8 ha_buf[MAX_ADDR_LEN], *ha = NULL; 1535 1536 if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) { 1537 ND_PRINTK2(KERN_WARNING 1538 "ICMPv6 Redirect: no link-local address on %s\n", 1539 dev->name); 1540 return; 1541 } 1542 1543 if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) && 1544 ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) { 1545 ND_PRINTK2(KERN_WARNING 1546 "ICMPv6 Redirect: target address is not link-local unicast.\n"); 1547 return; 1548 } 1549 1550 icmpv6_flow_init(sk, &fl6, NDISC_REDIRECT, 1551 &saddr_buf, &ipv6_hdr(skb)->saddr, dev->ifindex); 1552 1553 dst = ip6_route_output(net, NULL, &fl6); 1554 if (dst == NULL) 1555 return; 1556 1557 dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), NULL, 0); 1558 if (IS_ERR(dst)) 1559 return; 1560 1561 rt = (struct rt6_info *) dst; 1562 1563 if (rt->rt6i_flags & RTF_GATEWAY) { 1564 ND_PRINTK2(KERN_WARNING 1565 "ICMPv6 Redirect: destination is not a neighbour.\n"); 1566 goto release; 1567 } 1568 if (!rt->rt6i_peer) 1569 rt6_bind_peer(rt, 1); 1570 if (!inet_peer_xrlim_allow(rt->rt6i_peer, 1*HZ)) 1571 goto release; 1572 1573 if (dev->addr_len) { 1574 read_lock_bh(&neigh->lock); 1575 if (neigh->nud_state & NUD_VALID) { 1576 memcpy(ha_buf, neigh->ha, dev->addr_len); 1577 read_unlock_bh(&neigh->lock); 1578 ha = ha_buf; 1579 len += ndisc_opt_addr_space(dev); 1580 } else 1581 read_unlock_bh(&neigh->lock); 1582 } 1583 1584 rd_len = min_t(unsigned int, 1585 IPV6_MIN_MTU-sizeof(struct ipv6hdr)-len, skb->len + 8); 1586 rd_len &= ~0x7; 1587 len += rd_len; 1588 1589 hlen = LL_RESERVED_SPACE(dev); 1590 tlen = dev->needed_tailroom; 1591 buff = sock_alloc_send_skb(sk, 1592 (MAX_HEADER + sizeof(struct ipv6hdr) + 1593 len + hlen + tlen), 1594 1, &err); 1595 if (buff == NULL) { 1596 ND_PRINTK0(KERN_ERR 1597 "ICMPv6 Redirect: %s() failed to allocate an skb, err=%d.\n", 1598 __func__, err); 1599 goto release; 1600 } 1601 1602 skb_reserve(buff, hlen); 1603 ip6_nd_hdr(sk, buff, dev, &saddr_buf, &ipv6_hdr(skb)->saddr, 1604 IPPROTO_ICMPV6, len); 1605 1606 skb_set_transport_header(buff, skb_tail_pointer(buff) - buff->data); 1607 skb_put(buff, len); 1608 icmph = icmp6_hdr(buff); 1609 1610 memset(icmph, 0, sizeof(struct icmp6hdr)); 1611 icmph->icmp6_type = NDISC_REDIRECT; 1612 1613 /* 1614 * copy target and destination addresses 1615 */ 1616 1617 addrp = (struct in6_addr *)(icmph + 1); 1618 *addrp = *target; 1619 addrp++; 1620 *addrp = ipv6_hdr(skb)->daddr; 1621 1622 opt = (u8*) (addrp + 1); 1623 1624 /* 1625 * include target_address option 1626 */ 1627 1628 if (ha) 1629 opt = ndisc_fill_addr_option(opt, ND_OPT_TARGET_LL_ADDR, ha, 1630 dev->addr_len, dev->type); 1631 1632 /* 1633 * build redirect option and copy skb over to the new packet. 1634 */ 1635 1636 memset(opt, 0, 8); 1637 *(opt++) = ND_OPT_REDIRECT_HDR; 1638 *(opt++) = (rd_len >> 3); 1639 opt += 6; 1640 1641 memcpy(opt, ipv6_hdr(skb), rd_len - 8); 1642 1643 icmph->icmp6_cksum = csum_ipv6_magic(&saddr_buf, &ipv6_hdr(skb)->saddr, 1644 len, IPPROTO_ICMPV6, 1645 csum_partial(icmph, len, 0)); 1646 1647 skb_dst_set(buff, dst); 1648 rcu_read_lock(); 1649 idev = __in6_dev_get(dst->dev); 1650 IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len); 1651 err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, buff, NULL, dst->dev, 1652 dst_output); 1653 if (!err) { 1654 ICMP6MSGOUT_INC_STATS(net, idev, NDISC_REDIRECT); 1655 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS); 1656 } 1657 1658 rcu_read_unlock(); 1659 return; 1660 1661release: 1662 dst_release(dst); 1663} 1664 1665static void pndisc_redo(struct sk_buff *skb) 1666{ 1667 ndisc_recv_ns(skb); 1668 kfree_skb(skb); 1669} 1670 1671int ndisc_rcv(struct sk_buff *skb) 1672{ 1673 struct nd_msg *msg; 1674 1675 if (!pskb_may_pull(skb, skb->len)) 1676 return 0; 1677 1678 msg = (struct nd_msg *)skb_transport_header(skb); 1679 1680 __skb_push(skb, skb->data - skb_transport_header(skb)); 1681 1682 if (ipv6_hdr(skb)->hop_limit != 255) { 1683 ND_PRINTK2(KERN_WARNING 1684 "ICMPv6 NDISC: invalid hop-limit: %d\n", 1685 ipv6_hdr(skb)->hop_limit); 1686 return 0; 1687 } 1688 1689 if (msg->icmph.icmp6_code != 0) { 1690 ND_PRINTK2(KERN_WARNING 1691 "ICMPv6 NDISC: invalid ICMPv6 code: %d\n", 1692 msg->icmph.icmp6_code); 1693 return 0; 1694 } 1695 1696 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb)); 1697 1698 switch (msg->icmph.icmp6_type) { 1699 case NDISC_NEIGHBOUR_SOLICITATION: 1700 ndisc_recv_ns(skb); 1701 break; 1702 1703 case NDISC_NEIGHBOUR_ADVERTISEMENT: 1704 ndisc_recv_na(skb); 1705 break; 1706 1707 case NDISC_ROUTER_SOLICITATION: 1708 ndisc_recv_rs(skb); 1709 break; 1710 1711 case NDISC_ROUTER_ADVERTISEMENT: 1712 ndisc_router_discovery(skb); 1713 break; 1714 1715 case NDISC_REDIRECT: 1716 ndisc_redirect_rcv(skb); 1717 break; 1718 } 1719 1720 return 0; 1721} 1722 1723static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr) 1724{ 1725 struct net_device *dev = ptr; 1726 struct net *net = dev_net(dev); 1727 1728 switch (event) { 1729 case NETDEV_CHANGEADDR: 1730 neigh_changeaddr(&nd_tbl, dev); 1731 fib6_run_gc(~0UL, net); 1732 break; 1733 case NETDEV_DOWN: 1734 neigh_ifdown(&nd_tbl, dev); 1735 fib6_run_gc(~0UL, net); 1736 break; 1737 case NETDEV_NOTIFY_PEERS: 1738 ndisc_send_unsol_na(dev); 1739 break; 1740 default: 1741 break; 1742 } 1743 1744 return NOTIFY_DONE; 1745} 1746 1747static struct notifier_block ndisc_netdev_notifier = { 1748 .notifier_call = ndisc_netdev_event, 1749}; 1750 1751#ifdef CONFIG_SYSCTL 1752static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl, 1753 const char *func, const char *dev_name) 1754{ 1755 static char warncomm[TASK_COMM_LEN]; 1756 static int warned; 1757 if (strcmp(warncomm, current->comm) && warned < 5) { 1758 strcpy(warncomm, current->comm); 1759 printk(KERN_WARNING 1760 "process `%s' is using deprecated sysctl (%s) " 1761 "net.ipv6.neigh.%s.%s; " 1762 "Use net.ipv6.neigh.%s.%s_ms " 1763 "instead.\n", 1764 warncomm, func, 1765 dev_name, ctl->procname, 1766 dev_name, ctl->procname); 1767 warned++; 1768 } 1769} 1770 1771int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, void __user *buffer, size_t *lenp, loff_t *ppos) 1772{ 1773 struct net_device *dev = ctl->extra1; 1774 struct inet6_dev *idev; 1775 int ret; 1776 1777 if ((strcmp(ctl->procname, "retrans_time") == 0) || 1778 (strcmp(ctl->procname, "base_reachable_time") == 0)) 1779 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default"); 1780 1781 if (strcmp(ctl->procname, "retrans_time") == 0) 1782 ret = proc_dointvec(ctl, write, buffer, lenp, ppos); 1783 1784 else if (strcmp(ctl->procname, "base_reachable_time") == 0) 1785 ret = proc_dointvec_jiffies(ctl, write, 1786 buffer, lenp, ppos); 1787 1788 else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) || 1789 (strcmp(ctl->procname, "base_reachable_time_ms") == 0)) 1790 ret = proc_dointvec_ms_jiffies(ctl, write, 1791 buffer, lenp, ppos); 1792 else 1793 ret = -1; 1794 1795 if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) { 1796 if (ctl->data == &idev->nd_parms->base_reachable_time) 1797 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time); 1798 idev->tstamp = jiffies; 1799 inet6_ifinfo_notify(RTM_NEWLINK, idev); 1800 in6_dev_put(idev); 1801 } 1802 return ret; 1803} 1804 1805 1806#endif 1807 1808static int __net_init ndisc_net_init(struct net *net) 1809{ 1810 struct ipv6_pinfo *np; 1811 struct sock *sk; 1812 int err; 1813 1814 err = inet_ctl_sock_create(&sk, PF_INET6, 1815 SOCK_RAW, IPPROTO_ICMPV6, net); 1816 if (err < 0) { 1817 ND_PRINTK0(KERN_ERR 1818 "ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n", 1819 err); 1820 return err; 1821 } 1822 1823 net->ipv6.ndisc_sk = sk; 1824 1825 np = inet6_sk(sk); 1826 np->hop_limit = 255; 1827 /* Do not loopback ndisc messages */ 1828 np->mc_loop = 0; 1829 1830 return 0; 1831} 1832 1833static void __net_exit ndisc_net_exit(struct net *net) 1834{ 1835 inet_ctl_sock_destroy(net->ipv6.ndisc_sk); 1836} 1837 1838static struct pernet_operations ndisc_net_ops = { 1839 .init = ndisc_net_init, 1840 .exit = ndisc_net_exit, 1841}; 1842 1843int __init ndisc_init(void) 1844{ 1845 int err; 1846 1847 err = register_pernet_subsys(&ndisc_net_ops); 1848 if (err) 1849 return err; 1850 /* 1851 * Initialize the neighbour table 1852 */ 1853 neigh_table_init(&nd_tbl); 1854 1855#ifdef CONFIG_SYSCTL 1856 err = neigh_sysctl_register(NULL, &nd_tbl.parms, "ipv6", 1857 &ndisc_ifinfo_sysctl_change); 1858 if (err) 1859 goto out_unregister_pernet; 1860#endif 1861 err = register_netdevice_notifier(&ndisc_netdev_notifier); 1862 if (err) 1863 goto out_unregister_sysctl; 1864out: 1865 return err; 1866 1867out_unregister_sysctl: 1868#ifdef CONFIG_SYSCTL 1869 neigh_sysctl_unregister(&nd_tbl.parms); 1870out_unregister_pernet: 1871#endif 1872 unregister_pernet_subsys(&ndisc_net_ops); 1873 goto out; 1874} 1875 1876void ndisc_cleanup(void) 1877{ 1878 unregister_netdevice_notifier(&ndisc_netdev_notifier); 1879#ifdef CONFIG_SYSCTL 1880 neigh_sysctl_unregister(&nd_tbl.parms); 1881#endif 1882 neigh_table_clear(&nd_tbl); 1883 unregister_pernet_subsys(&ndisc_net_ops); 1884} 1885