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