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 struct sk_buff *ndisc_build_skb(struct net_device *dev, 441 const struct in6_addr *daddr, 442 const struct in6_addr *saddr, 443 struct icmp6hdr *icmp6h, 444 const struct in6_addr *target, 445 int llinfo) 446 { 447 struct net *net = dev_net(dev); 448 struct sock *sk = net->ipv6.ndisc_sk; 449 struct sk_buff *skb; 450 struct icmp6hdr *hdr; 451 int len; 452 int err; 453 u8 *opt; 454 455 if (!dev->addr_len) 456 llinfo = 0; 457 458 len = sizeof(struct icmp6hdr) + (target ? sizeof(*target) : 0); 459 if (llinfo) 460 len += ndisc_opt_addr_space(dev); 461 462 skb = sock_alloc_send_skb(sk, 463 (MAX_HEADER + sizeof(struct ipv6hdr) + 464 len + LL_ALLOCATED_SPACE(dev)), 465 1, &err); 466 if (!skb) { 467 ND_PRINTK0(KERN_ERR 468 "ICMPv6 ND: %s() failed to allocate an skb.\n", 469 __func__); 470 return NULL; 471 } 472 473 skb_reserve(skb, LL_RESERVED_SPACE(dev)); 474 ip6_nd_hdr(sk, skb, dev, saddr, daddr, IPPROTO_ICMPV6, len); 475 476 skb->transport_header = skb->tail; 477 skb_put(skb, len); 478 479 hdr = (struct icmp6hdr *)skb_transport_header(skb); 480 memcpy(hdr, icmp6h, sizeof(*hdr)); 481 482 opt = skb_transport_header(skb) + sizeof(struct icmp6hdr); 483 if (target) { 484 ipv6_addr_copy((struct in6_addr *)opt, target); 485 opt += sizeof(*target); 486 } 487 488 if (llinfo) 489 ndisc_fill_addr_option(opt, llinfo, dev->dev_addr, 490 dev->addr_len, dev->type); 491 492 hdr->icmp6_cksum = csum_ipv6_magic(saddr, daddr, len, 493 IPPROTO_ICMPV6, 494 csum_partial(hdr, 495 len, 0)); 496 497 return skb; 498 } 499 500 EXPORT_SYMBOL(ndisc_build_skb); 501 502 void ndisc_send_skb(struct sk_buff *skb, 503 struct net_device *dev, 504 struct neighbour *neigh, 505 const struct in6_addr *daddr, 506 const struct in6_addr *saddr, 507 struct icmp6hdr *icmp6h) 508 { 509 struct flowi fl; 510 struct dst_entry *dst; 511 struct net *net = dev_net(dev); 512 struct sock *sk = net->ipv6.ndisc_sk; 513 struct inet6_dev *idev; 514 int err; 515 u8 type; 516 517 type = icmp6h->icmp6_type; 518 519 icmpv6_flow_init(sk, &fl, type, saddr, daddr, dev->ifindex); 520 521 dst = icmp6_dst_alloc(dev, neigh, daddr); 522 if (!dst) { 523 kfree_skb(skb); 524 return; 525 } 526 527 err = xfrm_lookup(net, &dst, &fl, NULL, 0); 528 if (err < 0) { 529 kfree_skb(skb); 530 return; 531 } 532 533 skb->dst = dst; 534 535 idev = in6_dev_get(dst->dev); 536 IP6_INC_STATS(net, idev, IPSTATS_MIB_OUTREQUESTS); 537 538 err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, skb, NULL, dst->dev, 539 dst_output); 540 if (!err) { 541 ICMP6MSGOUT_INC_STATS(net, idev, type); 542 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS); 543 } 544 545 if (likely(idev != NULL)) 546 in6_dev_put(idev); 547 } 548 549 EXPORT_SYMBOL(ndisc_send_skb); 550 551 /* 552 * Send a Neighbour Discover packet 553 */ 554 static void __ndisc_send(struct net_device *dev, 555 struct neighbour *neigh, 556 const struct in6_addr *daddr, 557 const struct in6_addr *saddr, 558 struct icmp6hdr *icmp6h, const struct in6_addr *target, 559 int llinfo) 560 { 561 struct sk_buff *skb; 562 563 skb = ndisc_build_skb(dev, daddr, saddr, icmp6h, target, llinfo); 564 if (!skb) 565 return; 566 567 ndisc_send_skb(skb, dev, neigh, daddr, saddr, icmp6h); 568 } 569 570 static void ndisc_send_na(struct net_device *dev, struct neighbour *neigh, 571 const struct in6_addr *daddr, 572 const struct in6_addr *solicited_addr, 573 int router, int solicited, int override, int inc_opt) 574 { 575 struct in6_addr tmpaddr; 576 struct inet6_ifaddr *ifp; 577 const struct in6_addr *src_addr; 578 struct icmp6hdr icmp6h = { 579 .icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT, 580 }; 581 582 /* for anycast or proxy, solicited_addr != src_addr */ 583 ifp = ipv6_get_ifaddr(dev_net(dev), solicited_addr, dev, 1); 584 if (ifp) { 585 src_addr = solicited_addr; 586 if (ifp->flags & IFA_F_OPTIMISTIC) 587 override = 0; 588 in6_ifa_put(ifp); 589 } else { 590 if (ipv6_dev_get_saddr(dev_net(dev), dev, daddr, 591 inet6_sk(dev_net(dev)->ipv6.ndisc_sk)->srcprefs, 592 &tmpaddr)) 593 return; 594 src_addr = &tmpaddr; 595 } 596 597 icmp6h.icmp6_router = router; 598 icmp6h.icmp6_solicited = solicited; 599 icmp6h.icmp6_override = override; 600 601 __ndisc_send(dev, neigh, daddr, src_addr, 602 &icmp6h, solicited_addr, 603 inc_opt ? ND_OPT_TARGET_LL_ADDR : 0); 604 } 605 606 void ndisc_send_ns(struct net_device *dev, struct neighbour *neigh, 607 const struct in6_addr *solicit, 608 const struct in6_addr *daddr, const struct in6_addr *saddr) 609 { 610 struct in6_addr addr_buf; 611 struct icmp6hdr icmp6h = { 612 .icmp6_type = NDISC_NEIGHBOUR_SOLICITATION, 613 }; 614 615 if (saddr == NULL) { 616 if (ipv6_get_lladdr(dev, &addr_buf, 617 (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC))) 618 return; 619 saddr = &addr_buf; 620 } 621 622 __ndisc_send(dev, neigh, daddr, saddr, 623 &icmp6h, solicit, 624 !ipv6_addr_any(saddr) ? ND_OPT_SOURCE_LL_ADDR : 0); 625 } 626 627 void ndisc_send_rs(struct net_device *dev, const struct in6_addr *saddr, 628 const struct in6_addr *daddr) 629 { 630 struct icmp6hdr icmp6h = { 631 .icmp6_type = NDISC_ROUTER_SOLICITATION, 632 }; 633 int send_sllao = dev->addr_len; 634 635 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD 636 /* 637 * According to section 2.2 of RFC 4429, we must not 638 * send router solicitations with a sllao from 639 * optimistic addresses, but we may send the solicitation 640 * if we don't include the sllao. So here we check 641 * if our address is optimistic, and if so, we 642 * suppress the inclusion of the sllao. 643 */ 644 if (send_sllao) { 645 struct inet6_ifaddr *ifp = ipv6_get_ifaddr(dev_net(dev), saddr, 646 dev, 1); 647 if (ifp) { 648 if (ifp->flags & IFA_F_OPTIMISTIC) { 649 send_sllao = 0; 650 } 651 in6_ifa_put(ifp); 652 } else { 653 send_sllao = 0; 654 } 655 } 656 #endif 657 __ndisc_send(dev, NULL, daddr, saddr, 658 &icmp6h, NULL, 659 send_sllao ? ND_OPT_SOURCE_LL_ADDR : 0); 660 } 661 662 663 static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb) 664 { 665 /* 666 * "The sender MUST return an ICMP 667 * destination unreachable" 668 */ 669 dst_link_failure(skb); 670 kfree_skb(skb); 671 } 672 673 /* Called with locked neigh: either read or both */ 674 675 static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb) 676 { 677 struct in6_addr *saddr = NULL; 678 struct in6_addr mcaddr; 679 struct net_device *dev = neigh->dev; 680 struct in6_addr *target = (struct in6_addr *)&neigh->primary_key; 681 int probes = atomic_read(&neigh->probes); 682 683 if (skb && ipv6_chk_addr(dev_net(dev), &ipv6_hdr(skb)->saddr, dev, 1)) 684 saddr = &ipv6_hdr(skb)->saddr; 685 686 if ((probes -= neigh->parms->ucast_probes) < 0) { 687 if (!(neigh->nud_state & NUD_VALID)) { 688 ND_PRINTK1(KERN_DEBUG "%s(): trying to ucast probe in NUD_INVALID: %pI6\n", 689 __func__, target); 690 } 691 ndisc_send_ns(dev, neigh, target, target, saddr); 692 } else if ((probes -= neigh->parms->app_probes) < 0) { 693 #ifdef CONFIG_ARPD 694 neigh_app_ns(neigh); 695 #endif 696 } else { 697 addrconf_addr_solict_mult(target, &mcaddr); 698 ndisc_send_ns(dev, NULL, target, &mcaddr, saddr); 699 } 700 } 701 702 static int pndisc_is_router(const void *pkey, 703 struct net_device *dev) 704 { 705 struct pneigh_entry *n; 706 int ret = -1; 707 708 read_lock_bh(&nd_tbl.lock); 709 n = __pneigh_lookup(&nd_tbl, dev_net(dev), pkey, dev); 710 if (n) 711 ret = !!(n->flags & NTF_ROUTER); 712 read_unlock_bh(&nd_tbl.lock); 713 714 return ret; 715 } 716 717 static void ndisc_recv_ns(struct sk_buff *skb) 718 { 719 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb); 720 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr; 721 struct in6_addr *daddr = &ipv6_hdr(skb)->daddr; 722 u8 *lladdr = NULL; 723 u32 ndoptlen = skb->tail - (skb->transport_header + 724 offsetof(struct nd_msg, opt)); 725 struct ndisc_options ndopts; 726 struct net_device *dev = skb->dev; 727 struct inet6_ifaddr *ifp; 728 struct inet6_dev *idev = NULL; 729 struct neighbour *neigh; 730 int dad = ipv6_addr_any(saddr); 731 int inc; 732 int is_router = -1; 733 734 if (ipv6_addr_is_multicast(&msg->target)) { 735 ND_PRINTK2(KERN_WARNING 736 "ICMPv6 NS: multicast target address"); 737 return; 738 } 739 740 /* 741 * RFC2461 7.1.1: 742 * DAD has to be destined for solicited node multicast address. 743 */ 744 if (dad && 745 !(daddr->s6_addr32[0] == htonl(0xff020000) && 746 daddr->s6_addr32[1] == htonl(0x00000000) && 747 daddr->s6_addr32[2] == htonl(0x00000001) && 748 daddr->s6_addr [12] == 0xff )) { 749 ND_PRINTK2(KERN_WARNING 750 "ICMPv6 NS: bad DAD packet (wrong destination)\n"); 751 return; 752 } 753 754 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) { 755 ND_PRINTK2(KERN_WARNING 756 "ICMPv6 NS: invalid ND options\n"); 757 return; 758 } 759 760 if (ndopts.nd_opts_src_lladdr) { 761 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev); 762 if (!lladdr) { 763 ND_PRINTK2(KERN_WARNING 764 "ICMPv6 NS: invalid link-layer address length\n"); 765 return; 766 } 767 768 /* RFC2461 7.1.1: 769 * If the IP source address is the unspecified address, 770 * there MUST NOT be source link-layer address option 771 * in the message. 772 */ 773 if (dad) { 774 ND_PRINTK2(KERN_WARNING 775 "ICMPv6 NS: bad DAD packet (link-layer address option)\n"); 776 return; 777 } 778 } 779 780 inc = ipv6_addr_is_multicast(daddr); 781 782 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1); 783 if (ifp) { 784 785 if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) { 786 if (dad) { 787 if (dev->type == ARPHRD_IEEE802_TR) { 788 const unsigned char *sadr; 789 sadr = skb_mac_header(skb); 790 if (((sadr[8] ^ dev->dev_addr[0]) & 0x7f) == 0 && 791 sadr[9] == dev->dev_addr[1] && 792 sadr[10] == dev->dev_addr[2] && 793 sadr[11] == dev->dev_addr[3] && 794 sadr[12] == dev->dev_addr[4] && 795 sadr[13] == dev->dev_addr[5]) { 796 /* looped-back to us */ 797 goto out; 798 } 799 } 800 801 /* 802 * We are colliding with another node 803 * who is doing DAD 804 * so fail our DAD process 805 */ 806 addrconf_dad_failure(ifp); 807 return; 808 } else { 809 /* 810 * This is not a dad solicitation. 811 * If we are an optimistic node, 812 * we should respond. 813 * Otherwise, we should ignore it. 814 */ 815 if (!(ifp->flags & IFA_F_OPTIMISTIC)) 816 goto out; 817 } 818 } 819 820 idev = ifp->idev; 821 } else { 822 struct net *net = dev_net(dev); 823 824 idev = in6_dev_get(dev); 825 if (!idev) { 826 /* XXX: count this drop? */ 827 return; 828 } 829 830 if (ipv6_chk_acast_addr(net, dev, &msg->target) || 831 (idev->cnf.forwarding && 832 (net->ipv6.devconf_all->proxy_ndp || idev->cnf.proxy_ndp) && 833 (is_router = pndisc_is_router(&msg->target, dev)) >= 0)) { 834 if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) && 835 skb->pkt_type != PACKET_HOST && 836 inc != 0 && 837 idev->nd_parms->proxy_delay != 0) { 838 /* 839 * for anycast or proxy, 840 * sender should delay its response 841 * by a random time between 0 and 842 * MAX_ANYCAST_DELAY_TIME seconds. 843 * (RFC2461) -- yoshfuji 844 */ 845 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC); 846 if (n) 847 pneigh_enqueue(&nd_tbl, idev->nd_parms, n); 848 goto out; 849 } 850 } else 851 goto out; 852 } 853 854 if (is_router < 0) 855 is_router = !!idev->cnf.forwarding; 856 857 if (dad) { 858 ndisc_send_na(dev, NULL, &in6addr_linklocal_allnodes, &msg->target, 859 is_router, 0, (ifp != NULL), 1); 860 goto out; 861 } 862 863 if (inc) 864 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast); 865 else 866 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast); 867 868 /* 869 * update / create cache entry 870 * for the source address 871 */ 872 neigh = __neigh_lookup(&nd_tbl, saddr, dev, 873 !inc || lladdr || !dev->addr_len); 874 if (neigh) 875 neigh_update(neigh, lladdr, NUD_STALE, 876 NEIGH_UPDATE_F_WEAK_OVERRIDE| 877 NEIGH_UPDATE_F_OVERRIDE); 878 if (neigh || !dev->header_ops) { 879 ndisc_send_na(dev, neigh, saddr, &msg->target, 880 is_router, 881 1, (ifp != NULL && inc), inc); 882 if (neigh) 883 neigh_release(neigh); 884 } 885 886 out: 887 if (ifp) 888 in6_ifa_put(ifp); 889 else 890 in6_dev_put(idev); 891 892 return; 893 } 894 895 static void ndisc_recv_na(struct sk_buff *skb) 896 { 897 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb); 898 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr; 899 struct in6_addr *daddr = &ipv6_hdr(skb)->daddr; 900 u8 *lladdr = NULL; 901 u32 ndoptlen = skb->tail - (skb->transport_header + 902 offsetof(struct nd_msg, opt)); 903 struct ndisc_options ndopts; 904 struct net_device *dev = skb->dev; 905 struct inet6_ifaddr *ifp; 906 struct neighbour *neigh; 907 908 if (skb->len < sizeof(struct nd_msg)) { 909 ND_PRINTK2(KERN_WARNING 910 "ICMPv6 NA: packet too short\n"); 911 return; 912 } 913 914 if (ipv6_addr_is_multicast(&msg->target)) { 915 ND_PRINTK2(KERN_WARNING 916 "ICMPv6 NA: target address is multicast.\n"); 917 return; 918 } 919 920 if (ipv6_addr_is_multicast(daddr) && 921 msg->icmph.icmp6_solicited) { 922 ND_PRINTK2(KERN_WARNING 923 "ICMPv6 NA: solicited NA is multicasted.\n"); 924 return; 925 } 926 927 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) { 928 ND_PRINTK2(KERN_WARNING 929 "ICMPv6 NS: invalid ND option\n"); 930 return; 931 } 932 if (ndopts.nd_opts_tgt_lladdr) { 933 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev); 934 if (!lladdr) { 935 ND_PRINTK2(KERN_WARNING 936 "ICMPv6 NA: invalid link-layer address length\n"); 937 return; 938 } 939 } 940 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1); 941 if (ifp) { 942 if (ifp->flags & IFA_F_TENTATIVE) { 943 addrconf_dad_failure(ifp); 944 return; 945 } 946 /* What should we make now? The advertisement 947 is invalid, but ndisc specs say nothing 948 about it. It could be misconfiguration, or 949 an smart proxy agent tries to help us :-) 950 951 We should not print the error if NA has been 952 received from loopback - it is just our own 953 unsolicited advertisement. 954 */ 955 if (skb->pkt_type != PACKET_LOOPBACK) 956 ND_PRINTK1(KERN_WARNING 957 "ICMPv6 NA: someone advertises our address on %s!\n", 958 ifp->idev->dev->name); 959 in6_ifa_put(ifp); 960 return; 961 } 962 neigh = neigh_lookup(&nd_tbl, &msg->target, dev); 963 964 if (neigh) { 965 u8 old_flags = neigh->flags; 966 struct net *net = dev_net(dev); 967 968 if (neigh->nud_state & NUD_FAILED) 969 goto out; 970 971 /* 972 * Don't update the neighbor cache entry on a proxy NA from 973 * ourselves because either the proxied node is off link or it 974 * has already sent a NA to us. 975 */ 976 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) && 977 net->ipv6.devconf_all->forwarding && net->ipv6.devconf_all->proxy_ndp && 978 pneigh_lookup(&nd_tbl, net, &msg->target, dev, 0)) { 979 /* XXX: idev->cnf.prixy_ndp */ 980 goto out; 981 } 982 983 neigh_update(neigh, lladdr, 984 msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE, 985 NEIGH_UPDATE_F_WEAK_OVERRIDE| 986 (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)| 987 NEIGH_UPDATE_F_OVERRIDE_ISROUTER| 988 (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0)); 989 990 if ((old_flags & ~neigh->flags) & NTF_ROUTER) { 991 /* 992 * Change: router to host 993 */ 994 struct rt6_info *rt; 995 rt = rt6_get_dflt_router(saddr, dev); 996 if (rt) 997 ip6_del_rt(rt); 998 } 999 1000 out: 1001 neigh_release(neigh); 1002 } 1003 } 1004 1005 static void ndisc_recv_rs(struct sk_buff *skb) 1006 { 1007 struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb); 1008 unsigned long ndoptlen = skb->len - sizeof(*rs_msg); 1009 struct neighbour *neigh; 1010 struct inet6_dev *idev; 1011 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr; 1012 struct ndisc_options ndopts; 1013 u8 *lladdr = NULL; 1014 1015 if (skb->len < sizeof(*rs_msg)) 1016 return; 1017 1018 idev = in6_dev_get(skb->dev); 1019 if (!idev) { 1020 if (net_ratelimit()) 1021 ND_PRINTK1("ICMP6 RS: can't find in6 device\n"); 1022 return; 1023 } 1024 1025 /* Don't accept RS if we're not in router mode */ 1026 if (!idev->cnf.forwarding) 1027 goto out; 1028 1029 /* 1030 * Don't update NCE if src = ::; 1031 * this implies that the source node has no ip address assigned yet. 1032 */ 1033 if (ipv6_addr_any(saddr)) 1034 goto out; 1035 1036 /* Parse ND options */ 1037 if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) { 1038 if (net_ratelimit()) 1039 ND_PRINTK2("ICMP6 NS: invalid ND option, ignored\n"); 1040 goto out; 1041 } 1042 1043 if (ndopts.nd_opts_src_lladdr) { 1044 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, 1045 skb->dev); 1046 if (!lladdr) 1047 goto out; 1048 } 1049 1050 neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1); 1051 if (neigh) { 1052 neigh_update(neigh, lladdr, NUD_STALE, 1053 NEIGH_UPDATE_F_WEAK_OVERRIDE| 1054 NEIGH_UPDATE_F_OVERRIDE| 1055 NEIGH_UPDATE_F_OVERRIDE_ISROUTER); 1056 neigh_release(neigh); 1057 } 1058 out: 1059 in6_dev_put(idev); 1060 } 1061 1062 static void ndisc_ra_useropt(struct sk_buff *ra, struct nd_opt_hdr *opt) 1063 { 1064 struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb_transport_header(ra); 1065 struct sk_buff *skb; 1066 struct nlmsghdr *nlh; 1067 struct nduseroptmsg *ndmsg; 1068 struct net *net = dev_net(ra->dev); 1069 int err; 1070 int base_size = NLMSG_ALIGN(sizeof(struct nduseroptmsg) 1071 + (opt->nd_opt_len << 3)); 1072 size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr)); 1073 1074 skb = nlmsg_new(msg_size, GFP_ATOMIC); 1075 if (skb == NULL) { 1076 err = -ENOBUFS; 1077 goto errout; 1078 } 1079 1080 nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0); 1081 if (nlh == NULL) { 1082 goto nla_put_failure; 1083 } 1084 1085 ndmsg = nlmsg_data(nlh); 1086 ndmsg->nduseropt_family = AF_INET6; 1087 ndmsg->nduseropt_ifindex = ra->dev->ifindex; 1088 ndmsg->nduseropt_icmp_type = icmp6h->icmp6_type; 1089 ndmsg->nduseropt_icmp_code = icmp6h->icmp6_code; 1090 ndmsg->nduseropt_opts_len = opt->nd_opt_len << 3; 1091 1092 memcpy(ndmsg + 1, opt, opt->nd_opt_len << 3); 1093 1094 NLA_PUT(skb, NDUSEROPT_SRCADDR, sizeof(struct in6_addr), 1095 &ipv6_hdr(ra)->saddr); 1096 nlmsg_end(skb, nlh); 1097 1098 err = rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL, 1099 GFP_ATOMIC); 1100 if (err < 0) 1101 goto errout; 1102 1103 return; 1104 1105 nla_put_failure: 1106 nlmsg_free(skb); 1107 err = -EMSGSIZE; 1108 errout: 1109 rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err); 1110 } 1111 1112 static void ndisc_router_discovery(struct sk_buff *skb) 1113 { 1114 struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb); 1115 struct neighbour *neigh = NULL; 1116 struct inet6_dev *in6_dev; 1117 struct rt6_info *rt = NULL; 1118 int lifetime; 1119 struct ndisc_options ndopts; 1120 int optlen; 1121 unsigned int pref = 0; 1122 1123 __u8 * opt = (__u8 *)(ra_msg + 1); 1124 1125 optlen = (skb->tail - skb->transport_header) - sizeof(struct ra_msg); 1126 1127 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) { 1128 ND_PRINTK2(KERN_WARNING 1129 "ICMPv6 RA: source address is not link-local.\n"); 1130 return; 1131 } 1132 if (optlen < 0) { 1133 ND_PRINTK2(KERN_WARNING 1134 "ICMPv6 RA: packet too short\n"); 1135 return; 1136 } 1137 1138 #ifdef CONFIG_IPV6_NDISC_NODETYPE 1139 if (skb->ndisc_nodetype == NDISC_NODETYPE_HOST) { 1140 ND_PRINTK2(KERN_WARNING 1141 "ICMPv6 RA: from host or unauthorized router\n"); 1142 return; 1143 } 1144 #endif 1145 1146 /* 1147 * set the RA_RECV flag in the interface 1148 */ 1149 1150 in6_dev = in6_dev_get(skb->dev); 1151 if (in6_dev == NULL) { 1152 ND_PRINTK0(KERN_ERR 1153 "ICMPv6 RA: can't find inet6 device for %s.\n", 1154 skb->dev->name); 1155 return; 1156 } 1157 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_ra) { 1158 in6_dev_put(in6_dev); 1159 return; 1160 } 1161 1162 if (!ndisc_parse_options(opt, optlen, &ndopts)) { 1163 in6_dev_put(in6_dev); 1164 ND_PRINTK2(KERN_WARNING 1165 "ICMP6 RA: invalid ND options\n"); 1166 return; 1167 } 1168 1169 #ifdef CONFIG_IPV6_NDISC_NODETYPE 1170 /* skip link-specific parameters from interior routers */ 1171 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT) 1172 goto skip_linkparms; 1173 #endif 1174 1175 if (in6_dev->if_flags & IF_RS_SENT) { 1176 /* 1177 * flag that an RA was received after an RS was sent 1178 * out on this interface. 1179 */ 1180 in6_dev->if_flags |= IF_RA_RCVD; 1181 } 1182 1183 /* 1184 * Remember the managed/otherconf flags from most recently 1185 * received RA message (RFC 2462) -- yoshfuji 1186 */ 1187 in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED | 1188 IF_RA_OTHERCONF)) | 1189 (ra_msg->icmph.icmp6_addrconf_managed ? 1190 IF_RA_MANAGED : 0) | 1191 (ra_msg->icmph.icmp6_addrconf_other ? 1192 IF_RA_OTHERCONF : 0); 1193 1194 if (!in6_dev->cnf.accept_ra_defrtr) 1195 goto skip_defrtr; 1196 1197 lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime); 1198 1199 #ifdef CONFIG_IPV6_ROUTER_PREF 1200 pref = ra_msg->icmph.icmp6_router_pref; 1201 /* 10b is handled as if it were 00b (medium) */ 1202 if (pref == ICMPV6_ROUTER_PREF_INVALID || 1203 !in6_dev->cnf.accept_ra_rtr_pref) 1204 pref = ICMPV6_ROUTER_PREF_MEDIUM; 1205 #endif 1206 1207 rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev); 1208 1209 if (rt) 1210 neigh = rt->rt6i_nexthop; 1211 1212 if (rt && lifetime == 0) { 1213 neigh_clone(neigh); 1214 ip6_del_rt(rt); 1215 rt = NULL; 1216 } 1217 1218 if (rt == NULL && lifetime) { 1219 ND_PRINTK3(KERN_DEBUG 1220 "ICMPv6 RA: adding default router.\n"); 1221 1222 rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref); 1223 if (rt == NULL) { 1224 ND_PRINTK0(KERN_ERR 1225 "ICMPv6 RA: %s() failed to add default route.\n", 1226 __func__); 1227 in6_dev_put(in6_dev); 1228 return; 1229 } 1230 1231 neigh = rt->rt6i_nexthop; 1232 if (neigh == NULL) { 1233 ND_PRINTK0(KERN_ERR 1234 "ICMPv6 RA: %s() got default router without neighbour.\n", 1235 __func__); 1236 dst_release(&rt->u.dst); 1237 in6_dev_put(in6_dev); 1238 return; 1239 } 1240 neigh->flags |= NTF_ROUTER; 1241 } else if (rt) { 1242 rt->rt6i_flags = (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref); 1243 } 1244 1245 if (rt) 1246 rt->rt6i_expires = jiffies + (HZ * lifetime); 1247 1248 if (ra_msg->icmph.icmp6_hop_limit) { 1249 in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit; 1250 if (rt) 1251 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = ra_msg->icmph.icmp6_hop_limit; 1252 } 1253 1254 skip_defrtr: 1255 1256 /* 1257 * Update Reachable Time and Retrans Timer 1258 */ 1259 1260 if (in6_dev->nd_parms) { 1261 unsigned long rtime = ntohl(ra_msg->retrans_timer); 1262 1263 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) { 1264 rtime = (rtime*HZ)/1000; 1265 if (rtime < HZ/10) 1266 rtime = HZ/10; 1267 in6_dev->nd_parms->retrans_time = rtime; 1268 in6_dev->tstamp = jiffies; 1269 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev); 1270 } 1271 1272 rtime = ntohl(ra_msg->reachable_time); 1273 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) { 1274 rtime = (rtime*HZ)/1000; 1275 1276 if (rtime < HZ/10) 1277 rtime = HZ/10; 1278 1279 if (rtime != in6_dev->nd_parms->base_reachable_time) { 1280 in6_dev->nd_parms->base_reachable_time = rtime; 1281 in6_dev->nd_parms->gc_staletime = 3 * rtime; 1282 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime); 1283 in6_dev->tstamp = jiffies; 1284 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev); 1285 } 1286 } 1287 } 1288 1289 #ifdef CONFIG_IPV6_NDISC_NODETYPE 1290 skip_linkparms: 1291 #endif 1292 1293 /* 1294 * Process options. 1295 */ 1296 1297 if (!neigh) 1298 neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr, 1299 skb->dev, 1); 1300 if (neigh) { 1301 u8 *lladdr = NULL; 1302 if (ndopts.nd_opts_src_lladdr) { 1303 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, 1304 skb->dev); 1305 if (!lladdr) { 1306 ND_PRINTK2(KERN_WARNING 1307 "ICMPv6 RA: invalid link-layer address length\n"); 1308 goto out; 1309 } 1310 } 1311 neigh_update(neigh, lladdr, NUD_STALE, 1312 NEIGH_UPDATE_F_WEAK_OVERRIDE| 1313 NEIGH_UPDATE_F_OVERRIDE| 1314 NEIGH_UPDATE_F_OVERRIDE_ISROUTER| 1315 NEIGH_UPDATE_F_ISROUTER); 1316 } 1317 1318 #ifdef CONFIG_IPV6_ROUTE_INFO 1319 if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) { 1320 struct nd_opt_hdr *p; 1321 for (p = ndopts.nd_opts_ri; 1322 p; 1323 p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) { 1324 struct route_info *ri = (struct route_info *)p; 1325 #ifdef CONFIG_IPV6_NDISC_NODETYPE 1326 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT && 1327 ri->prefix_len == 0) 1328 continue; 1329 #endif 1330 if (ri->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen) 1331 continue; 1332 rt6_route_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3, 1333 &ipv6_hdr(skb)->saddr); 1334 } 1335 } 1336 #endif 1337 1338 #ifdef CONFIG_IPV6_NDISC_NODETYPE 1339 /* skip link-specific ndopts from interior routers */ 1340 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT) 1341 goto out; 1342 #endif 1343 1344 if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) { 1345 struct nd_opt_hdr *p; 1346 for (p = ndopts.nd_opts_pi; 1347 p; 1348 p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) { 1349 addrconf_prefix_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3); 1350 } 1351 } 1352 1353 if (ndopts.nd_opts_mtu) { 1354 __be32 n; 1355 u32 mtu; 1356 1357 memcpy(&n, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu)); 1358 mtu = ntohl(n); 1359 1360 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) { 1361 ND_PRINTK2(KERN_WARNING 1362 "ICMPv6 RA: invalid mtu: %d\n", 1363 mtu); 1364 } else if (in6_dev->cnf.mtu6 != mtu) { 1365 in6_dev->cnf.mtu6 = mtu; 1366 1367 if (rt) 1368 rt->u.dst.metrics[RTAX_MTU-1] = mtu; 1369 1370 rt6_mtu_change(skb->dev, mtu); 1371 } 1372 } 1373 1374 if (ndopts.nd_useropts) { 1375 struct nd_opt_hdr *p; 1376 for (p = ndopts.nd_useropts; 1377 p; 1378 p = ndisc_next_useropt(p, ndopts.nd_useropts_end)) { 1379 ndisc_ra_useropt(skb, p); 1380 } 1381 } 1382 1383 if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) { 1384 ND_PRINTK2(KERN_WARNING 1385 "ICMPv6 RA: invalid RA options"); 1386 } 1387 out: 1388 if (rt) 1389 dst_release(&rt->u.dst); 1390 else if (neigh) 1391 neigh_release(neigh); 1392 in6_dev_put(in6_dev); 1393 } 1394 1395 static void ndisc_redirect_rcv(struct sk_buff *skb) 1396 { 1397 struct inet6_dev *in6_dev; 1398 struct icmp6hdr *icmph; 1399 struct in6_addr *dest; 1400 struct in6_addr *target; /* new first hop to destination */ 1401 struct neighbour *neigh; 1402 int on_link = 0; 1403 struct ndisc_options ndopts; 1404 int optlen; 1405 u8 *lladdr = NULL; 1406 1407 #ifdef CONFIG_IPV6_NDISC_NODETYPE 1408 switch (skb->ndisc_nodetype) { 1409 case NDISC_NODETYPE_HOST: 1410 case NDISC_NODETYPE_NODEFAULT: 1411 ND_PRINTK2(KERN_WARNING 1412 "ICMPv6 Redirect: from host or unauthorized router\n"); 1413 return; 1414 } 1415 #endif 1416 1417 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) { 1418 ND_PRINTK2(KERN_WARNING 1419 "ICMPv6 Redirect: source address is not link-local.\n"); 1420 return; 1421 } 1422 1423 optlen = skb->tail - skb->transport_header; 1424 optlen -= sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr); 1425 1426 if (optlen < 0) { 1427 ND_PRINTK2(KERN_WARNING 1428 "ICMPv6 Redirect: packet too short\n"); 1429 return; 1430 } 1431 1432 icmph = icmp6_hdr(skb); 1433 target = (struct in6_addr *) (icmph + 1); 1434 dest = target + 1; 1435 1436 if (ipv6_addr_is_multicast(dest)) { 1437 ND_PRINTK2(KERN_WARNING 1438 "ICMPv6 Redirect: destination address is multicast.\n"); 1439 return; 1440 } 1441 1442 if (ipv6_addr_equal(dest, target)) { 1443 on_link = 1; 1444 } else if (ipv6_addr_type(target) != 1445 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) { 1446 ND_PRINTK2(KERN_WARNING 1447 "ICMPv6 Redirect: target address is not link-local unicast.\n"); 1448 return; 1449 } 1450 1451 in6_dev = in6_dev_get(skb->dev); 1452 if (!in6_dev) 1453 return; 1454 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects) { 1455 in6_dev_put(in6_dev); 1456 return; 1457 } 1458 1459 /* RFC2461 8.1: 1460 * The IP source address of the Redirect MUST be the same as the current 1461 * first-hop router for the specified ICMP Destination Address. 1462 */ 1463 1464 if (!ndisc_parse_options((u8*)(dest + 1), optlen, &ndopts)) { 1465 ND_PRINTK2(KERN_WARNING 1466 "ICMPv6 Redirect: invalid ND options\n"); 1467 in6_dev_put(in6_dev); 1468 return; 1469 } 1470 if (ndopts.nd_opts_tgt_lladdr) { 1471 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, 1472 skb->dev); 1473 if (!lladdr) { 1474 ND_PRINTK2(KERN_WARNING 1475 "ICMPv6 Redirect: invalid link-layer address length\n"); 1476 in6_dev_put(in6_dev); 1477 return; 1478 } 1479 } 1480 1481 neigh = __neigh_lookup(&nd_tbl, target, skb->dev, 1); 1482 if (neigh) { 1483 rt6_redirect(dest, &ipv6_hdr(skb)->daddr, 1484 &ipv6_hdr(skb)->saddr, neigh, lladdr, 1485 on_link); 1486 neigh_release(neigh); 1487 } 1488 in6_dev_put(in6_dev); 1489 } 1490 1491 void ndisc_send_redirect(struct sk_buff *skb, struct neighbour *neigh, 1492 const struct in6_addr *target) 1493 { 1494 struct net_device *dev = skb->dev; 1495 struct net *net = dev_net(dev); 1496 struct sock *sk = net->ipv6.ndisc_sk; 1497 int len = sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr); 1498 struct sk_buff *buff; 1499 struct icmp6hdr *icmph; 1500 struct in6_addr saddr_buf; 1501 struct in6_addr *addrp; 1502 struct rt6_info *rt; 1503 struct dst_entry *dst; 1504 struct inet6_dev *idev; 1505 struct flowi fl; 1506 u8 *opt; 1507 int rd_len; 1508 int err; 1509 u8 ha_buf[MAX_ADDR_LEN], *ha = NULL; 1510 1511 if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) { 1512 ND_PRINTK2(KERN_WARNING 1513 "ICMPv6 Redirect: no link-local address on %s\n", 1514 dev->name); 1515 return; 1516 } 1517 1518 if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) && 1519 ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) { 1520 ND_PRINTK2(KERN_WARNING 1521 "ICMPv6 Redirect: target address is not link-local unicast.\n"); 1522 return; 1523 } 1524 1525 icmpv6_flow_init(sk, &fl, NDISC_REDIRECT, 1526 &saddr_buf, &ipv6_hdr(skb)->saddr, dev->ifindex); 1527 1528 dst = ip6_route_output(net, NULL, &fl); 1529 if (dst == NULL) 1530 return; 1531 1532 err = xfrm_lookup(net, &dst, &fl, NULL, 0); 1533 if (err) 1534 return; 1535 1536 rt = (struct rt6_info *) dst; 1537 1538 if (rt->rt6i_flags & RTF_GATEWAY) { 1539 ND_PRINTK2(KERN_WARNING 1540 "ICMPv6 Redirect: destination is not a neighbour.\n"); 1541 goto release; 1542 } 1543 if (!xrlim_allow(dst, 1*HZ)) 1544 goto release; 1545 1546 if (dev->addr_len) { 1547 read_lock_bh(&neigh->lock); 1548 if (neigh->nud_state & NUD_VALID) { 1549 memcpy(ha_buf, neigh->ha, dev->addr_len); 1550 read_unlock_bh(&neigh->lock); 1551 ha = ha_buf; 1552 len += ndisc_opt_addr_space(dev); 1553 } else 1554 read_unlock_bh(&neigh->lock); 1555 } 1556 1557 rd_len = min_t(unsigned int, 1558 IPV6_MIN_MTU-sizeof(struct ipv6hdr)-len, skb->len + 8); 1559 rd_len &= ~0x7; 1560 len += rd_len; 1561 1562 buff = sock_alloc_send_skb(sk, 1563 (MAX_HEADER + sizeof(struct ipv6hdr) + 1564 len + LL_ALLOCATED_SPACE(dev)), 1565 1, &err); 1566 if (buff == NULL) { 1567 ND_PRINTK0(KERN_ERR 1568 "ICMPv6 Redirect: %s() failed to allocate an skb.\n", 1569 __func__); 1570 goto release; 1571 } 1572 1573 skb_reserve(buff, LL_RESERVED_SPACE(dev)); 1574 ip6_nd_hdr(sk, buff, dev, &saddr_buf, &ipv6_hdr(skb)->saddr, 1575 IPPROTO_ICMPV6, len); 1576 1577 skb_set_transport_header(buff, skb_tail_pointer(buff) - buff->data); 1578 skb_put(buff, len); 1579 icmph = icmp6_hdr(buff); 1580 1581 memset(icmph, 0, sizeof(struct icmp6hdr)); 1582 icmph->icmp6_type = NDISC_REDIRECT; 1583 1584 /* 1585 * copy target and destination addresses 1586 */ 1587 1588 addrp = (struct in6_addr *)(icmph + 1); 1589 ipv6_addr_copy(addrp, target); 1590 addrp++; 1591 ipv6_addr_copy(addrp, &ipv6_hdr(skb)->daddr); 1592 1593 opt = (u8*) (addrp + 1); 1594 1595 /* 1596 * include target_address option 1597 */ 1598 1599 if (ha) 1600 opt = ndisc_fill_addr_option(opt, ND_OPT_TARGET_LL_ADDR, ha, 1601 dev->addr_len, dev->type); 1602 1603 /* 1604 * build redirect option and copy skb over to the new packet. 1605 */ 1606 1607 memset(opt, 0, 8); 1608 *(opt++) = ND_OPT_REDIRECT_HDR; 1609 *(opt++) = (rd_len >> 3); 1610 opt += 6; 1611 1612 memcpy(opt, ipv6_hdr(skb), rd_len - 8); 1613 1614 icmph->icmp6_cksum = csum_ipv6_magic(&saddr_buf, &ipv6_hdr(skb)->saddr, 1615 len, IPPROTO_ICMPV6, 1616 csum_partial(icmph, len, 0)); 1617 1618 buff->dst = dst; 1619 idev = in6_dev_get(dst->dev); 1620 IP6_INC_STATS(net, idev, IPSTATS_MIB_OUTREQUESTS); 1621 err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, buff, NULL, dst->dev, 1622 dst_output); 1623 if (!err) { 1624 ICMP6MSGOUT_INC_STATS(net, idev, NDISC_REDIRECT); 1625 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS); 1626 } 1627 1628 if (likely(idev != NULL)) 1629 in6_dev_put(idev); 1630 return; 1631 1632 release: 1633 dst_release(dst); 1634 } 1635 1636 static void pndisc_redo(struct sk_buff *skb) 1637 { 1638 ndisc_recv_ns(skb); 1639 kfree_skb(skb); 1640 } 1641 1642 int ndisc_rcv(struct sk_buff *skb) 1643 { 1644 struct nd_msg *msg; 1645 1646 if (!pskb_may_pull(skb, skb->len)) 1647 return 0; 1648 1649 msg = (struct nd_msg *)skb_transport_header(skb); 1650 1651 __skb_push(skb, skb->data - skb_transport_header(skb)); 1652 1653 if (ipv6_hdr(skb)->hop_limit != 255) { 1654 ND_PRINTK2(KERN_WARNING 1655 "ICMPv6 NDISC: invalid hop-limit: %d\n", 1656 ipv6_hdr(skb)->hop_limit); 1657 return 0; 1658 } 1659 1660 if (msg->icmph.icmp6_code != 0) { 1661 ND_PRINTK2(KERN_WARNING 1662 "ICMPv6 NDISC: invalid ICMPv6 code: %d\n", 1663 msg->icmph.icmp6_code); 1664 return 0; 1665 } 1666 1667 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb)); 1668 1669 switch (msg->icmph.icmp6_type) { 1670 case NDISC_NEIGHBOUR_SOLICITATION: 1671 ndisc_recv_ns(skb); 1672 break; 1673 1674 case NDISC_NEIGHBOUR_ADVERTISEMENT: 1675 ndisc_recv_na(skb); 1676 break; 1677 1678 case NDISC_ROUTER_SOLICITATION: 1679 ndisc_recv_rs(skb); 1680 break; 1681 1682 case NDISC_ROUTER_ADVERTISEMENT: 1683 ndisc_router_discovery(skb); 1684 break; 1685 1686 case NDISC_REDIRECT: 1687 ndisc_redirect_rcv(skb); 1688 break; 1689 } 1690 1691 return 0; 1692 } 1693 1694 static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr) 1695 { 1696 struct net_device *dev = ptr; 1697 struct net *net = dev_net(dev); 1698 1699 switch (event) { 1700 case NETDEV_CHANGEADDR: 1701 neigh_changeaddr(&nd_tbl, dev); 1702 fib6_run_gc(~0UL, net); 1703 break; 1704 case NETDEV_DOWN: 1705 neigh_ifdown(&nd_tbl, dev); 1706 fib6_run_gc(~0UL, net); 1707 break; 1708 default: 1709 break; 1710 } 1711 1712 return NOTIFY_DONE; 1713 } 1714 1715 static struct notifier_block ndisc_netdev_notifier = { 1716 .notifier_call = ndisc_netdev_event, 1717 }; 1718 1719 #ifdef CONFIG_SYSCTL 1720 static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl, 1721 const char *func, const char *dev_name) 1722 { 1723 static char warncomm[TASK_COMM_LEN]; 1724 static int warned; 1725 if (strcmp(warncomm, current->comm) && warned < 5) { 1726 strcpy(warncomm, current->comm); 1727 printk(KERN_WARNING 1728 "process `%s' is using deprecated sysctl (%s) " 1729 "net.ipv6.neigh.%s.%s; " 1730 "Use net.ipv6.neigh.%s.%s_ms " 1731 "instead.\n", 1732 warncomm, func, 1733 dev_name, ctl->procname, 1734 dev_name, ctl->procname); 1735 warned++; 1736 } 1737 } 1738 1739 int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, struct file * filp, void __user *buffer, size_t *lenp, loff_t *ppos) 1740 { 1741 struct net_device *dev = ctl->extra1; 1742 struct inet6_dev *idev; 1743 int ret; 1744 1745 if ((strcmp(ctl->procname, "retrans_time") == 0) || 1746 (strcmp(ctl->procname, "base_reachable_time") == 0)) 1747 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default"); 1748 1749 if (strcmp(ctl->procname, "retrans_time") == 0) 1750 ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos); 1751 1752 else if (strcmp(ctl->procname, "base_reachable_time") == 0) 1753 ret = proc_dointvec_jiffies(ctl, write, 1754 filp, buffer, lenp, ppos); 1755 1756 else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) || 1757 (strcmp(ctl->procname, "base_reachable_time_ms") == 0)) 1758 ret = proc_dointvec_ms_jiffies(ctl, write, 1759 filp, buffer, lenp, ppos); 1760 else 1761 ret = -1; 1762 1763 if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) { 1764 if (ctl->data == &idev->nd_parms->base_reachable_time) 1765 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time); 1766 idev->tstamp = jiffies; 1767 inet6_ifinfo_notify(RTM_NEWLINK, idev); 1768 in6_dev_put(idev); 1769 } 1770 return ret; 1771 } 1772 1773 int ndisc_ifinfo_sysctl_strategy(ctl_table *ctl, 1774 void __user *oldval, size_t __user *oldlenp, 1775 void __user *newval, size_t newlen) 1776 { 1777 struct net_device *dev = ctl->extra1; 1778 struct inet6_dev *idev; 1779 int ret; 1780 1781 if (ctl->ctl_name == NET_NEIGH_RETRANS_TIME || 1782 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME) 1783 ndisc_warn_deprecated_sysctl(ctl, "procfs", dev ? dev->name : "default"); 1784 1785 switch (ctl->ctl_name) { 1786 case NET_NEIGH_REACHABLE_TIME: 1787 ret = sysctl_jiffies(ctl, oldval, oldlenp, newval, newlen); 1788 break; 1789 case NET_NEIGH_RETRANS_TIME_MS: 1790 case NET_NEIGH_REACHABLE_TIME_MS: 1791 ret = sysctl_ms_jiffies(ctl, oldval, oldlenp, newval, newlen); 1792 break; 1793 default: 1794 ret = 0; 1795 } 1796 1797 if (newval && newlen && ret > 0 && 1798 dev && (idev = in6_dev_get(dev)) != NULL) { 1799 if (ctl->ctl_name == NET_NEIGH_REACHABLE_TIME || 1800 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME_MS) 1801 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time); 1802 idev->tstamp = jiffies; 1803 inet6_ifinfo_notify(RTM_NEWLINK, idev); 1804 in6_dev_put(idev); 1805 } 1806 1807 return ret; 1808 } 1809 1810 #endif 1811 1812 static int ndisc_net_init(struct net *net) 1813 { 1814 struct ipv6_pinfo *np; 1815 struct sock *sk; 1816 int err; 1817 1818 err = inet_ctl_sock_create(&sk, PF_INET6, 1819 SOCK_RAW, IPPROTO_ICMPV6, net); 1820 if (err < 0) { 1821 ND_PRINTK0(KERN_ERR 1822 "ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n", 1823 err); 1824 return err; 1825 } 1826 1827 net->ipv6.ndisc_sk = sk; 1828 1829 np = inet6_sk(sk); 1830 np->hop_limit = 255; 1831 /* Do not loopback ndisc messages */ 1832 np->mc_loop = 0; 1833 1834 return 0; 1835 } 1836 1837 static void ndisc_net_exit(struct net *net) 1838 { 1839 inet_ctl_sock_destroy(net->ipv6.ndisc_sk); 1840 } 1841 1842 static struct pernet_operations ndisc_net_ops = { 1843 .init = ndisc_net_init, 1844 .exit = ndisc_net_exit, 1845 }; 1846 1847 int __init ndisc_init(void) 1848 { 1849 int err; 1850 1851 err = register_pernet_subsys(&ndisc_net_ops); 1852 if (err) 1853 return err; 1854 /* 1855 * Initialize the neighbour table 1856 */ 1857 neigh_table_init(&nd_tbl); 1858 1859 #ifdef CONFIG_SYSCTL 1860 err = neigh_sysctl_register(NULL, &nd_tbl.parms, NET_IPV6, 1861 NET_IPV6_NEIGH, "ipv6", 1862 &ndisc_ifinfo_sysctl_change, 1863 &ndisc_ifinfo_sysctl_strategy); 1864 if (err) 1865 goto out_unregister_pernet; 1866 #endif 1867 err = register_netdevice_notifier(&ndisc_netdev_notifier); 1868 if (err) 1869 goto out_unregister_sysctl; 1870 out: 1871 return err; 1872 1873 out_unregister_sysctl: 1874 #ifdef CONFIG_SYSCTL 1875 neigh_sysctl_unregister(&nd_tbl.parms); 1876 out_unregister_pernet: 1877 #endif 1878 unregister_pernet_subsys(&ndisc_net_ops); 1879 goto out; 1880 } 1881 1882 void ndisc_cleanup(void) 1883 { 1884 unregister_netdevice_notifier(&ndisc_netdev_notifier); 1885 #ifdef CONFIG_SYSCTL 1886 neigh_sysctl_unregister(&nd_tbl.parms); 1887 #endif 1888 neigh_table_clear(&nd_tbl); 1889 unregister_pernet_subsys(&ndisc_net_ops); 1890 } 1891