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_ALLOCATED_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(net, 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(net, idev, type); 525 ICMP6_INC_STATS(net, 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_net(dev), 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 struct net *net = dev_net(dev); 788 789 idev = in6_dev_get(dev); 790 if (!idev) { 791 /* XXX: count this drop? */ 792 return; 793 } 794 795 if (ipv6_chk_acast_addr(net, dev, &msg->target) || 796 (idev->cnf.forwarding && 797 (net->ipv6.devconf_all->proxy_ndp || idev->cnf.proxy_ndp) && 798 (is_router = pndisc_is_router(&msg->target, dev)) >= 0)) { 799 if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) && 800 skb->pkt_type != PACKET_HOST && 801 inc != 0 && 802 idev->nd_parms->proxy_delay != 0) { 803 /* 804 * for anycast or proxy, 805 * sender should delay its response 806 * by a random time between 0 and 807 * MAX_ANYCAST_DELAY_TIME seconds. 808 * (RFC2461) -- yoshfuji 809 */ 810 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC); 811 if (n) 812 pneigh_enqueue(&nd_tbl, idev->nd_parms, n); 813 goto out; 814 } 815 } else 816 goto out; 817 } 818 819 if (is_router < 0) 820 is_router = !!idev->cnf.forwarding; 821 822 if (dad) { 823 ndisc_send_na(dev, NULL, &in6addr_linklocal_allnodes, &msg->target, 824 is_router, 0, (ifp != NULL), 1); 825 goto out; 826 } 827 828 if (inc) 829 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast); 830 else 831 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast); 832 833 /* 834 * update / create cache entry 835 * for the source address 836 */ 837 neigh = __neigh_lookup(&nd_tbl, saddr, dev, 838 !inc || lladdr || !dev->addr_len); 839 if (neigh) 840 neigh_update(neigh, lladdr, NUD_STALE, 841 NEIGH_UPDATE_F_WEAK_OVERRIDE| 842 NEIGH_UPDATE_F_OVERRIDE); 843 if (neigh || !dev->header_ops) { 844 ndisc_send_na(dev, neigh, saddr, &msg->target, 845 is_router, 846 1, (ifp != NULL && inc), inc); 847 if (neigh) 848 neigh_release(neigh); 849 } 850 851 out: 852 if (ifp) 853 in6_ifa_put(ifp); 854 else 855 in6_dev_put(idev); 856 857 return; 858 } 859 860 static void ndisc_recv_na(struct sk_buff *skb) 861 { 862 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb); 863 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr; 864 struct in6_addr *daddr = &ipv6_hdr(skb)->daddr; 865 u8 *lladdr = NULL; 866 u32 ndoptlen = skb->tail - (skb->transport_header + 867 offsetof(struct nd_msg, opt)); 868 struct ndisc_options ndopts; 869 struct net_device *dev = skb->dev; 870 struct inet6_ifaddr *ifp; 871 struct neighbour *neigh; 872 873 if (skb->len < sizeof(struct nd_msg)) { 874 ND_PRINTK2(KERN_WARNING 875 "ICMPv6 NA: packet too short\n"); 876 return; 877 } 878 879 if (ipv6_addr_is_multicast(&msg->target)) { 880 ND_PRINTK2(KERN_WARNING 881 "ICMPv6 NA: target address is multicast.\n"); 882 return; 883 } 884 885 if (ipv6_addr_is_multicast(daddr) && 886 msg->icmph.icmp6_solicited) { 887 ND_PRINTK2(KERN_WARNING 888 "ICMPv6 NA: solicited NA is multicasted.\n"); 889 return; 890 } 891 892 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) { 893 ND_PRINTK2(KERN_WARNING 894 "ICMPv6 NS: invalid ND option\n"); 895 return; 896 } 897 if (ndopts.nd_opts_tgt_lladdr) { 898 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev); 899 if (!lladdr) { 900 ND_PRINTK2(KERN_WARNING 901 "ICMPv6 NA: invalid link-layer address length\n"); 902 return; 903 } 904 } 905 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1); 906 if (ifp) { 907 if (ifp->flags & IFA_F_TENTATIVE) { 908 addrconf_dad_failure(ifp); 909 return; 910 } 911 /* What should we make now? The advertisement 912 is invalid, but ndisc specs say nothing 913 about it. It could be misconfiguration, or 914 an smart proxy agent tries to help us :-) 915 916 We should not print the error if NA has been 917 received from loopback - it is just our own 918 unsolicited advertisement. 919 */ 920 if (skb->pkt_type != PACKET_LOOPBACK) 921 ND_PRINTK1(KERN_WARNING 922 "ICMPv6 NA: someone advertises our address on %s!\n", 923 ifp->idev->dev->name); 924 in6_ifa_put(ifp); 925 return; 926 } 927 neigh = neigh_lookup(&nd_tbl, &msg->target, dev); 928 929 if (neigh) { 930 u8 old_flags = neigh->flags; 931 struct net *net = dev_net(dev); 932 933 if (neigh->nud_state & NUD_FAILED) 934 goto out; 935 936 /* 937 * Don't update the neighbor cache entry on a proxy NA from 938 * ourselves because either the proxied node is off link or it 939 * has already sent a NA to us. 940 */ 941 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) && 942 net->ipv6.devconf_all->forwarding && net->ipv6.devconf_all->proxy_ndp && 943 pneigh_lookup(&nd_tbl, net, &msg->target, dev, 0)) { 944 /* XXX: idev->cnf.prixy_ndp */ 945 goto out; 946 } 947 948 neigh_update(neigh, lladdr, 949 msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE, 950 NEIGH_UPDATE_F_WEAK_OVERRIDE| 951 (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)| 952 NEIGH_UPDATE_F_OVERRIDE_ISROUTER| 953 (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0)); 954 955 if ((old_flags & ~neigh->flags) & NTF_ROUTER) { 956 /* 957 * Change: router to host 958 */ 959 struct rt6_info *rt; 960 rt = rt6_get_dflt_router(saddr, dev); 961 if (rt) 962 ip6_del_rt(rt); 963 } 964 965 out: 966 neigh_release(neigh); 967 } 968 } 969 970 static void ndisc_recv_rs(struct sk_buff *skb) 971 { 972 struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb); 973 unsigned long ndoptlen = skb->len - sizeof(*rs_msg); 974 struct neighbour *neigh; 975 struct inet6_dev *idev; 976 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr; 977 struct ndisc_options ndopts; 978 u8 *lladdr = NULL; 979 980 if (skb->len < sizeof(*rs_msg)) 981 return; 982 983 idev = in6_dev_get(skb->dev); 984 if (!idev) { 985 if (net_ratelimit()) 986 ND_PRINTK1("ICMP6 RS: can't find in6 device\n"); 987 return; 988 } 989 990 /* Don't accept RS if we're not in router mode */ 991 if (!idev->cnf.forwarding) 992 goto out; 993 994 /* 995 * Don't update NCE if src = ::; 996 * this implies that the source node has no ip address assigned yet. 997 */ 998 if (ipv6_addr_any(saddr)) 999 goto out; 1000 1001 /* Parse ND options */ 1002 if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) { 1003 if (net_ratelimit()) 1004 ND_PRINTK2("ICMP6 NS: invalid ND option, ignored\n"); 1005 goto out; 1006 } 1007 1008 if (ndopts.nd_opts_src_lladdr) { 1009 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, 1010 skb->dev); 1011 if (!lladdr) 1012 goto out; 1013 } 1014 1015 neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1); 1016 if (neigh) { 1017 neigh_update(neigh, lladdr, NUD_STALE, 1018 NEIGH_UPDATE_F_WEAK_OVERRIDE| 1019 NEIGH_UPDATE_F_OVERRIDE| 1020 NEIGH_UPDATE_F_OVERRIDE_ISROUTER); 1021 neigh_release(neigh); 1022 } 1023 out: 1024 in6_dev_put(idev); 1025 } 1026 1027 static void ndisc_ra_useropt(struct sk_buff *ra, struct nd_opt_hdr *opt) 1028 { 1029 struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb_transport_header(ra); 1030 struct sk_buff *skb; 1031 struct nlmsghdr *nlh; 1032 struct nduseroptmsg *ndmsg; 1033 struct net *net = dev_net(ra->dev); 1034 int err; 1035 int base_size = NLMSG_ALIGN(sizeof(struct nduseroptmsg) 1036 + (opt->nd_opt_len << 3)); 1037 size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr)); 1038 1039 skb = nlmsg_new(msg_size, GFP_ATOMIC); 1040 if (skb == NULL) { 1041 err = -ENOBUFS; 1042 goto errout; 1043 } 1044 1045 nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0); 1046 if (nlh == NULL) { 1047 goto nla_put_failure; 1048 } 1049 1050 ndmsg = nlmsg_data(nlh); 1051 ndmsg->nduseropt_family = AF_INET6; 1052 ndmsg->nduseropt_ifindex = ra->dev->ifindex; 1053 ndmsg->nduseropt_icmp_type = icmp6h->icmp6_type; 1054 ndmsg->nduseropt_icmp_code = icmp6h->icmp6_code; 1055 ndmsg->nduseropt_opts_len = opt->nd_opt_len << 3; 1056 1057 memcpy(ndmsg + 1, opt, opt->nd_opt_len << 3); 1058 1059 NLA_PUT(skb, NDUSEROPT_SRCADDR, sizeof(struct in6_addr), 1060 &ipv6_hdr(ra)->saddr); 1061 nlmsg_end(skb, nlh); 1062 1063 err = rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL, 1064 GFP_ATOMIC); 1065 if (err < 0) 1066 goto errout; 1067 1068 return; 1069 1070 nla_put_failure: 1071 nlmsg_free(skb); 1072 err = -EMSGSIZE; 1073 errout: 1074 rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err); 1075 } 1076 1077 static void ndisc_router_discovery(struct sk_buff *skb) 1078 { 1079 struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb); 1080 struct neighbour *neigh = NULL; 1081 struct inet6_dev *in6_dev; 1082 struct rt6_info *rt = NULL; 1083 int lifetime; 1084 struct ndisc_options ndopts; 1085 int optlen; 1086 unsigned int pref = 0; 1087 1088 __u8 * opt = (__u8 *)(ra_msg + 1); 1089 1090 optlen = (skb->tail - skb->transport_header) - sizeof(struct ra_msg); 1091 1092 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) { 1093 ND_PRINTK2(KERN_WARNING 1094 "ICMPv6 RA: source address is not link-local.\n"); 1095 return; 1096 } 1097 if (optlen < 0) { 1098 ND_PRINTK2(KERN_WARNING 1099 "ICMPv6 RA: packet too short\n"); 1100 return; 1101 } 1102 1103 #ifdef CONFIG_IPV6_NDISC_NODETYPE 1104 if (skb->ndisc_nodetype == NDISC_NODETYPE_HOST) { 1105 ND_PRINTK2(KERN_WARNING 1106 "ICMPv6 RA: from host or unauthorized router\n"); 1107 return; 1108 } 1109 #endif 1110 1111 /* 1112 * set the RA_RECV flag in the interface 1113 */ 1114 1115 in6_dev = in6_dev_get(skb->dev); 1116 if (in6_dev == NULL) { 1117 ND_PRINTK0(KERN_ERR 1118 "ICMPv6 RA: can't find inet6 device for %s.\n", 1119 skb->dev->name); 1120 return; 1121 } 1122 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_ra) { 1123 in6_dev_put(in6_dev); 1124 return; 1125 } 1126 1127 if (!ndisc_parse_options(opt, optlen, &ndopts)) { 1128 in6_dev_put(in6_dev); 1129 ND_PRINTK2(KERN_WARNING 1130 "ICMP6 RA: invalid ND options\n"); 1131 return; 1132 } 1133 1134 #ifdef CONFIG_IPV6_NDISC_NODETYPE 1135 /* skip link-specific parameters from interior routers */ 1136 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT) 1137 goto skip_linkparms; 1138 #endif 1139 1140 if (in6_dev->if_flags & IF_RS_SENT) { 1141 /* 1142 * flag that an RA was received after an RS was sent 1143 * out on this interface. 1144 */ 1145 in6_dev->if_flags |= IF_RA_RCVD; 1146 } 1147 1148 /* 1149 * Remember the managed/otherconf flags from most recently 1150 * received RA message (RFC 2462) -- yoshfuji 1151 */ 1152 in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED | 1153 IF_RA_OTHERCONF)) | 1154 (ra_msg->icmph.icmp6_addrconf_managed ? 1155 IF_RA_MANAGED : 0) | 1156 (ra_msg->icmph.icmp6_addrconf_other ? 1157 IF_RA_OTHERCONF : 0); 1158 1159 if (!in6_dev->cnf.accept_ra_defrtr) 1160 goto skip_defrtr; 1161 1162 lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime); 1163 1164 #ifdef CONFIG_IPV6_ROUTER_PREF 1165 pref = ra_msg->icmph.icmp6_router_pref; 1166 /* 10b is handled as if it were 00b (medium) */ 1167 if (pref == ICMPV6_ROUTER_PREF_INVALID || 1168 !in6_dev->cnf.accept_ra_rtr_pref) 1169 pref = ICMPV6_ROUTER_PREF_MEDIUM; 1170 #endif 1171 1172 rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev); 1173 1174 if (rt) 1175 neigh = rt->rt6i_nexthop; 1176 1177 if (rt && lifetime == 0) { 1178 neigh_clone(neigh); 1179 ip6_del_rt(rt); 1180 rt = NULL; 1181 } 1182 1183 if (rt == NULL && lifetime) { 1184 ND_PRINTK3(KERN_DEBUG 1185 "ICMPv6 RA: adding default router.\n"); 1186 1187 rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref); 1188 if (rt == NULL) { 1189 ND_PRINTK0(KERN_ERR 1190 "ICMPv6 RA: %s() failed to add default route.\n", 1191 __func__); 1192 in6_dev_put(in6_dev); 1193 return; 1194 } 1195 1196 neigh = rt->rt6i_nexthop; 1197 if (neigh == NULL) { 1198 ND_PRINTK0(KERN_ERR 1199 "ICMPv6 RA: %s() got default router without neighbour.\n", 1200 __func__); 1201 dst_release(&rt->u.dst); 1202 in6_dev_put(in6_dev); 1203 return; 1204 } 1205 neigh->flags |= NTF_ROUTER; 1206 } else if (rt) { 1207 rt->rt6i_flags = (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref); 1208 } 1209 1210 if (rt) 1211 rt->rt6i_expires = jiffies + (HZ * lifetime); 1212 1213 if (ra_msg->icmph.icmp6_hop_limit) { 1214 in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit; 1215 if (rt) 1216 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = ra_msg->icmph.icmp6_hop_limit; 1217 } 1218 1219 skip_defrtr: 1220 1221 /* 1222 * Update Reachable Time and Retrans Timer 1223 */ 1224 1225 if (in6_dev->nd_parms) { 1226 unsigned long rtime = ntohl(ra_msg->retrans_timer); 1227 1228 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) { 1229 rtime = (rtime*HZ)/1000; 1230 if (rtime < HZ/10) 1231 rtime = HZ/10; 1232 in6_dev->nd_parms->retrans_time = rtime; 1233 in6_dev->tstamp = jiffies; 1234 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev); 1235 } 1236 1237 rtime = ntohl(ra_msg->reachable_time); 1238 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) { 1239 rtime = (rtime*HZ)/1000; 1240 1241 if (rtime < HZ/10) 1242 rtime = HZ/10; 1243 1244 if (rtime != in6_dev->nd_parms->base_reachable_time) { 1245 in6_dev->nd_parms->base_reachable_time = rtime; 1246 in6_dev->nd_parms->gc_staletime = 3 * rtime; 1247 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime); 1248 in6_dev->tstamp = jiffies; 1249 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev); 1250 } 1251 } 1252 } 1253 1254 #ifdef CONFIG_IPV6_NDISC_NODETYPE 1255 skip_linkparms: 1256 #endif 1257 1258 /* 1259 * Process options. 1260 */ 1261 1262 if (!neigh) 1263 neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr, 1264 skb->dev, 1); 1265 if (neigh) { 1266 u8 *lladdr = NULL; 1267 if (ndopts.nd_opts_src_lladdr) { 1268 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, 1269 skb->dev); 1270 if (!lladdr) { 1271 ND_PRINTK2(KERN_WARNING 1272 "ICMPv6 RA: invalid link-layer address length\n"); 1273 goto out; 1274 } 1275 } 1276 neigh_update(neigh, lladdr, NUD_STALE, 1277 NEIGH_UPDATE_F_WEAK_OVERRIDE| 1278 NEIGH_UPDATE_F_OVERRIDE| 1279 NEIGH_UPDATE_F_OVERRIDE_ISROUTER| 1280 NEIGH_UPDATE_F_ISROUTER); 1281 } 1282 1283 #ifdef CONFIG_IPV6_ROUTE_INFO 1284 if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) { 1285 struct nd_opt_hdr *p; 1286 for (p = ndopts.nd_opts_ri; 1287 p; 1288 p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) { 1289 struct route_info *ri = (struct route_info *)p; 1290 #ifdef CONFIG_IPV6_NDISC_NODETYPE 1291 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT && 1292 ri->prefix_len == 0) 1293 continue; 1294 #endif 1295 if (ri->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen) 1296 continue; 1297 rt6_route_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3, 1298 &ipv6_hdr(skb)->saddr); 1299 } 1300 } 1301 #endif 1302 1303 #ifdef CONFIG_IPV6_NDISC_NODETYPE 1304 /* skip link-specific ndopts from interior routers */ 1305 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT) 1306 goto out; 1307 #endif 1308 1309 if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) { 1310 struct nd_opt_hdr *p; 1311 for (p = ndopts.nd_opts_pi; 1312 p; 1313 p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) { 1314 addrconf_prefix_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3); 1315 } 1316 } 1317 1318 if (ndopts.nd_opts_mtu) { 1319 __be32 n; 1320 u32 mtu; 1321 1322 memcpy(&n, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu)); 1323 mtu = ntohl(n); 1324 1325 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) { 1326 ND_PRINTK2(KERN_WARNING 1327 "ICMPv6 RA: invalid mtu: %d\n", 1328 mtu); 1329 } else if (in6_dev->cnf.mtu6 != mtu) { 1330 in6_dev->cnf.mtu6 = mtu; 1331 1332 if (rt) 1333 rt->u.dst.metrics[RTAX_MTU-1] = mtu; 1334 1335 rt6_mtu_change(skb->dev, mtu); 1336 } 1337 } 1338 1339 if (ndopts.nd_useropts) { 1340 struct nd_opt_hdr *p; 1341 for (p = ndopts.nd_useropts; 1342 p; 1343 p = ndisc_next_useropt(p, ndopts.nd_useropts_end)) { 1344 ndisc_ra_useropt(skb, p); 1345 } 1346 } 1347 1348 if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) { 1349 ND_PRINTK2(KERN_WARNING 1350 "ICMPv6 RA: invalid RA options"); 1351 } 1352 out: 1353 if (rt) 1354 dst_release(&rt->u.dst); 1355 else if (neigh) 1356 neigh_release(neigh); 1357 in6_dev_put(in6_dev); 1358 } 1359 1360 static void ndisc_redirect_rcv(struct sk_buff *skb) 1361 { 1362 struct inet6_dev *in6_dev; 1363 struct icmp6hdr *icmph; 1364 struct in6_addr *dest; 1365 struct in6_addr *target; /* new first hop to destination */ 1366 struct neighbour *neigh; 1367 int on_link = 0; 1368 struct ndisc_options ndopts; 1369 int optlen; 1370 u8 *lladdr = NULL; 1371 1372 #ifdef CONFIG_IPV6_NDISC_NODETYPE 1373 switch (skb->ndisc_nodetype) { 1374 case NDISC_NODETYPE_HOST: 1375 case NDISC_NODETYPE_NODEFAULT: 1376 ND_PRINTK2(KERN_WARNING 1377 "ICMPv6 Redirect: from host or unauthorized router\n"); 1378 return; 1379 } 1380 #endif 1381 1382 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) { 1383 ND_PRINTK2(KERN_WARNING 1384 "ICMPv6 Redirect: source address is not link-local.\n"); 1385 return; 1386 } 1387 1388 optlen = skb->tail - skb->transport_header; 1389 optlen -= sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr); 1390 1391 if (optlen < 0) { 1392 ND_PRINTK2(KERN_WARNING 1393 "ICMPv6 Redirect: packet too short\n"); 1394 return; 1395 } 1396 1397 icmph = icmp6_hdr(skb); 1398 target = (struct in6_addr *) (icmph + 1); 1399 dest = target + 1; 1400 1401 if (ipv6_addr_is_multicast(dest)) { 1402 ND_PRINTK2(KERN_WARNING 1403 "ICMPv6 Redirect: destination address is multicast.\n"); 1404 return; 1405 } 1406 1407 if (ipv6_addr_equal(dest, target)) { 1408 on_link = 1; 1409 } else if (ipv6_addr_type(target) != 1410 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) { 1411 ND_PRINTK2(KERN_WARNING 1412 "ICMPv6 Redirect: target address is not link-local unicast.\n"); 1413 return; 1414 } 1415 1416 in6_dev = in6_dev_get(skb->dev); 1417 if (!in6_dev) 1418 return; 1419 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects) { 1420 in6_dev_put(in6_dev); 1421 return; 1422 } 1423 1424 /* RFC2461 8.1: 1425 * The IP source address of the Redirect MUST be the same as the current 1426 * first-hop router for the specified ICMP Destination Address. 1427 */ 1428 1429 if (!ndisc_parse_options((u8*)(dest + 1), optlen, &ndopts)) { 1430 ND_PRINTK2(KERN_WARNING 1431 "ICMPv6 Redirect: invalid ND options\n"); 1432 in6_dev_put(in6_dev); 1433 return; 1434 } 1435 if (ndopts.nd_opts_tgt_lladdr) { 1436 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, 1437 skb->dev); 1438 if (!lladdr) { 1439 ND_PRINTK2(KERN_WARNING 1440 "ICMPv6 Redirect: invalid link-layer address length\n"); 1441 in6_dev_put(in6_dev); 1442 return; 1443 } 1444 } 1445 1446 neigh = __neigh_lookup(&nd_tbl, target, skb->dev, 1); 1447 if (neigh) { 1448 rt6_redirect(dest, &ipv6_hdr(skb)->daddr, 1449 &ipv6_hdr(skb)->saddr, neigh, lladdr, 1450 on_link); 1451 neigh_release(neigh); 1452 } 1453 in6_dev_put(in6_dev); 1454 } 1455 1456 void ndisc_send_redirect(struct sk_buff *skb, struct neighbour *neigh, 1457 const struct in6_addr *target) 1458 { 1459 struct net_device *dev = skb->dev; 1460 struct net *net = dev_net(dev); 1461 struct sock *sk = net->ipv6.ndisc_sk; 1462 int len = sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr); 1463 struct sk_buff *buff; 1464 struct icmp6hdr *icmph; 1465 struct in6_addr saddr_buf; 1466 struct in6_addr *addrp; 1467 struct rt6_info *rt; 1468 struct dst_entry *dst; 1469 struct inet6_dev *idev; 1470 struct flowi fl; 1471 u8 *opt; 1472 int rd_len; 1473 int err; 1474 u8 ha_buf[MAX_ADDR_LEN], *ha = NULL; 1475 1476 if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) { 1477 ND_PRINTK2(KERN_WARNING 1478 "ICMPv6 Redirect: no link-local address on %s\n", 1479 dev->name); 1480 return; 1481 } 1482 1483 if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) && 1484 ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) { 1485 ND_PRINTK2(KERN_WARNING 1486 "ICMPv6 Redirect: target address is not link-local unicast.\n"); 1487 return; 1488 } 1489 1490 icmpv6_flow_init(sk, &fl, NDISC_REDIRECT, 1491 &saddr_buf, &ipv6_hdr(skb)->saddr, dev->ifindex); 1492 1493 dst = ip6_route_output(net, NULL, &fl); 1494 if (dst == NULL) 1495 return; 1496 1497 err = xfrm_lookup(&dst, &fl, NULL, 0); 1498 if (err) 1499 return; 1500 1501 rt = (struct rt6_info *) dst; 1502 1503 if (rt->rt6i_flags & RTF_GATEWAY) { 1504 ND_PRINTK2(KERN_WARNING 1505 "ICMPv6 Redirect: destination is not a neighbour.\n"); 1506 dst_release(dst); 1507 return; 1508 } 1509 if (!xrlim_allow(dst, 1*HZ)) { 1510 dst_release(dst); 1511 return; 1512 } 1513 1514 if (dev->addr_len) { 1515 read_lock_bh(&neigh->lock); 1516 if (neigh->nud_state & NUD_VALID) { 1517 memcpy(ha_buf, neigh->ha, dev->addr_len); 1518 read_unlock_bh(&neigh->lock); 1519 ha = ha_buf; 1520 len += ndisc_opt_addr_space(dev); 1521 } else 1522 read_unlock_bh(&neigh->lock); 1523 } 1524 1525 rd_len = min_t(unsigned int, 1526 IPV6_MIN_MTU-sizeof(struct ipv6hdr)-len, skb->len + 8); 1527 rd_len &= ~0x7; 1528 len += rd_len; 1529 1530 buff = sock_alloc_send_skb(sk, 1531 (MAX_HEADER + sizeof(struct ipv6hdr) + 1532 len + LL_ALLOCATED_SPACE(dev)), 1533 1, &err); 1534 if (buff == NULL) { 1535 ND_PRINTK0(KERN_ERR 1536 "ICMPv6 Redirect: %s() failed to allocate an skb.\n", 1537 __func__); 1538 dst_release(dst); 1539 return; 1540 } 1541 1542 skb_reserve(buff, LL_RESERVED_SPACE(dev)); 1543 ip6_nd_hdr(sk, buff, dev, &saddr_buf, &ipv6_hdr(skb)->saddr, 1544 IPPROTO_ICMPV6, len); 1545 1546 skb_set_transport_header(buff, skb_tail_pointer(buff) - buff->data); 1547 skb_put(buff, len); 1548 icmph = icmp6_hdr(buff); 1549 1550 memset(icmph, 0, sizeof(struct icmp6hdr)); 1551 icmph->icmp6_type = NDISC_REDIRECT; 1552 1553 /* 1554 * copy target and destination addresses 1555 */ 1556 1557 addrp = (struct in6_addr *)(icmph + 1); 1558 ipv6_addr_copy(addrp, target); 1559 addrp++; 1560 ipv6_addr_copy(addrp, &ipv6_hdr(skb)->daddr); 1561 1562 opt = (u8*) (addrp + 1); 1563 1564 /* 1565 * include target_address option 1566 */ 1567 1568 if (ha) 1569 opt = ndisc_fill_addr_option(opt, ND_OPT_TARGET_LL_ADDR, ha, 1570 dev->addr_len, dev->type); 1571 1572 /* 1573 * build redirect option and copy skb over to the new packet. 1574 */ 1575 1576 memset(opt, 0, 8); 1577 *(opt++) = ND_OPT_REDIRECT_HDR; 1578 *(opt++) = (rd_len >> 3); 1579 opt += 6; 1580 1581 memcpy(opt, ipv6_hdr(skb), rd_len - 8); 1582 1583 icmph->icmp6_cksum = csum_ipv6_magic(&saddr_buf, &ipv6_hdr(skb)->saddr, 1584 len, IPPROTO_ICMPV6, 1585 csum_partial((u8 *) icmph, len, 0)); 1586 1587 buff->dst = dst; 1588 idev = in6_dev_get(dst->dev); 1589 IP6_INC_STATS(net, idev, IPSTATS_MIB_OUTREQUESTS); 1590 err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, buff, NULL, dst->dev, 1591 dst_output); 1592 if (!err) { 1593 ICMP6MSGOUT_INC_STATS(net, idev, NDISC_REDIRECT); 1594 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS); 1595 } 1596 1597 if (likely(idev != NULL)) 1598 in6_dev_put(idev); 1599 } 1600 1601 static void pndisc_redo(struct sk_buff *skb) 1602 { 1603 ndisc_recv_ns(skb); 1604 kfree_skb(skb); 1605 } 1606 1607 int ndisc_rcv(struct sk_buff *skb) 1608 { 1609 struct nd_msg *msg; 1610 1611 if (!pskb_may_pull(skb, skb->len)) 1612 return 0; 1613 1614 msg = (struct nd_msg *)skb_transport_header(skb); 1615 1616 __skb_push(skb, skb->data - skb_transport_header(skb)); 1617 1618 if (ipv6_hdr(skb)->hop_limit != 255) { 1619 ND_PRINTK2(KERN_WARNING 1620 "ICMPv6 NDISC: invalid hop-limit: %d\n", 1621 ipv6_hdr(skb)->hop_limit); 1622 return 0; 1623 } 1624 1625 if (msg->icmph.icmp6_code != 0) { 1626 ND_PRINTK2(KERN_WARNING 1627 "ICMPv6 NDISC: invalid ICMPv6 code: %d\n", 1628 msg->icmph.icmp6_code); 1629 return 0; 1630 } 1631 1632 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb)); 1633 1634 switch (msg->icmph.icmp6_type) { 1635 case NDISC_NEIGHBOUR_SOLICITATION: 1636 ndisc_recv_ns(skb); 1637 break; 1638 1639 case NDISC_NEIGHBOUR_ADVERTISEMENT: 1640 ndisc_recv_na(skb); 1641 break; 1642 1643 case NDISC_ROUTER_SOLICITATION: 1644 ndisc_recv_rs(skb); 1645 break; 1646 1647 case NDISC_ROUTER_ADVERTISEMENT: 1648 ndisc_router_discovery(skb); 1649 break; 1650 1651 case NDISC_REDIRECT: 1652 ndisc_redirect_rcv(skb); 1653 break; 1654 } 1655 1656 return 0; 1657 } 1658 1659 static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr) 1660 { 1661 struct net_device *dev = ptr; 1662 struct net *net = dev_net(dev); 1663 1664 switch (event) { 1665 case NETDEV_CHANGEADDR: 1666 neigh_changeaddr(&nd_tbl, dev); 1667 fib6_run_gc(~0UL, net); 1668 break; 1669 case NETDEV_DOWN: 1670 neigh_ifdown(&nd_tbl, dev); 1671 fib6_run_gc(~0UL, net); 1672 break; 1673 default: 1674 break; 1675 } 1676 1677 return NOTIFY_DONE; 1678 } 1679 1680 static struct notifier_block ndisc_netdev_notifier = { 1681 .notifier_call = ndisc_netdev_event, 1682 }; 1683 1684 #ifdef CONFIG_SYSCTL 1685 static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl, 1686 const char *func, const char *dev_name) 1687 { 1688 static char warncomm[TASK_COMM_LEN]; 1689 static int warned; 1690 if (strcmp(warncomm, current->comm) && warned < 5) { 1691 strcpy(warncomm, current->comm); 1692 printk(KERN_WARNING 1693 "process `%s' is using deprecated sysctl (%s) " 1694 "net.ipv6.neigh.%s.%s; " 1695 "Use net.ipv6.neigh.%s.%s_ms " 1696 "instead.\n", 1697 warncomm, func, 1698 dev_name, ctl->procname, 1699 dev_name, ctl->procname); 1700 warned++; 1701 } 1702 } 1703 1704 int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, struct file * filp, void __user *buffer, size_t *lenp, loff_t *ppos) 1705 { 1706 struct net_device *dev = ctl->extra1; 1707 struct inet6_dev *idev; 1708 int ret; 1709 1710 if ((strcmp(ctl->procname, "retrans_time") == 0) || 1711 (strcmp(ctl->procname, "base_reachable_time") == 0)) 1712 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default"); 1713 1714 if (strcmp(ctl->procname, "retrans_time") == 0) 1715 ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos); 1716 1717 else if (strcmp(ctl->procname, "base_reachable_time") == 0) 1718 ret = proc_dointvec_jiffies(ctl, write, 1719 filp, buffer, lenp, ppos); 1720 1721 else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) || 1722 (strcmp(ctl->procname, "base_reachable_time_ms") == 0)) 1723 ret = proc_dointvec_ms_jiffies(ctl, write, 1724 filp, buffer, lenp, ppos); 1725 else 1726 ret = -1; 1727 1728 if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) { 1729 if (ctl->data == &idev->nd_parms->base_reachable_time) 1730 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time); 1731 idev->tstamp = jiffies; 1732 inet6_ifinfo_notify(RTM_NEWLINK, idev); 1733 in6_dev_put(idev); 1734 } 1735 return ret; 1736 } 1737 1738 int ndisc_ifinfo_sysctl_strategy(ctl_table *ctl, 1739 void __user *oldval, size_t __user *oldlenp, 1740 void __user *newval, size_t newlen) 1741 { 1742 struct net_device *dev = ctl->extra1; 1743 struct inet6_dev *idev; 1744 int ret; 1745 1746 if (ctl->ctl_name == NET_NEIGH_RETRANS_TIME || 1747 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME) 1748 ndisc_warn_deprecated_sysctl(ctl, "procfs", dev ? dev->name : "default"); 1749 1750 switch (ctl->ctl_name) { 1751 case NET_NEIGH_REACHABLE_TIME: 1752 ret = sysctl_jiffies(ctl, oldval, oldlenp, newval, newlen); 1753 break; 1754 case NET_NEIGH_RETRANS_TIME_MS: 1755 case NET_NEIGH_REACHABLE_TIME_MS: 1756 ret = sysctl_ms_jiffies(ctl, oldval, oldlenp, newval, newlen); 1757 break; 1758 default: 1759 ret = 0; 1760 } 1761 1762 if (newval && newlen && ret > 0 && 1763 dev && (idev = in6_dev_get(dev)) != NULL) { 1764 if (ctl->ctl_name == NET_NEIGH_REACHABLE_TIME || 1765 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME_MS) 1766 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time); 1767 idev->tstamp = jiffies; 1768 inet6_ifinfo_notify(RTM_NEWLINK, idev); 1769 in6_dev_put(idev); 1770 } 1771 1772 return ret; 1773 } 1774 1775 #endif 1776 1777 static int ndisc_net_init(struct net *net) 1778 { 1779 struct ipv6_pinfo *np; 1780 struct sock *sk; 1781 int err; 1782 1783 err = inet_ctl_sock_create(&sk, PF_INET6, 1784 SOCK_RAW, IPPROTO_ICMPV6, net); 1785 if (err < 0) { 1786 ND_PRINTK0(KERN_ERR 1787 "ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n", 1788 err); 1789 return err; 1790 } 1791 1792 net->ipv6.ndisc_sk = sk; 1793 1794 np = inet6_sk(sk); 1795 np->hop_limit = 255; 1796 /* Do not loopback ndisc messages */ 1797 np->mc_loop = 0; 1798 1799 return 0; 1800 } 1801 1802 static void ndisc_net_exit(struct net *net) 1803 { 1804 inet_ctl_sock_destroy(net->ipv6.ndisc_sk); 1805 } 1806 1807 static struct pernet_operations ndisc_net_ops = { 1808 .init = ndisc_net_init, 1809 .exit = ndisc_net_exit, 1810 }; 1811 1812 int __init ndisc_init(void) 1813 { 1814 int err; 1815 1816 err = register_pernet_subsys(&ndisc_net_ops); 1817 if (err) 1818 return err; 1819 /* 1820 * Initialize the neighbour table 1821 */ 1822 neigh_table_init(&nd_tbl); 1823 1824 #ifdef CONFIG_SYSCTL 1825 err = neigh_sysctl_register(NULL, &nd_tbl.parms, NET_IPV6, 1826 NET_IPV6_NEIGH, "ipv6", 1827 &ndisc_ifinfo_sysctl_change, 1828 &ndisc_ifinfo_sysctl_strategy); 1829 if (err) 1830 goto out_unregister_pernet; 1831 #endif 1832 err = register_netdevice_notifier(&ndisc_netdev_notifier); 1833 if (err) 1834 goto out_unregister_sysctl; 1835 out: 1836 return err; 1837 1838 out_unregister_sysctl: 1839 #ifdef CONFIG_SYSCTL 1840 neigh_sysctl_unregister(&nd_tbl.parms); 1841 out_unregister_pernet: 1842 #endif 1843 unregister_pernet_subsys(&ndisc_net_ops); 1844 goto out; 1845 } 1846 1847 void ndisc_cleanup(void) 1848 { 1849 unregister_netdevice_notifier(&ndisc_netdev_notifier); 1850 #ifdef CONFIG_SYSCTL 1851 neigh_sysctl_unregister(&nd_tbl.parms); 1852 #endif 1853 neigh_table_clear(&nd_tbl); 1854 unregister_pernet_subsys(&ndisc_net_ops); 1855 } 1856