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