include/net/addrconf.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef _ADDRCONF_H
   3 #define _ADDRCONF_H
   4
   5 #define MAX_RTR_SOLICITATIONS           -1              /* unlimited */
   6 #define RTR_SOLICITATION_INTERVAL       (4*HZ)
   7 #define RTR_SOLICITATION_MAX_INTERVAL   (3600*HZ)       /* 1 hour */
   8
   9 #define MIN_VALID_LIFETIME              (2*3600)        /* 2 hours */
  10
  11 #define TEMP_VALID_LIFETIME             (7*86400)
  12 #define TEMP_PREFERRED_LIFETIME         (86400)
  13 #define REGEN_MAX_RETRY                 (3)
  14 #define MAX_DESYNC_FACTOR               (600)
  15
  16 #define ADDR_CHECK_FREQUENCY            (120*HZ)
  17
  18 #define IPV6_MAX_ADDRESSES              16
  19
  20 #define ADDRCONF_TIMER_FUZZ_MINUS       (HZ > 50 ? HZ / 50 : 1)
  21 #define ADDRCONF_TIMER_FUZZ             (HZ / 4)
  22 #define ADDRCONF_TIMER_FUZZ_MAX         (HZ)
  23
  24 #define ADDRCONF_NOTIFY_PRIORITY        0
  25
  26 #include <linux/in.h>
  27 #include <linux/in6.h>
  28
  29 struct prefix_info {
  30         __u8                    type;
  31         __u8                    length;
  32         __u8                    prefix_len;
  33
  34         union __packed {
  35                 __u8            flags;
  36                 struct __packed {
  37 #if defined(__BIG_ENDIAN_BITFIELD)
  38                         __u8    onlink : 1,
  39                                 autoconf : 1,
  40                                 reserved : 6;
  41 #elif defined(__LITTLE_ENDIAN_BITFIELD)
  42                         __u8    reserved : 6,
  43                                 autoconf : 1,
  44                                 onlink : 1;
  45 #else
  46 #error "Please fix <asm/byteorder.h>"
  47 #endif
  48                 };
  49         };
  50         __be32                  valid;
  51         __be32                  prefered;
  52         __be32                  reserved2;
  53
  54         struct in6_addr         prefix;
  55 };
  56
  57 /* rfc4861 4.6.2: IPv6 PIO is 32 bytes in size */
  58 static_assert(sizeof(struct prefix_info) == 32);
  59
  60 #include <linux/ipv6.h>
  61 #include <linux/netdevice.h>
  62 #include <net/if_inet6.h>
  63 #include <net/ipv6.h>
  64
  65 struct in6_validator_info {
  66         struct in6_addr         i6vi_addr;
  67         struct inet6_dev        *i6vi_dev;
  68         struct netlink_ext_ack  *extack;
  69 };
  70
  71 struct ifa6_config {
  72         const struct in6_addr   *pfx;
  73         unsigned int            plen;
  74
  75         u8                      ifa_proto;
  76
  77         const struct in6_addr   *peer_pfx;
  78
  79         u32                     rt_priority;
  80         u32                     ifa_flags;
  81         u32                     preferred_lft;
  82         u32                     valid_lft;
  83         u16                     scope;
  84 };
  85
  86 int addrconf_init(void);
  87 void addrconf_cleanup(void);
  88
  89 int addrconf_add_ifaddr(struct net *net, void __user *arg);
  90 int addrconf_del_ifaddr(struct net *net, void __user *arg);
  91 int addrconf_set_dstaddr(struct net *net, void __user *arg);
  92
  93 int ipv6_chk_addr(struct net *net, const struct in6_addr *addr,
  94                   const struct net_device *dev, int strict);
  95 int ipv6_chk_addr_and_flags(struct net *net, const struct in6_addr *addr,
  96                             const struct net_device *dev, bool skip_dev_check,
  97                             int strict, u32 banned_flags);
  98
  99 #if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
 100 int ipv6_chk_home_addr(struct net *net, const struct in6_addr *addr);
 101 #endif
 102
 103 int ipv6_chk_rpl_srh_loop(struct net *net, const struct in6_addr *segs,
 104                           unsigned char nsegs);
 105
 106 bool ipv6_chk_custom_prefix(const struct in6_addr *addr,
 107                                    const unsigned int prefix_len,
 108                                    struct net_device *dev);
 109
 110 int ipv6_chk_prefix(const struct in6_addr *addr, struct net_device *dev);
 111
 112 struct net_device *ipv6_dev_find(struct net *net, const struct in6_addr *addr,
 113                                  struct net_device *dev);
 114
 115 struct inet6_ifaddr *ipv6_get_ifaddr(struct net *net,
 116                                      const struct in6_addr *addr,
 117                                      struct net_device *dev, int strict);
 118
 119 int ipv6_dev_get_saddr(struct net *net, const struct net_device *dev,
 120                        const struct in6_addr *daddr, unsigned int srcprefs,
 121                        struct in6_addr *saddr);
 122 int ipv6_get_lladdr(struct net_device *dev, struct in6_addr *addr,
 123                     u32 banned_flags);
 124 bool inet_rcv_saddr_equal(const struct sock *sk, const struct sock *sk2,
 125                           bool match_wildcard);
 126 bool inet_rcv_saddr_any(const struct sock *sk);
 127 void addrconf_join_solict(struct net_device *dev, const struct in6_addr *addr);
 128 void addrconf_leave_solict(struct inet6_dev *idev, const struct in6_addr *addr);
 129
 130 void addrconf_add_linklocal(struct inet6_dev *idev,
 131                             const struct in6_addr *addr, u32 flags);
 132
 133 int addrconf_prefix_rcv_add_addr(struct net *net, struct net_device *dev,
 134                                  const struct prefix_info *pinfo,
 135                                  struct inet6_dev *in6_dev,
 136                                  const struct in6_addr *addr, int addr_type,
 137                                  u32 addr_flags, bool sllao, bool tokenized,
 138                                  __u32 valid_lft, u32 prefered_lft);
 139
 140 static inline void addrconf_addr_eui48_base(u8 *eui, const char *const addr)
 141 {
 142         memcpy(eui, addr, 3);
 143         eui[3] = 0xFF;
 144         eui[4] = 0xFE;
 145         memcpy(eui + 5, addr + 3, 3);
 146 }
 147
 148 static inline void addrconf_addr_eui48(u8 *eui, const char *const addr)
 149 {
 150         addrconf_addr_eui48_base(eui, addr);
 151         eui[0] ^= 2;
 152 }
 153
 154 static inline int addrconf_ifid_eui48(u8 *eui, struct net_device *dev)
 155 {
 156         if (dev->addr_len != ETH_ALEN)
 157                 return -1;
 158
 159         /*
 160          * The zSeries OSA network cards can be shared among various
 161          * OS instances, but the OSA cards have only one MAC address.
 162          * This leads to duplicate address conflicts in conjunction
 163          * with IPv6 if more than one instance uses the same card.
 164          *
 165          * The driver for these cards can deliver a unique 16-bit
 166          * identifier for each instance sharing the same card.  It is
 167          * placed instead of 0xFFFE in the interface identifier.  The
 168          * "u" bit of the interface identifier is not inverted in this
 169          * case.  Hence the resulting interface identifier has local
 170          * scope according to RFC2373.
 171          */
 172
 173         addrconf_addr_eui48_base(eui, dev->dev_addr);
 174
 175         if (dev->dev_id) {
 176                 eui[3] = (dev->dev_id >> 8) & 0xFF;
 177                 eui[4] = dev->dev_id & 0xFF;
 178         } else {
 179                 eui[0] ^= 2;
 180         }
 181
 182         return 0;
 183 }
 184
 185 static inline unsigned long addrconf_timeout_fixup(u32 timeout,
 186                                                    unsigned int unit)
 187 {
 188         if (timeout == 0xffffffff)
 189                 return ~0UL;
 190
 191         /*
 192          * Avoid arithmetic overflow.
 193          * Assuming unit is constant and non-zero, this "if" statement
 194          * will go away on 64bit archs.
 195          */
 196         if (0xfffffffe > LONG_MAX / unit && timeout > LONG_MAX / unit)
 197                 return LONG_MAX / unit;
 198
 199         return timeout;
 200 }
 201
 202 static inline int addrconf_finite_timeout(unsigned long timeout)
 203 {
 204         return ~timeout;
 205 }
 206
 207 /*
 208  *      IPv6 Address Label subsystem (addrlabel.c)
 209  */
 210 int ipv6_addr_label_init(void);
 211 void ipv6_addr_label_cleanup(void);
 212 int ipv6_addr_label_rtnl_register(void);
 213 u32 ipv6_addr_label(struct net *net, const struct in6_addr *addr,
 214                     int type, int ifindex);
 215
 216 /*
 217  *      multicast prototypes (mcast.c)
 218  */
 219 static inline bool ipv6_mc_may_pull(struct sk_buff *skb,
 220                                     unsigned int len)
 221 {
 222         if (skb_transport_offset(skb) + ipv6_transport_len(skb) < len)
 223                 return false;
 224
 225         return pskb_may_pull(skb, len);
 226 }
 227
 228 int ipv6_sock_mc_join(struct sock *sk, int ifindex,
 229                       const struct in6_addr *addr);
 230 int ipv6_sock_mc_drop(struct sock *sk, int ifindex,
 231                       const struct in6_addr *addr);
 232 void __ipv6_sock_mc_close(struct sock *sk);
 233 void ipv6_sock_mc_close(struct sock *sk);
 234 bool inet6_mc_check(const struct sock *sk, const struct in6_addr *mc_addr,
 235                     const struct in6_addr *src_addr);
 236
 237 int ipv6_dev_mc_inc(struct net_device *dev, const struct in6_addr *addr);
 238 int __ipv6_dev_mc_dec(struct inet6_dev *idev, const struct in6_addr *addr);
 239 int ipv6_dev_mc_dec(struct net_device *dev, const struct in6_addr *addr);
 240 void ipv6_mc_up(struct inet6_dev *idev);
 241 void ipv6_mc_down(struct inet6_dev *idev);
 242 void ipv6_mc_unmap(struct inet6_dev *idev);
 243 void ipv6_mc_remap(struct inet6_dev *idev);
 244 void ipv6_mc_init_dev(struct inet6_dev *idev);
 245 void ipv6_mc_destroy_dev(struct inet6_dev *idev);
 246 int ipv6_mc_check_mld(struct sk_buff *skb);
 247 void addrconf_dad_failure(struct sk_buff *skb, struct inet6_ifaddr *ifp);
 248
 249 bool ipv6_chk_mcast_addr(struct net_device *dev, const struct in6_addr *group,
 250                          const struct in6_addr *src_addr);
 251
 252 void ipv6_mc_dad_complete(struct inet6_dev *idev);
 253
 254 /*
 255  * identify MLD packets for MLD filter exceptions
 256  */
 257 static inline bool ipv6_is_mld(struct sk_buff *skb, int nexthdr, int offset)
 258 {
 259         struct icmp6hdr *hdr;
 260
 261         if (nexthdr != IPPROTO_ICMPV6 ||
 262             !pskb_network_may_pull(skb, offset + sizeof(struct icmp6hdr)))
 263                 return false;
 264
 265         hdr = (struct icmp6hdr *)(skb_network_header(skb) + offset);
 266
 267         switch (hdr->icmp6_type) {
 268         case ICMPV6_MGM_QUERY:
 269         case ICMPV6_MGM_REPORT:
 270         case ICMPV6_MGM_REDUCTION:
 271         case ICMPV6_MLD2_REPORT:
 272                 return true;
 273         default:
 274                 break;
 275         }
 276         return false;
 277 }
 278
 279 void addrconf_prefix_rcv(struct net_device *dev,
 280                          u8 *opt, int len, bool sllao);
 281
 282 /*
 283  *      anycast prototypes (anycast.c)
 284  */
 285 int ipv6_sock_ac_join(struct sock *sk, int ifindex,
 286                       const struct in6_addr *addr);
 287 int ipv6_sock_ac_drop(struct sock *sk, int ifindex,
 288                       const struct in6_addr *addr);
 289 void __ipv6_sock_ac_close(struct sock *sk);
 290 void ipv6_sock_ac_close(struct sock *sk);
 291
 292 int __ipv6_dev_ac_inc(struct inet6_dev *idev, const struct in6_addr *addr);
 293 int __ipv6_dev_ac_dec(struct inet6_dev *idev, const struct in6_addr *addr);
 294 void ipv6_ac_destroy_dev(struct inet6_dev *idev);
 295 bool ipv6_chk_acast_addr(struct net *net, struct net_device *dev,
 296                          const struct in6_addr *addr);
 297 bool ipv6_chk_acast_addr_src(struct net *net, struct net_device *dev,
 298                              const struct in6_addr *addr);
 299 int ipv6_anycast_init(void);
 300 void ipv6_anycast_cleanup(void);
 301
 302 /* Device notifier */
 303 int register_inet6addr_notifier(struct notifier_block *nb);
 304 int unregister_inet6addr_notifier(struct notifier_block *nb);
 305 int inet6addr_notifier_call_chain(unsigned long val, void *v);
 306
 307 int register_inet6addr_validator_notifier(struct notifier_block *nb);
 308 int unregister_inet6addr_validator_notifier(struct notifier_block *nb);
 309 int inet6addr_validator_notifier_call_chain(unsigned long val, void *v);
 310
 311 void inet6_netconf_notify_devconf(struct net *net, int event, int type,
 312                                   int ifindex, struct ipv6_devconf *devconf);
 313
 314 /**
 315  * __in6_dev_get - get inet6_dev pointer from netdevice
 316  * @dev: network device
 317  *
 318  * Caller must hold rcu_read_lock or RTNL, because this function
 319  * does not take a reference on the inet6_dev.
 320  */
 321 static inline struct inet6_dev *__in6_dev_get(const struct net_device *dev)
 322 {
 323         return rcu_dereference_rtnl(dev->ip6_ptr);
 324 }
 325
 326 /**
 327  * __in6_dev_stats_get - get inet6_dev pointer for stats
 328  * @dev: network device
 329  * @skb: skb for original incoming interface if neeeded
 330  *
 331  * Caller must hold rcu_read_lock or RTNL, because this function
 332  * does not take a reference on the inet6_dev.
 333  */
 334 static inline struct inet6_dev *__in6_dev_stats_get(const struct net_device *dev,
 335                                                     const struct sk_buff *skb)
 336 {
 337         if (netif_is_l3_master(dev))
 338                 dev = dev_get_by_index_rcu(dev_net(dev), inet6_iif(skb));
 339         return __in6_dev_get(dev);
 340 }
 341
 342 /**
 343  * __in6_dev_get_safely - get inet6_dev pointer from netdevice
 344  * @dev: network device
 345  *
 346  * This is a safer version of __in6_dev_get
 347  */
 348 static inline struct inet6_dev *__in6_dev_get_safely(const struct net_device *dev)
 349 {
 350         if (likely(dev))
 351                 return rcu_dereference_rtnl(dev->ip6_ptr);
 352         else
 353                 return NULL;
 354 }
 355
 356 /**
 357  * in6_dev_get - get inet6_dev pointer from netdevice
 358  * @dev: network device
 359  *
 360  * This version can be used in any context, and takes a reference
 361  * on the inet6_dev. Callers must use in6_dev_put() later to
 362  * release this reference.
 363  */
 364 static inline struct inet6_dev *in6_dev_get(const struct net_device *dev)
 365 {
 366         struct inet6_dev *idev;
 367
 368         rcu_read_lock();
 369         idev = rcu_dereference(dev->ip6_ptr);
 370         if (idev)
 371                 refcount_inc(&idev->refcnt);
 372         rcu_read_unlock();
 373         return idev;
 374 }
 375
 376 static inline struct neigh_parms *__in6_dev_nd_parms_get_rcu(const struct net_device *dev)
 377 {
 378         struct inet6_dev *idev = __in6_dev_get(dev);
 379
 380         return idev ? idev->nd_parms : NULL;
 381 }
 382
 383 void in6_dev_finish_destroy(struct inet6_dev *idev);
 384
 385 static inline void in6_dev_put(struct inet6_dev *idev)
 386 {
 387         if (refcount_dec_and_test(&idev->refcnt))
 388                 in6_dev_finish_destroy(idev);
 389 }
 390
 391 static inline void in6_dev_put_clear(struct inet6_dev **pidev)
 392 {
 393         struct inet6_dev *idev = *pidev;
 394
 395         if (idev) {
 396                 in6_dev_put(idev);
 397                 *pidev = NULL;
 398         }
 399 }
 400
 401 static inline void __in6_dev_put(struct inet6_dev *idev)
 402 {
 403         refcount_dec(&idev->refcnt);
 404 }
 405
 406 static inline void in6_dev_hold(struct inet6_dev *idev)
 407 {
 408         refcount_inc(&idev->refcnt);
 409 }
 410
 411 /* called with rcu_read_lock held */
 412 static inline bool ip6_ignore_linkdown(const struct net_device *dev)
 413 {
 414         const struct inet6_dev *idev = __in6_dev_get(dev);
 415
 416         if (unlikely(!idev))
 417                 return true;
 418
 419         return !!idev->cnf.ignore_routes_with_linkdown;
 420 }
 421
 422 void inet6_ifa_finish_destroy(struct inet6_ifaddr *ifp);
 423
 424 static inline void in6_ifa_put(struct inet6_ifaddr *ifp)
 425 {
 426         if (refcount_dec_and_test(&ifp->refcnt))
 427                 inet6_ifa_finish_destroy(ifp);
 428 }
 429
 430 static inline void __in6_ifa_put(struct inet6_ifaddr *ifp)
 431 {
 432         refcount_dec(&ifp->refcnt);
 433 }
 434
 435 static inline void in6_ifa_hold(struct inet6_ifaddr *ifp)
 436 {
 437         refcount_inc(&ifp->refcnt);
 438 }
 439
 440
 441 /*
 442  *      compute link-local solicited-node multicast address
 443  */
 444
 445 static inline void addrconf_addr_solict_mult(const struct in6_addr *addr,
 446                                              struct in6_addr *solicited)
 447 {
 448         ipv6_addr_set(solicited,
 449                       htonl(0xFF020000), 0,
 450                       htonl(0x1),
 451                       htonl(0xFF000000) | addr->s6_addr32[3]);
 452 }
 453
 454 static inline bool ipv6_addr_is_ll_all_nodes(const struct in6_addr *addr)
 455 {
 456 #if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64
 457         __be64 *p = (__force __be64 *)addr;
 458         return ((p[0] ^ cpu_to_be64(0xff02000000000000UL)) | (p[1] ^ cpu_to_be64(1))) == 0UL;
 459 #else
 460         return ((addr->s6_addr32[0] ^ htonl(0xff020000)) |
 461                 addr->s6_addr32[1] | addr->s6_addr32[2] |
 462                 (addr->s6_addr32[3] ^ htonl(0x00000001))) == 0;
 463 #endif
 464 }
 465
 466 static inline bool ipv6_addr_is_ll_all_routers(const struct in6_addr *addr)
 467 {
 468 #if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64
 469         __be64 *p = (__force __be64 *)addr;
 470         return ((p[0] ^ cpu_to_be64(0xff02000000000000UL)) | (p[1] ^ cpu_to_be64(2))) == 0UL;
 471 #else
 472         return ((addr->s6_addr32[0] ^ htonl(0xff020000)) |
 473                 addr->s6_addr32[1] | addr->s6_addr32[2] |
 474                 (addr->s6_addr32[3] ^ htonl(0x00000002))) == 0;
 475 #endif
 476 }
 477
 478 static inline bool ipv6_addr_is_isatap(const struct in6_addr *addr)
 479 {
 480         return (addr->s6_addr32[2] | htonl(0x02000000)) == htonl(0x02005EFE);
 481 }
 482
 483 static inline bool ipv6_addr_is_solict_mult(const struct in6_addr *addr)
 484 {
 485 #if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64
 486         __be64 *p = (__force __be64 *)addr;
 487         return ((p[0] ^ cpu_to_be64(0xff02000000000000UL)) |
 488                 ((p[1] ^ cpu_to_be64(0x00000001ff000000UL)) &
 489                  cpu_to_be64(0xffffffffff000000UL))) == 0UL;
 490 #else
 491         return ((addr->s6_addr32[0] ^ htonl(0xff020000)) |
 492                 addr->s6_addr32[1] |
 493                 (addr->s6_addr32[2] ^ htonl(0x00000001)) |
 494                 (addr->s6_addr[12] ^ 0xff)) == 0;
 495 #endif
 496 }
 497
 498 static inline bool ipv6_addr_is_all_snoopers(const struct in6_addr *addr)
 499 {
 500 #if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64
 501         __be64 *p = (__force __be64 *)addr;
 502
 503         return ((p[0] ^ cpu_to_be64(0xff02000000000000UL)) |
 504                 (p[1] ^ cpu_to_be64(0x6a))) == 0UL;
 505 #else
 506         return ((addr->s6_addr32[0] ^ htonl(0xff020000)) |
 507                 addr->s6_addr32[1] | addr->s6_addr32[2] |
 508                 (addr->s6_addr32[3] ^ htonl(0x0000006a))) == 0;
 509 #endif
 510 }
 511
 512 #ifdef CONFIG_PROC_FS
 513 int if6_proc_init(void);
 514 void if6_proc_exit(void);
 515 #endif
 516
 517 #endif