License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 14:07:57 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
2005-04-16 22:20:36 +00:00
|
|
|
#ifndef _ADDRCONF_H
|
|
|
|
#define _ADDRCONF_H
|
|
|
|
|
2016-09-28 06:57:58 +00:00
|
|
|
#define MAX_RTR_SOLICITATIONS -1 /* unlimited */
|
2005-04-16 22:20:36 +00:00
|
|
|
#define RTR_SOLICITATION_INTERVAL (4*HZ)
|
2016-09-28 06:57:58 +00:00
|
|
|
#define RTR_SOLICITATION_MAX_INTERVAL (3600*HZ) /* 1 hour */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#define MIN_VALID_LIFETIME (2*3600) /* 2 hours */
|
|
|
|
|
|
|
|
#define TEMP_VALID_LIFETIME (7*86400)
|
|
|
|
#define TEMP_PREFERRED_LIFETIME (86400)
|
2011-07-26 13:50:49 +00:00
|
|
|
#define REGEN_MAX_RETRY (3)
|
2005-04-16 22:20:36 +00:00
|
|
|
#define MAX_DESYNC_FACTOR (600)
|
|
|
|
|
|
|
|
#define ADDR_CHECK_FREQUENCY (120*HZ)
|
|
|
|
|
|
|
|
#define IPV6_MAX_ADDRESSES 16
|
|
|
|
|
2013-01-24 09:41:41 +00:00
|
|
|
#define ADDRCONF_TIMER_FUZZ_MINUS (HZ > 50 ? HZ / 50 : 1)
|
|
|
|
#define ADDRCONF_TIMER_FUZZ (HZ / 4)
|
|
|
|
#define ADDRCONF_TIMER_FUZZ_MAX (HZ)
|
|
|
|
|
2017-05-08 17:12:13 +00:00
|
|
|
#define ADDRCONF_NOTIFY_PRIORITY 0
|
|
|
|
|
2007-11-29 11:11:40 +00:00
|
|
|
#include <linux/in.h>
|
2005-05-04 05:17:18 +00:00
|
|
|
#include <linux/in6.h>
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
struct prefix_info {
|
|
|
|
__u8 type;
|
|
|
|
__u8 length;
|
|
|
|
__u8 prefix_len;
|
|
|
|
|
|
|
|
#if defined(__BIG_ENDIAN_BITFIELD)
|
|
|
|
__u8 onlink : 1,
|
|
|
|
autoconf : 1,
|
|
|
|
reserved : 6;
|
|
|
|
#elif defined(__LITTLE_ENDIAN_BITFIELD)
|
|
|
|
__u8 reserved : 6,
|
|
|
|
autoconf : 1,
|
|
|
|
onlink : 1;
|
|
|
|
#else
|
|
|
|
#error "Please fix <asm/byteorder.h>"
|
|
|
|
#endif
|
2006-11-15 04:56:00 +00:00
|
|
|
__be32 valid;
|
|
|
|
__be32 prefered;
|
|
|
|
__be32 reserved2;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
struct in6_addr prefix;
|
|
|
|
};
|
|
|
|
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <net/if_inet6.h>
|
2005-05-03 21:25:13 +00:00
|
|
|
#include <net/ipv6.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-06-08 20:12:14 +00:00
|
|
|
struct in6_validator_info {
|
|
|
|
struct in6_addr i6vi_addr;
|
|
|
|
struct inet6_dev *i6vi_dev;
|
2017-10-18 16:56:54 +00:00
|
|
|
struct netlink_ext_ack *extack;
|
2017-06-08 20:12:14 +00:00
|
|
|
};
|
|
|
|
|
2018-05-27 15:09:53 +00:00
|
|
|
struct ifa6_config {
|
|
|
|
const struct in6_addr *pfx;
|
|
|
|
unsigned int plen;
|
|
|
|
|
|
|
|
const struct in6_addr *peer_pfx;
|
|
|
|
|
2018-05-27 15:09:58 +00:00
|
|
|
u32 rt_priority;
|
2018-05-27 15:09:53 +00:00
|
|
|
u32 ifa_flags;
|
|
|
|
u32 preferred_lft;
|
|
|
|
u32 valid_lft;
|
|
|
|
u16 scope;
|
|
|
|
};
|
|
|
|
|
2013-08-01 00:31:32 +00:00
|
|
|
int addrconf_init(void);
|
|
|
|
void addrconf_cleanup(void);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-08-01 00:31:32 +00:00
|
|
|
int addrconf_add_ifaddr(struct net *net, void __user *arg);
|
|
|
|
int addrconf_del_ifaddr(struct net *net, void __user *arg);
|
|
|
|
int addrconf_set_dstaddr(struct net *net, void __user *arg);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-08-01 00:31:32 +00:00
|
|
|
int ipv6_chk_addr(struct net *net, const struct in6_addr *addr,
|
|
|
|
const struct net_device *dev, int strict);
|
2015-02-04 11:01:23 +00:00
|
|
|
int ipv6_chk_addr_and_flags(struct net *net, const struct in6_addr *addr,
|
2018-03-13 15:29:37 +00:00
|
|
|
const struct net_device *dev, bool skip_dev_check,
|
|
|
|
int strict, u32 banned_flags);
|
2008-01-11 06:43:18 +00:00
|
|
|
|
2007-06-27 06:56:32 +00:00
|
|
|
#if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
|
2013-08-01 00:31:32 +00:00
|
|
|
int ipv6_chk_home_addr(struct net *net, const struct in6_addr *addr);
|
2006-08-24 02:16:22 +00:00
|
|
|
#endif
|
2008-03-16 02:54:23 +00:00
|
|
|
|
2013-09-23 20:04:19 +00:00
|
|
|
bool ipv6_chk_custom_prefix(const struct in6_addr *addr,
|
|
|
|
const unsigned int prefix_len,
|
|
|
|
struct net_device *dev);
|
|
|
|
|
2013-08-01 00:31:32 +00:00
|
|
|
int ipv6_chk_prefix(const struct in6_addr *addr, struct net_device *dev);
|
|
|
|
|
|
|
|
struct inet6_ifaddr *ipv6_get_ifaddr(struct net *net,
|
|
|
|
const struct in6_addr *addr,
|
|
|
|
struct net_device *dev, int strict);
|
|
|
|
|
|
|
|
int ipv6_dev_get_saddr(struct net *net, const struct net_device *dev,
|
|
|
|
const struct in6_addr *daddr, unsigned int srcprefs,
|
|
|
|
struct in6_addr *saddr);
|
|
|
|
int __ipv6_get_lladdr(struct inet6_dev *idev, struct in6_addr *addr,
|
2013-12-06 08:45:21 +00:00
|
|
|
u32 banned_flags);
|
2013-08-01 00:31:32 +00:00
|
|
|
int ipv6_get_lladdr(struct net_device *dev, struct in6_addr *addr,
|
2013-12-06 08:45:21 +00:00
|
|
|
u32 banned_flags);
|
2017-09-13 20:58:15 +00:00
|
|
|
bool inet_rcv_saddr_equal(const struct sock *sk, const struct sock *sk2,
|
|
|
|
bool match_wildcard);
|
bpf: Introduce BPF_PROG_TYPE_SK_REUSEPORT
This patch adds a BPF_PROG_TYPE_SK_REUSEPORT which can select
a SO_REUSEPORT sk from a BPF_MAP_TYPE_REUSEPORT_ARRAY. Like other
non SK_FILTER/CGROUP_SKB program, it requires CAP_SYS_ADMIN.
BPF_PROG_TYPE_SK_REUSEPORT introduces "struct sk_reuseport_kern"
to store the bpf context instead of using the skb->cb[48].
At the SO_REUSEPORT sk lookup time, it is in the middle of transiting
from a lower layer (ipv4/ipv6) to a upper layer (udp/tcp). At this
point, it is not always clear where the bpf context can be appended
in the skb->cb[48] to avoid saving-and-restoring cb[]. Even putting
aside the difference between ipv4-vs-ipv6 and udp-vs-tcp. It is not
clear if the lower layer is only ipv4 and ipv6 in the future and
will it not touch the cb[] again before transiting to the upper
layer.
For example, in udp_gro_receive(), it uses the 48 byte NAPI_GRO_CB
instead of IP[6]CB and it may still modify the cb[] after calling
the udp[46]_lib_lookup_skb(). Because of the above reason, if
sk->cb is used for the bpf ctx, saving-and-restoring is needed
and likely the whole 48 bytes cb[] has to be saved and restored.
Instead of saving, setting and restoring the cb[], this patch opts
to create a new "struct sk_reuseport_kern" and setting the needed
values in there.
The new BPF_PROG_TYPE_SK_REUSEPORT and "struct sk_reuseport_(kern|md)"
will serve all ipv4/ipv6 + udp/tcp combinations. There is no protocol
specific usage at this point and it is also inline with the current
sock_reuseport.c implementation (i.e. no protocol specific requirement).
In "struct sk_reuseport_md", this patch exposes data/data_end/len
with semantic similar to other existing usages. Together
with "bpf_skb_load_bytes()" and "bpf_skb_load_bytes_relative()",
the bpf prog can peek anywhere in the skb. The "bind_inany" tells
the bpf prog that the reuseport group is bind-ed to a local
INANY address which cannot be learned from skb.
The new "bind_inany" is added to "struct sock_reuseport" which will be
used when running the new "BPF_PROG_TYPE_SK_REUSEPORT" bpf prog in order
to avoid repeating the "bind INANY" test on
"sk_v6_rcv_saddr/sk->sk_rcv_saddr" every time a bpf prog is run. It can
only be properly initialized when a "sk->sk_reuseport" enabled sk is
adding to a hashtable (i.e. during "reuseport_alloc()" and
"reuseport_add_sock()").
The new "sk_select_reuseport()" is the main helper that the
bpf prog will use to select a SO_REUSEPORT sk. It is the only function
that can use the new BPF_MAP_TYPE_REUSEPORT_ARRAY. As mentioned in
the earlier patch, the validity of a selected sk is checked in
run time in "sk_select_reuseport()". Doing the check in
verification time is difficult and inflexible (consider the map-in-map
use case). The runtime check is to compare the selected sk's reuseport_id
with the reuseport_id that we want. This helper will return -EXXX if the
selected sk cannot serve the incoming request (e.g. reuseport_id
not match). The bpf prog can decide if it wants to do SK_DROP as its
discretion.
When the bpf prog returns SK_PASS, the kernel will check if a
valid sk has been selected (i.e. "reuse_kern->selected_sk != NULL").
If it does , it will use the selected sk. If not, the kernel
will select one from "reuse->socks[]" (as before this patch).
The SK_DROP and SK_PASS handling logic will be in the next patch.
Signed-off-by: Martin KaFai Lau <kafai@fb.com>
Acked-by: Alexei Starovoitov <ast@kernel.org>
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
2018-08-08 08:01:25 +00:00
|
|
|
bool inet_rcv_saddr_any(const struct sock *sk);
|
2013-08-01 00:31:32 +00:00
|
|
|
void addrconf_join_solict(struct net_device *dev, const struct in6_addr *addr);
|
|
|
|
void addrconf_leave_solict(struct inet6_dev *idev, const struct in6_addr *addr);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-06-15 19:20:17 +00:00
|
|
|
void addrconf_add_linklocal(struct inet6_dev *idev,
|
|
|
|
const struct in6_addr *addr, u32 flags);
|
|
|
|
|
2016-06-15 19:20:24 +00:00
|
|
|
int addrconf_prefix_rcv_add_addr(struct net *net, struct net_device *dev,
|
|
|
|
const struct prefix_info *pinfo,
|
|
|
|
struct inet6_dev *in6_dev,
|
|
|
|
const struct in6_addr *addr, int addr_type,
|
|
|
|
u32 addr_flags, bool sllao, bool tokenized,
|
|
|
|
__u32 valid_lft, u32 prefered_lft);
|
|
|
|
|
2017-03-14 14:01:57 +00:00
|
|
|
static inline void addrconf_addr_eui48_base(u8 *eui, const char *const addr)
|
|
|
|
{
|
|
|
|
memcpy(eui, addr, 3);
|
|
|
|
eui[3] = 0xFF;
|
|
|
|
eui[4] = 0xFE;
|
|
|
|
memcpy(eui + 5, addr + 3, 3);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void addrconf_addr_eui48(u8 *eui, const char *const addr)
|
|
|
|
{
|
|
|
|
addrconf_addr_eui48_base(eui, addr);
|
|
|
|
eui[0] ^= 2;
|
|
|
|
}
|
|
|
|
|
2015-07-30 15:33:22 +00:00
|
|
|
static inline int addrconf_ifid_eui48(u8 *eui, struct net_device *dev)
|
|
|
|
{
|
|
|
|
if (dev->addr_len != ETH_ALEN)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The zSeries OSA network cards can be shared among various
|
|
|
|
* OS instances, but the OSA cards have only one MAC address.
|
|
|
|
* This leads to duplicate address conflicts in conjunction
|
|
|
|
* with IPv6 if more than one instance uses the same card.
|
|
|
|
*
|
|
|
|
* The driver for these cards can deliver a unique 16-bit
|
|
|
|
* identifier for each instance sharing the same card. It is
|
|
|
|
* placed instead of 0xFFFE in the interface identifier. The
|
|
|
|
* "u" bit of the interface identifier is not inverted in this
|
|
|
|
* case. Hence the resulting interface identifier has local
|
|
|
|
* scope according to RFC2373.
|
|
|
|
*/
|
2017-03-14 14:01:57 +00:00
|
|
|
|
|
|
|
addrconf_addr_eui48_base(eui, dev->dev_addr);
|
|
|
|
|
2015-07-30 15:33:22 +00:00
|
|
|
if (dev->dev_id) {
|
|
|
|
eui[3] = (dev->dev_id >> 8) & 0xFF;
|
|
|
|
eui[4] = dev->dev_id & 0xFF;
|
|
|
|
} else {
|
|
|
|
eui[0] ^= 2;
|
|
|
|
}
|
2017-03-14 14:01:57 +00:00
|
|
|
|
2015-07-30 15:33:22 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-05-27 08:37:49 +00:00
|
|
|
static inline unsigned long addrconf_timeout_fixup(u32 timeout,
|
2012-04-15 05:58:06 +00:00
|
|
|
unsigned int unit)
|
2008-05-27 08:37:49 +00:00
|
|
|
{
|
|
|
|
if (timeout == 0xffffffff)
|
|
|
|
return ~0UL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Avoid arithmetic overflow.
|
|
|
|
* Assuming unit is constant and non-zero, this "if" statement
|
|
|
|
* will go away on 64bit archs.
|
|
|
|
*/
|
|
|
|
if (0xfffffffe > LONG_MAX / unit && timeout > LONG_MAX / unit)
|
|
|
|
return LONG_MAX / unit;
|
|
|
|
|
|
|
|
return timeout;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int addrconf_finite_timeout(unsigned long timeout)
|
|
|
|
{
|
|
|
|
return ~timeout;
|
|
|
|
}
|
|
|
|
|
2007-11-14 06:56:23 +00:00
|
|
|
/*
|
|
|
|
* IPv6 Address Label subsystem (addrlabel.c)
|
|
|
|
*/
|
2013-08-01 00:31:32 +00:00
|
|
|
int ipv6_addr_label_init(void);
|
|
|
|
void ipv6_addr_label_cleanup(void);
|
2017-12-04 18:19:18 +00:00
|
|
|
int ipv6_addr_label_rtnl_register(void);
|
2013-08-01 00:31:32 +00:00
|
|
|
u32 ipv6_addr_label(struct net *net, const struct in6_addr *addr,
|
|
|
|
int type, int ifindex);
|
2007-11-14 06:56:23 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* multicast prototypes (mcast.c)
|
|
|
|
*/
|
2013-08-01 00:31:32 +00:00
|
|
|
int ipv6_sock_mc_join(struct sock *sk, int ifindex,
|
|
|
|
const struct in6_addr *addr);
|
|
|
|
int ipv6_sock_mc_drop(struct sock *sk, int ifindex,
|
|
|
|
const struct in6_addr *addr);
|
2016-10-20 06:35:12 +00:00
|
|
|
void __ipv6_sock_mc_close(struct sock *sk);
|
2013-08-01 00:31:32 +00:00
|
|
|
void ipv6_sock_mc_close(struct sock *sk);
|
|
|
|
bool inet6_mc_check(struct sock *sk, const struct in6_addr *mc_addr,
|
|
|
|
const struct in6_addr *src_addr);
|
|
|
|
|
|
|
|
int ipv6_dev_mc_inc(struct net_device *dev, const struct in6_addr *addr);
|
|
|
|
int __ipv6_dev_mc_dec(struct inet6_dev *idev, const struct in6_addr *addr);
|
|
|
|
int ipv6_dev_mc_dec(struct net_device *dev, const struct in6_addr *addr);
|
|
|
|
void ipv6_mc_up(struct inet6_dev *idev);
|
|
|
|
void ipv6_mc_down(struct inet6_dev *idev);
|
|
|
|
void ipv6_mc_unmap(struct inet6_dev *idev);
|
|
|
|
void ipv6_mc_remap(struct inet6_dev *idev);
|
|
|
|
void ipv6_mc_init_dev(struct inet6_dev *idev);
|
|
|
|
void ipv6_mc_destroy_dev(struct inet6_dev *idev);
|
2015-05-02 12:01:07 +00:00
|
|
|
int ipv6_mc_check_mld(struct sk_buff *skb, struct sk_buff **skb_trimmed);
|
2017-10-30 23:38:52 +00:00
|
|
|
void addrconf_dad_failure(struct sk_buff *skb, struct inet6_ifaddr *ifp);
|
2013-08-01 00:31:32 +00:00
|
|
|
|
|
|
|
bool ipv6_chk_mcast_addr(struct net_device *dev, const struct in6_addr *group,
|
|
|
|
const struct in6_addr *src_addr);
|
|
|
|
|
|
|
|
void ipv6_mc_dad_complete(struct inet6_dev *idev);
|
2013-08-31 05:44:30 +00:00
|
|
|
|
|
|
|
/* A stub used by vxlan module. This is ugly, ideally these
|
|
|
|
* symbols should be built into the core kernel.
|
|
|
|
*/
|
|
|
|
struct ipv6_stub {
|
|
|
|
int (*ipv6_sock_mc_join)(struct sock *sk, int ifindex,
|
|
|
|
const struct in6_addr *addr);
|
|
|
|
int (*ipv6_sock_mc_drop)(struct sock *sk, int ifindex,
|
|
|
|
const struct in6_addr *addr);
|
2015-07-30 20:34:53 +00:00
|
|
|
int (*ipv6_dst_lookup)(struct net *net, struct sock *sk,
|
|
|
|
struct dst_entry **dst, struct flowi6 *fl6);
|
2018-05-10 03:34:25 +00:00
|
|
|
|
|
|
|
struct fib6_table *(*fib6_get_table)(struct net *net, u32 id);
|
|
|
|
struct fib6_info *(*fib6_lookup)(struct net *net, int oif,
|
|
|
|
struct flowi6 *fl6, int flags);
|
|
|
|
struct fib6_info *(*fib6_table_lookup)(struct net *net,
|
|
|
|
struct fib6_table *table,
|
|
|
|
int oif, struct flowi6 *fl6,
|
|
|
|
int flags);
|
|
|
|
struct fib6_info *(*fib6_multipath_select)(const struct net *net,
|
|
|
|
struct fib6_info *f6i,
|
|
|
|
struct flowi6 *fl6, int oif,
|
|
|
|
const struct sk_buff *skb,
|
|
|
|
int strict);
|
2018-05-21 16:08:14 +00:00
|
|
|
u32 (*ip6_mtu_from_fib6)(struct fib6_info *f6i, struct in6_addr *daddr,
|
|
|
|
struct in6_addr *saddr);
|
2018-05-10 03:34:25 +00:00
|
|
|
|
2013-08-31 05:44:30 +00:00
|
|
|
void (*udpv6_encap_enable)(void);
|
2015-09-22 16:57:13 +00:00
|
|
|
void (*ndisc_send_na)(struct net_device *dev, const struct in6_addr *daddr,
|
2013-08-31 05:44:36 +00:00
|
|
|
const struct in6_addr *solicited_addr,
|
|
|
|
bool router, bool solicited, bool override, bool inc_opt);
|
2013-08-31 05:44:34 +00:00
|
|
|
struct neigh_table *nd_tbl;
|
2013-08-31 05:44:30 +00:00
|
|
|
};
|
|
|
|
extern const struct ipv6_stub *ipv6_stub __read_mostly;
|
|
|
|
|
2018-03-30 22:08:05 +00:00
|
|
|
/* A stub used by bpf helpers. Similarly ugly as ipv6_stub */
|
|
|
|
struct ipv6_bpf_stub {
|
|
|
|
int (*inet6_bind)(struct sock *sk, struct sockaddr *uaddr, int addr_len,
|
|
|
|
bool force_bind_address_no_port, bool with_lock);
|
2018-10-15 17:27:45 +00:00
|
|
|
struct sock *(*udp6_lib_lookup)(struct net *net,
|
|
|
|
const struct in6_addr *saddr, __be16 sport,
|
|
|
|
const struct in6_addr *daddr, __be16 dport,
|
|
|
|
int dif, int sdif, struct udp_table *tbl,
|
|
|
|
struct sk_buff *skb);
|
2018-03-30 22:08:05 +00:00
|
|
|
};
|
|
|
|
extern const struct ipv6_bpf_stub *ipv6_bpf_stub __read_mostly;
|
|
|
|
|
2013-01-13 05:02:18 +00:00
|
|
|
/*
|
|
|
|
* identify MLD packets for MLD filter exceptions
|
|
|
|
*/
|
|
|
|
static inline bool ipv6_is_mld(struct sk_buff *skb, int nexthdr, int offset)
|
|
|
|
{
|
|
|
|
struct icmp6hdr *hdr;
|
|
|
|
|
|
|
|
if (nexthdr != IPPROTO_ICMPV6 ||
|
|
|
|
!pskb_network_may_pull(skb, offset + sizeof(struct icmp6hdr)))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
hdr = (struct icmp6hdr *)(skb_network_header(skb) + offset);
|
|
|
|
|
|
|
|
switch (hdr->icmp6_type) {
|
|
|
|
case ICMPV6_MGM_QUERY:
|
|
|
|
case ICMPV6_MGM_REPORT:
|
|
|
|
case ICMPV6_MGM_REDUCTION:
|
|
|
|
case ICMPV6_MLD2_REPORT:
|
|
|
|
return true;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-08-01 00:31:32 +00:00
|
|
|
void addrconf_prefix_rcv(struct net_device *dev,
|
|
|
|
u8 *opt, int len, bool sllao);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* anycast prototypes (anycast.c)
|
|
|
|
*/
|
2013-08-01 00:31:32 +00:00
|
|
|
int ipv6_sock_ac_join(struct sock *sk, int ifindex,
|
|
|
|
const struct in6_addr *addr);
|
|
|
|
int ipv6_sock_ac_drop(struct sock *sk, int ifindex,
|
|
|
|
const struct in6_addr *addr);
|
|
|
|
void ipv6_sock_ac_close(struct sock *sk);
|
|
|
|
|
2014-09-11 22:35:11 +00:00
|
|
|
int __ipv6_dev_ac_inc(struct inet6_dev *idev, const struct in6_addr *addr);
|
2013-08-01 00:31:32 +00:00
|
|
|
int __ipv6_dev_ac_dec(struct inet6_dev *idev, const struct in6_addr *addr);
|
2014-09-10 21:23:02 +00:00
|
|
|
void ipv6_ac_destroy_dev(struct inet6_dev *idev);
|
2013-08-01 00:31:32 +00:00
|
|
|
bool ipv6_chk_acast_addr(struct net *net, struct net_device *dev,
|
2014-01-22 06:42:37 +00:00
|
|
|
const struct in6_addr *addr);
|
|
|
|
bool ipv6_chk_acast_addr_src(struct net *net, struct net_device *dev,
|
|
|
|
const struct in6_addr *addr);
|
2018-11-02 20:23:57 +00:00
|
|
|
int ipv6_anycast_init(void);
|
|
|
|
void ipv6_anycast_cleanup(void);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Device notifier */
|
2013-08-01 00:31:32 +00:00
|
|
|
int register_inet6addr_notifier(struct notifier_block *nb);
|
|
|
|
int unregister_inet6addr_notifier(struct notifier_block *nb);
|
|
|
|
int inet6addr_notifier_call_chain(unsigned long val, void *v);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-06-08 20:12:14 +00:00
|
|
|
int register_inet6addr_validator_notifier(struct notifier_block *nb);
|
|
|
|
int unregister_inet6addr_validator_notifier(struct notifier_block *nb);
|
|
|
|
int inet6addr_validator_notifier_call_chain(unsigned long val, void *v);
|
|
|
|
|
2017-03-28 21:28:04 +00:00
|
|
|
void inet6_netconf_notify_devconf(struct net *net, int event, int type,
|
|
|
|
int ifindex, struct ipv6_devconf *devconf);
|
2012-12-04 01:13:35 +00:00
|
|
|
|
2010-09-21 06:57:39 +00:00
|
|
|
/**
|
|
|
|
* __in6_dev_get - get inet6_dev pointer from netdevice
|
|
|
|
* @dev: network device
|
|
|
|
*
|
|
|
|
* Caller must hold rcu_read_lock or RTNL, because this function
|
|
|
|
* does not take a reference on the inet6_dev.
|
|
|
|
*/
|
|
|
|
static inline struct inet6_dev *__in6_dev_get(const struct net_device *dev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2010-09-21 06:57:39 +00:00
|
|
|
return rcu_dereference_rtnl(dev->ip6_ptr);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2018-04-16 17:42:16 +00:00
|
|
|
/**
|
|
|
|
* __in6_dev_get_safely - get inet6_dev pointer from netdevice
|
|
|
|
* @dev: network device
|
|
|
|
*
|
|
|
|
* This is a safer version of __in6_dev_get
|
|
|
|
*/
|
|
|
|
static inline struct inet6_dev *__in6_dev_get_safely(const struct net_device *dev)
|
|
|
|
{
|
|
|
|
if (likely(dev))
|
|
|
|
return rcu_dereference_rtnl(dev->ip6_ptr);
|
|
|
|
else
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-09-21 06:57:39 +00:00
|
|
|
/**
|
|
|
|
* in6_dev_get - get inet6_dev pointer from netdevice
|
|
|
|
* @dev: network device
|
|
|
|
*
|
|
|
|
* This version can be used in any context, and takes a reference
|
|
|
|
* on the inet6_dev. Callers must use in6_dev_put() later to
|
|
|
|
* release this reference.
|
|
|
|
*/
|
|
|
|
static inline struct inet6_dev *in6_dev_get(const struct net_device *dev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2010-09-21 06:57:39 +00:00
|
|
|
struct inet6_dev *idev;
|
|
|
|
|
2006-09-22 21:44:24 +00:00
|
|
|
rcu_read_lock();
|
2010-09-21 06:57:39 +00:00
|
|
|
idev = rcu_dereference(dev->ip6_ptr);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (idev)
|
2017-07-04 06:34:55 +00:00
|
|
|
refcount_inc(&idev->refcnt);
|
2006-09-22 21:44:24 +00:00
|
|
|
rcu_read_unlock();
|
2005-04-16 22:20:36 +00:00
|
|
|
return idev;
|
|
|
|
}
|
|
|
|
|
2013-12-07 18:26:57 +00:00
|
|
|
static inline struct neigh_parms *__in6_dev_nd_parms_get_rcu(const struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct inet6_dev *idev = __in6_dev_get(dev);
|
|
|
|
|
|
|
|
return idev ? idev->nd_parms : NULL;
|
|
|
|
}
|
|
|
|
|
2013-08-01 00:31:32 +00:00
|
|
|
void in6_dev_finish_destroy(struct inet6_dev *idev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-09-21 06:57:39 +00:00
|
|
|
static inline void in6_dev_put(struct inet6_dev *idev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2017-07-04 06:34:55 +00:00
|
|
|
if (refcount_dec_and_test(&idev->refcnt))
|
2005-04-16 22:20:36 +00:00
|
|
|
in6_dev_finish_destroy(idev);
|
|
|
|
}
|
|
|
|
|
2017-08-15 11:09:51 +00:00
|
|
|
static inline void in6_dev_put_clear(struct inet6_dev **pidev)
|
|
|
|
{
|
|
|
|
struct inet6_dev *idev = *pidev;
|
|
|
|
|
|
|
|
if (idev) {
|
|
|
|
in6_dev_put(idev);
|
|
|
|
*pidev = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-09-21 06:57:39 +00:00
|
|
|
static inline void __in6_dev_put(struct inet6_dev *idev)
|
|
|
|
{
|
2017-07-04 06:34:55 +00:00
|
|
|
refcount_dec(&idev->refcnt);
|
2010-09-21 06:57:39 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-09-21 06:57:39 +00:00
|
|
|
static inline void in6_dev_hold(struct inet6_dev *idev)
|
|
|
|
{
|
2017-07-04 06:34:55 +00:00
|
|
|
refcount_inc(&idev->refcnt);
|
2010-09-21 06:57:39 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-08-01 00:31:32 +00:00
|
|
|
void inet6_ifa_finish_destroy(struct inet6_ifaddr *ifp);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
static inline void in6_ifa_put(struct inet6_ifaddr *ifp)
|
|
|
|
{
|
2017-07-04 06:34:56 +00:00
|
|
|
if (refcount_dec_and_test(&ifp->refcnt))
|
2005-04-16 22:20:36 +00:00
|
|
|
inet6_ifa_finish_destroy(ifp);
|
|
|
|
}
|
|
|
|
|
2010-09-21 06:57:39 +00:00
|
|
|
static inline void __in6_ifa_put(struct inet6_ifaddr *ifp)
|
|
|
|
{
|
2017-07-04 06:34:56 +00:00
|
|
|
refcount_dec(&ifp->refcnt);
|
2010-09-21 06:57:39 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-09-21 06:57:39 +00:00
|
|
|
static inline void in6_ifa_hold(struct inet6_ifaddr *ifp)
|
|
|
|
{
|
2017-07-04 06:34:56 +00:00
|
|
|
refcount_inc(&ifp->refcnt);
|
2010-09-21 06:57:39 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* compute link-local solicited-node multicast address
|
|
|
|
*/
|
|
|
|
|
|
|
|
static inline void addrconf_addr_solict_mult(const struct in6_addr *addr,
|
|
|
|
struct in6_addr *solicited)
|
|
|
|
{
|
|
|
|
ipv6_addr_set(solicited,
|
2008-02-28 08:03:12 +00:00
|
|
|
htonl(0xFF020000), 0,
|
|
|
|
htonl(0x1),
|
|
|
|
htonl(0xFF000000) | addr->s6_addr32[3]);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2013-01-20 17:38:38 +00:00
|
|
|
static inline bool ipv6_addr_is_ll_all_nodes(const struct in6_addr *addr)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2013-01-20 07:38:52 +00:00
|
|
|
#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64
|
2014-02-27 13:20:29 +00:00
|
|
|
__be64 *p = (__be64 *)addr;
|
2013-01-20 07:38:52 +00:00
|
|
|
return ((p[0] ^ cpu_to_be64(0xff02000000000000UL)) | (p[1] ^ cpu_to_be64(1))) == 0UL;
|
|
|
|
#else
|
2010-09-21 06:57:39 +00:00
|
|
|
return ((addr->s6_addr32[0] ^ htonl(0xff020000)) |
|
2008-04-11 11:17:55 +00:00
|
|
|
addr->s6_addr32[1] | addr->s6_addr32[2] |
|
2010-09-21 06:57:39 +00:00
|
|
|
(addr->s6_addr32[3] ^ htonl(0x00000001))) == 0;
|
2013-01-20 07:38:52 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2013-01-20 17:38:38 +00:00
|
|
|
static inline bool ipv6_addr_is_ll_all_routers(const struct in6_addr *addr)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2013-01-20 07:38:52 +00:00
|
|
|
#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64
|
2014-02-27 13:20:29 +00:00
|
|
|
__be64 *p = (__be64 *)addr;
|
2013-01-20 07:38:52 +00:00
|
|
|
return ((p[0] ^ cpu_to_be64(0xff02000000000000UL)) | (p[1] ^ cpu_to_be64(2))) == 0UL;
|
|
|
|
#else
|
2010-09-21 06:57:39 +00:00
|
|
|
return ((addr->s6_addr32[0] ^ htonl(0xff020000)) |
|
2008-04-11 11:17:55 +00:00
|
|
|
addr->s6_addr32[1] | addr->s6_addr32[2] |
|
2010-09-21 06:57:39 +00:00
|
|
|
(addr->s6_addr32[3] ^ htonl(0x00000002))) == 0;
|
2013-01-20 07:38:52 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2013-01-20 17:38:38 +00:00
|
|
|
static inline bool ipv6_addr_is_isatap(const struct in6_addr *addr)
|
2007-11-29 11:11:40 +00:00
|
|
|
{
|
2010-09-21 06:57:39 +00:00
|
|
|
return (addr->s6_addr32[2] | htonl(0x02000000)) == htonl(0x02005EFE);
|
2007-11-29 11:11:40 +00:00
|
|
|
}
|
|
|
|
|
2013-01-20 07:39:00 +00:00
|
|
|
static inline bool ipv6_addr_is_solict_mult(const struct in6_addr *addr)
|
|
|
|
{
|
2013-01-20 07:39:07 +00:00
|
|
|
#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64
|
2014-02-27 13:20:29 +00:00
|
|
|
__be64 *p = (__be64 *)addr;
|
2013-01-20 07:39:07 +00:00
|
|
|
return ((p[0] ^ cpu_to_be64(0xff02000000000000UL)) |
|
|
|
|
((p[1] ^ cpu_to_be64(0x00000001ff000000UL)) &
|
|
|
|
cpu_to_be64(0xffffffffff000000UL))) == 0UL;
|
|
|
|
#else
|
|
|
|
return ((addr->s6_addr32[0] ^ htonl(0xff020000)) |
|
|
|
|
addr->s6_addr32[1] |
|
|
|
|
(addr->s6_addr32[2] ^ htonl(0x00000001)) |
|
|
|
|
(addr->s6_addr[12] ^ 0xff)) == 0;
|
|
|
|
#endif
|
2013-01-20 07:39:00 +00:00
|
|
|
}
|
|
|
|
|
2005-08-16 05:18:02 +00:00
|
|
|
#ifdef CONFIG_PROC_FS
|
2013-08-01 00:31:32 +00:00
|
|
|
int if6_proc_init(void);
|
|
|
|
void if6_proc_exit(void);
|
2005-08-16 05:18:02 +00:00
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|