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