Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | #ifndef _NDISC_H |
| 2 | #define _NDISC_H |
| 3 | |
| 4 | /* |
| 5 | * ICMP codes for neighbour discovery messages |
| 6 | */ |
| 7 | |
| 8 | #define NDISC_ROUTER_SOLICITATION 133 |
| 9 | #define NDISC_ROUTER_ADVERTISEMENT 134 |
| 10 | #define NDISC_NEIGHBOUR_SOLICITATION 135 |
| 11 | #define NDISC_NEIGHBOUR_ADVERTISEMENT 136 |
| 12 | #define NDISC_REDIRECT 137 |
| 13 | |
| 14 | /* |
Templin, Fred L | fadf6bf | 2008-03-11 18:35:59 -0400 | [diff] [blame] | 15 | * Router type: cross-layer information from link-layer to |
| 16 | * IPv6 layer reported by certain link types (e.g., RFC4214). |
| 17 | */ |
| 18 | #define NDISC_NODETYPE_UNSPEC 0 /* unspecified (default) */ |
| 19 | #define NDISC_NODETYPE_HOST 1 /* host or unauthorized router */ |
| 20 | #define NDISC_NODETYPE_NODEFAULT 2 /* non-default router */ |
| 21 | #define NDISC_NODETYPE_DEFAULT 3 /* default router */ |
| 22 | |
| 23 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 24 | * ndisc options |
| 25 | */ |
| 26 | |
| 27 | enum { |
| 28 | __ND_OPT_PREFIX_INFO_END = 0, |
| 29 | ND_OPT_SOURCE_LL_ADDR = 1, /* RFC2461 */ |
| 30 | ND_OPT_TARGET_LL_ADDR = 2, /* RFC2461 */ |
| 31 | ND_OPT_PREFIX_INFO = 3, /* RFC2461 */ |
| 32 | ND_OPT_REDIRECT_HDR = 4, /* RFC2461 */ |
| 33 | ND_OPT_MTU = 5, /* RFC2461 */ |
Erik Nordmark | adc176c | 2016-12-02 14:00:08 -0800 | [diff] [blame] | 34 | ND_OPT_NONCE = 14, /* RFC7527 */ |
YOSHIFUJI Hideaki | 70ceb4f | 2006-03-20 17:06:24 -0800 | [diff] [blame] | 35 | __ND_OPT_ARRAY_MAX, |
| 36 | ND_OPT_ROUTE_INFO = 24, /* RFC4191 */ |
Pierre Ynard | 3191057 | 2007-10-10 21:22:05 -0700 | [diff] [blame] | 37 | ND_OPT_RDNSS = 25, /* RFC5006 */ |
Alexey I. Froloff | e35f30c | 2012-04-06 05:50:58 +0000 | [diff] [blame] | 38 | ND_OPT_DNSSL = 31, /* RFC6106 */ |
Alexander Aring | bbe5f5c | 2016-06-15 21:20:25 +0200 | [diff] [blame] | 39 | ND_OPT_6CO = 34, /* RFC6775 */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 40 | __ND_OPT_MAX |
| 41 | }; |
| 42 | |
| 43 | #define MAX_RTR_SOLICITATION_DELAY HZ |
| 44 | |
| 45 | #define ND_REACHABLE_TIME (30*HZ) |
| 46 | #define ND_RETRANS_TIMER HZ |
| 47 | |
Arnaldo Carvalho de Melo | 14c8502 | 2005-12-27 02:43:12 -0200 | [diff] [blame] | 48 | #include <linux/compiler.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 49 | #include <linux/icmpv6.h> |
Arnaldo Carvalho de Melo | 14c8502 | 2005-12-27 02:43:12 -0200 | [diff] [blame] | 50 | #include <linux/in6.h> |
| 51 | #include <linux/types.h> |
David S. Miller | 30f2a5f | 2012-07-11 23:26:46 -0700 | [diff] [blame] | 52 | #include <linux/if_arp.h> |
| 53 | #include <linux/netdevice.h> |
Pavel Emelyanov | b14f243 | 2012-08-08 21:52:28 +0000 | [diff] [blame] | 54 | #include <linux/hash.h> |
Arnaldo Carvalho de Melo | 14c8502 | 2005-12-27 02:43:12 -0200 | [diff] [blame] | 55 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 56 | #include <net/neighbour.h> |
Arnaldo Carvalho de Melo | 14c8502 | 2005-12-27 02:43:12 -0200 | [diff] [blame] | 57 | |
Alexander Aring | cc84b3c | 2016-06-15 21:20:24 +0200 | [diff] [blame] | 58 | /* Set to 3 to get tracing... */ |
| 59 | #define ND_DEBUG 1 |
| 60 | |
| 61 | #define ND_PRINTK(val, level, fmt, ...) \ |
| 62 | do { \ |
| 63 | if (val <= ND_DEBUG) \ |
| 64 | net_##level##_ratelimited(fmt, ##__VA_ARGS__); \ |
| 65 | } while (0) |
| 66 | |
Arnaldo Carvalho de Melo | 14c8502 | 2005-12-27 02:43:12 -0200 | [diff] [blame] | 67 | struct ctl_table; |
Arnaldo Carvalho de Melo | 14c8502 | 2005-12-27 02:43:12 -0200 | [diff] [blame] | 68 | struct inet6_dev; |
| 69 | struct net_device; |
| 70 | struct net_proto_family; |
| 71 | struct sk_buff; |
Alexander Aring | f997c55 | 2016-06-15 21:20:23 +0200 | [diff] [blame] | 72 | struct prefix_info; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 73 | |
| 74 | extern struct neigh_table nd_tbl; |
| 75 | |
| 76 | struct nd_msg { |
| 77 | struct icmp6hdr icmph; |
| 78 | struct in6_addr target; |
| 79 | __u8 opt[0]; |
| 80 | }; |
| 81 | |
| 82 | struct rs_msg { |
| 83 | struct icmp6hdr icmph; |
| 84 | __u8 opt[0]; |
| 85 | }; |
| 86 | |
| 87 | struct ra_msg { |
| 88 | struct icmp6hdr icmph; |
Al Viro | e69a4adc | 2006-11-14 20:56:00 -0800 | [diff] [blame] | 89 | __be32 reachable_time; |
| 90 | __be32 retrans_timer; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 91 | }; |
| 92 | |
Duan Jiong | 093d04d | 2012-12-14 02:59:59 +0000 | [diff] [blame] | 93 | struct rd_msg { |
| 94 | struct icmp6hdr icmph; |
| 95 | struct in6_addr target; |
| 96 | struct in6_addr dest; |
| 97 | __u8 opt[0]; |
| 98 | }; |
| 99 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 100 | struct nd_opt_hdr { |
| 101 | __u8 nd_opt_type; |
| 102 | __u8 nd_opt_len; |
Eric Dumazet | bc10502 | 2010-06-03 03:21:52 -0700 | [diff] [blame] | 103 | } __packed; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 104 | |
David S. Miller | 30f2a5f | 2012-07-11 23:26:46 -0700 | [diff] [blame] | 105 | /* ND options */ |
| 106 | struct ndisc_options { |
| 107 | struct nd_opt_hdr *nd_opt_array[__ND_OPT_ARRAY_MAX]; |
| 108 | #ifdef CONFIG_IPV6_ROUTE_INFO |
| 109 | struct nd_opt_hdr *nd_opts_ri; |
| 110 | struct nd_opt_hdr *nd_opts_ri_end; |
| 111 | #endif |
| 112 | struct nd_opt_hdr *nd_useropts; |
| 113 | struct nd_opt_hdr *nd_useropts_end; |
Alexander Aring | bbe5f5c | 2016-06-15 21:20:25 +0200 | [diff] [blame] | 114 | #if IS_ENABLED(CONFIG_IEEE802154_6LOWPAN) |
| 115 | struct nd_opt_hdr *nd_802154_opt_array[ND_OPT_TARGET_LL_ADDR + 1]; |
| 116 | #endif |
David S. Miller | 30f2a5f | 2012-07-11 23:26:46 -0700 | [diff] [blame] | 117 | }; |
| 118 | |
Alexander Aring | bbe5f5c | 2016-06-15 21:20:25 +0200 | [diff] [blame] | 119 | #define nd_opts_src_lladdr nd_opt_array[ND_OPT_SOURCE_LL_ADDR] |
| 120 | #define nd_opts_tgt_lladdr nd_opt_array[ND_OPT_TARGET_LL_ADDR] |
| 121 | #define nd_opts_pi nd_opt_array[ND_OPT_PREFIX_INFO] |
| 122 | #define nd_opts_pi_end nd_opt_array[__ND_OPT_PREFIX_INFO_END] |
| 123 | #define nd_opts_rh nd_opt_array[ND_OPT_REDIRECT_HDR] |
| 124 | #define nd_opts_mtu nd_opt_array[ND_OPT_MTU] |
Erik Nordmark | adc176c | 2016-12-02 14:00:08 -0800 | [diff] [blame] | 125 | #define nd_opts_nonce nd_opt_array[ND_OPT_NONCE] |
Alexander Aring | bbe5f5c | 2016-06-15 21:20:25 +0200 | [diff] [blame] | 126 | #define nd_802154_opts_src_lladdr nd_802154_opt_array[ND_OPT_SOURCE_LL_ADDR] |
| 127 | #define nd_802154_opts_tgt_lladdr nd_802154_opt_array[ND_OPT_TARGET_LL_ADDR] |
David S. Miller | 30f2a5f | 2012-07-11 23:26:46 -0700 | [diff] [blame] | 128 | |
| 129 | #define NDISC_OPT_SPACE(len) (((len)+2+7)&~7) |
| 130 | |
Alexander Aring | f997c55 | 2016-06-15 21:20:23 +0200 | [diff] [blame] | 131 | struct ndisc_options *ndisc_parse_options(const struct net_device *dev, |
| 132 | u8 *opt, int opt_len, |
Joe Perches | 3cc818a | 2013-09-21 10:22:47 -0700 | [diff] [blame] | 133 | struct ndisc_options *ndopts); |
David S. Miller | 30f2a5f | 2012-07-11 23:26:46 -0700 | [diff] [blame] | 134 | |
Alexander Aring | cc84b3c | 2016-06-15 21:20:24 +0200 | [diff] [blame] | 135 | void __ndisc_fill_addr_option(struct sk_buff *skb, int type, void *data, |
| 136 | int data_len, int pad); |
| 137 | |
Alexander Aring | f997c55 | 2016-06-15 21:20:23 +0200 | [diff] [blame] | 138 | #define NDISC_OPS_REDIRECT_DATA_SPACE 2 |
| 139 | |
| 140 | /* |
| 141 | * This structure defines the hooks for IPv6 neighbour discovery. |
| 142 | * The following hooks can be defined; unless noted otherwise, they are |
| 143 | * optional and can be filled with a null pointer. |
| 144 | * |
| 145 | * int (*is_useropt)(u8 nd_opt_type): |
| 146 | * This function is called when IPv6 decide RA userspace options. if |
| 147 | * this function returns 1 then the option given by nd_opt_type will |
| 148 | * be handled as userspace option additional to the IPv6 options. |
| 149 | * |
| 150 | * int (*parse_options)(const struct net_device *dev, |
| 151 | * struct nd_opt_hdr *nd_opt, |
| 152 | * struct ndisc_options *ndopts): |
| 153 | * This function is called while parsing ndisc ops and put each position |
| 154 | * as pointer into ndopts. If this function return unequal 0, then this |
| 155 | * function took care about the ndisc option, if 0 then the IPv6 ndisc |
| 156 | * option parser will take care about that option. |
| 157 | * |
| 158 | * void (*update)(const struct net_device *dev, struct neighbour *n, |
| 159 | * u32 flags, u8 icmp6_type, |
| 160 | * const struct ndisc_options *ndopts): |
| 161 | * This function is called when IPv6 ndisc updates the neighbour cache |
| 162 | * entry. Additional options which can be updated may be previously |
| 163 | * parsed by parse_opts callback and accessible over ndopts parameter. |
| 164 | * |
| 165 | * int (*opt_addr_space)(const struct net_device *dev, u8 icmp6_type, |
| 166 | * struct neighbour *neigh, u8 *ha_buf, |
| 167 | * u8 **ha): |
| 168 | * This function is called when the necessary option space will be |
| 169 | * calculated before allocating a skb. The parameters neigh, ha_buf |
| 170 | * abd ha are available on NDISC_REDIRECT messages only. |
| 171 | * |
| 172 | * void (*fill_addr_option)(const struct net_device *dev, |
| 173 | * struct sk_buff *skb, u8 icmp6_type, |
| 174 | * const u8 *ha): |
| 175 | * This function is called when the skb will finally fill the option |
| 176 | * fields inside skb. NOTE: this callback should fill the option |
| 177 | * fields to the skb which are previously indicated by opt_space |
| 178 | * parameter. That means the decision to add such option should |
| 179 | * not lost between these two callbacks, e.g. protected by interface |
| 180 | * up state. |
| 181 | * |
| 182 | * void (*prefix_rcv_add_addr)(struct net *net, struct net_device *dev, |
| 183 | * const struct prefix_info *pinfo, |
| 184 | * struct inet6_dev *in6_dev, |
| 185 | * struct in6_addr *addr, |
| 186 | * int addr_type, u32 addr_flags, |
| 187 | * bool sllao, bool tokenized, |
| 188 | * __u32 valid_lft, u32 prefered_lft, |
| 189 | * bool dev_addr_generated): |
| 190 | * This function is called when a RA messages is received with valid |
| 191 | * PIO option fields and an IPv6 address will be added to the interface |
| 192 | * for autoconfiguration. The parameter dev_addr_generated reports about |
| 193 | * if the address was based on dev->dev_addr or not. This can be used |
| 194 | * to add a second address if link-layer operates with two link layer |
| 195 | * addresses. E.g. 802.15.4 6LoWPAN. |
| 196 | */ |
| 197 | struct ndisc_ops { |
| 198 | int (*is_useropt)(u8 nd_opt_type); |
| 199 | int (*parse_options)(const struct net_device *dev, |
| 200 | struct nd_opt_hdr *nd_opt, |
| 201 | struct ndisc_options *ndopts); |
| 202 | void (*update)(const struct net_device *dev, struct neighbour *n, |
| 203 | u32 flags, u8 icmp6_type, |
| 204 | const struct ndisc_options *ndopts); |
| 205 | int (*opt_addr_space)(const struct net_device *dev, u8 icmp6_type, |
| 206 | struct neighbour *neigh, u8 *ha_buf, |
| 207 | u8 **ha); |
| 208 | void (*fill_addr_option)(const struct net_device *dev, |
| 209 | struct sk_buff *skb, u8 icmp6_type, |
| 210 | const u8 *ha); |
| 211 | void (*prefix_rcv_add_addr)(struct net *net, struct net_device *dev, |
| 212 | const struct prefix_info *pinfo, |
| 213 | struct inet6_dev *in6_dev, |
| 214 | struct in6_addr *addr, |
| 215 | int addr_type, u32 addr_flags, |
| 216 | bool sllao, bool tokenized, |
| 217 | __u32 valid_lft, u32 prefered_lft, |
| 218 | bool dev_addr_generated); |
| 219 | }; |
| 220 | |
| 221 | #if IS_ENABLED(CONFIG_IPV6) |
| 222 | static inline int ndisc_ops_is_useropt(const struct net_device *dev, |
| 223 | u8 nd_opt_type) |
| 224 | { |
| 225 | if (dev->ndisc_ops && dev->ndisc_ops->is_useropt) |
| 226 | return dev->ndisc_ops->is_useropt(nd_opt_type); |
| 227 | else |
| 228 | return 0; |
| 229 | } |
| 230 | |
| 231 | static inline int ndisc_ops_parse_options(const struct net_device *dev, |
| 232 | struct nd_opt_hdr *nd_opt, |
| 233 | struct ndisc_options *ndopts) |
| 234 | { |
| 235 | if (dev->ndisc_ops && dev->ndisc_ops->parse_options) |
| 236 | return dev->ndisc_ops->parse_options(dev, nd_opt, ndopts); |
| 237 | else |
| 238 | return 0; |
| 239 | } |
| 240 | |
| 241 | static inline void ndisc_ops_update(const struct net_device *dev, |
| 242 | struct neighbour *n, u32 flags, |
| 243 | u8 icmp6_type, |
| 244 | const struct ndisc_options *ndopts) |
| 245 | { |
| 246 | if (dev->ndisc_ops && dev->ndisc_ops->update) |
| 247 | dev->ndisc_ops->update(dev, n, flags, icmp6_type, ndopts); |
| 248 | } |
| 249 | |
| 250 | static inline int ndisc_ops_opt_addr_space(const struct net_device *dev, |
| 251 | u8 icmp6_type) |
| 252 | { |
| 253 | if (dev->ndisc_ops && dev->ndisc_ops->opt_addr_space && |
| 254 | icmp6_type != NDISC_REDIRECT) |
| 255 | return dev->ndisc_ops->opt_addr_space(dev, icmp6_type, NULL, |
| 256 | NULL, NULL); |
| 257 | else |
| 258 | return 0; |
| 259 | } |
| 260 | |
| 261 | static inline int ndisc_ops_redirect_opt_addr_space(const struct net_device *dev, |
| 262 | struct neighbour *neigh, |
| 263 | u8 *ha_buf, u8 **ha) |
| 264 | { |
| 265 | if (dev->ndisc_ops && dev->ndisc_ops->opt_addr_space) |
| 266 | return dev->ndisc_ops->opt_addr_space(dev, NDISC_REDIRECT, |
| 267 | neigh, ha_buf, ha); |
| 268 | else |
| 269 | return 0; |
| 270 | } |
| 271 | |
| 272 | static inline void ndisc_ops_fill_addr_option(const struct net_device *dev, |
| 273 | struct sk_buff *skb, |
| 274 | u8 icmp6_type) |
| 275 | { |
| 276 | if (dev->ndisc_ops && dev->ndisc_ops->fill_addr_option && |
| 277 | icmp6_type != NDISC_REDIRECT) |
| 278 | dev->ndisc_ops->fill_addr_option(dev, skb, icmp6_type, NULL); |
| 279 | } |
| 280 | |
| 281 | static inline void ndisc_ops_fill_redirect_addr_option(const struct net_device *dev, |
| 282 | struct sk_buff *skb, |
| 283 | const u8 *ha) |
| 284 | { |
| 285 | if (dev->ndisc_ops && dev->ndisc_ops->fill_addr_option) |
| 286 | dev->ndisc_ops->fill_addr_option(dev, skb, NDISC_REDIRECT, ha); |
| 287 | } |
| 288 | |
| 289 | static inline void ndisc_ops_prefix_rcv_add_addr(struct net *net, |
| 290 | struct net_device *dev, |
| 291 | const struct prefix_info *pinfo, |
| 292 | struct inet6_dev *in6_dev, |
| 293 | struct in6_addr *addr, |
| 294 | int addr_type, u32 addr_flags, |
| 295 | bool sllao, bool tokenized, |
| 296 | __u32 valid_lft, |
| 297 | u32 prefered_lft, |
| 298 | bool dev_addr_generated) |
| 299 | { |
| 300 | if (dev->ndisc_ops && dev->ndisc_ops->prefix_rcv_add_addr) |
| 301 | dev->ndisc_ops->prefix_rcv_add_addr(net, dev, pinfo, in6_dev, |
| 302 | addr, addr_type, |
| 303 | addr_flags, sllao, |
| 304 | tokenized, valid_lft, |
| 305 | prefered_lft, |
| 306 | dev_addr_generated); |
| 307 | } |
| 308 | #endif |
| 309 | |
David S. Miller | 30f2a5f | 2012-07-11 23:26:46 -0700 | [diff] [blame] | 310 | /* |
| 311 | * Return the padding between the option length and the start of the |
| 312 | * link addr. Currently only IP-over-InfiniBand needs this, although |
| 313 | * if RFC 3831 IPv6-over-Fibre Channel is ever implemented it may |
| 314 | * also need a pad of 2. |
| 315 | */ |
Joe Perches | d9d10a3 | 2013-07-30 10:31:00 -0700 | [diff] [blame] | 316 | static inline int ndisc_addr_option_pad(unsigned short type) |
David S. Miller | 30f2a5f | 2012-07-11 23:26:46 -0700 | [diff] [blame] | 317 | { |
| 318 | switch (type) { |
| 319 | case ARPHRD_INFINIBAND: return 2; |
| 320 | default: return 0; |
| 321 | } |
| 322 | } |
| 323 | |
Alexander Aring | 1e82f96 | 2016-06-15 21:20:19 +0200 | [diff] [blame] | 324 | static inline int __ndisc_opt_addr_space(unsigned char addr_len, int pad) |
| 325 | { |
| 326 | return NDISC_OPT_SPACE(addr_len + pad); |
| 327 | } |
| 328 | |
Alexander Aring | f997c55 | 2016-06-15 21:20:23 +0200 | [diff] [blame] | 329 | #if IS_ENABLED(CONFIG_IPV6) |
| 330 | static inline int ndisc_opt_addr_space(struct net_device *dev, u8 icmp6_type) |
YOSHIFUJI Hideaki / 吉藤英明 | c558e9f | 2013-01-21 06:47:56 +0000 | [diff] [blame] | 331 | { |
Alexander Aring | 1e82f96 | 2016-06-15 21:20:19 +0200 | [diff] [blame] | 332 | return __ndisc_opt_addr_space(dev->addr_len, |
Alexander Aring | f997c55 | 2016-06-15 21:20:23 +0200 | [diff] [blame] | 333 | ndisc_addr_option_pad(dev->type)) + |
| 334 | ndisc_ops_opt_addr_space(dev, icmp6_type); |
YOSHIFUJI Hideaki / 吉藤英明 | c558e9f | 2013-01-21 06:47:56 +0000 | [diff] [blame] | 335 | } |
| 336 | |
Alexander Aring | f997c55 | 2016-06-15 21:20:23 +0200 | [diff] [blame] | 337 | static inline int ndisc_redirect_opt_addr_space(struct net_device *dev, |
| 338 | struct neighbour *neigh, |
| 339 | u8 *ops_data_buf, |
| 340 | u8 **ops_data) |
| 341 | { |
| 342 | return __ndisc_opt_addr_space(dev->addr_len, |
| 343 | ndisc_addr_option_pad(dev->type)) + |
| 344 | ndisc_ops_redirect_opt_addr_space(dev, neigh, ops_data_buf, |
| 345 | ops_data); |
| 346 | } |
| 347 | #endif |
| 348 | |
Alexander Aring | 4f36ce8 | 2016-06-15 21:20:20 +0200 | [diff] [blame] | 349 | static inline u8 *__ndisc_opt_addr_data(struct nd_opt_hdr *p, |
| 350 | unsigned char addr_len, int prepad) |
David S. Miller | 30f2a5f | 2012-07-11 23:26:46 -0700 | [diff] [blame] | 351 | { |
| 352 | u8 *lladdr = (u8 *)(p + 1); |
| 353 | int lladdrlen = p->nd_opt_len << 3; |
Alexander Aring | 4f36ce8 | 2016-06-15 21:20:20 +0200 | [diff] [blame] | 354 | if (lladdrlen != __ndisc_opt_addr_space(addr_len, prepad)) |
David S. Miller | 30f2a5f | 2012-07-11 23:26:46 -0700 | [diff] [blame] | 355 | return NULL; |
| 356 | return lladdr + prepad; |
| 357 | } |
| 358 | |
Alexander Aring | 4f36ce8 | 2016-06-15 21:20:20 +0200 | [diff] [blame] | 359 | static inline u8 *ndisc_opt_addr_data(struct nd_opt_hdr *p, |
| 360 | struct net_device *dev) |
| 361 | { |
| 362 | return __ndisc_opt_addr_data(p, dev->addr_len, |
| 363 | ndisc_addr_option_pad(dev->type)); |
| 364 | } |
| 365 | |
David S. Miller | 2c2aba6 | 2011-12-28 15:06:58 -0500 | [diff] [blame] | 366 | static inline u32 ndisc_hashfn(const void *pkey, const struct net_device *dev, __u32 *hash_rnd) |
| 367 | { |
| 368 | const u32 *p32 = pkey; |
| 369 | |
Pavel Emelyanov | b14f243 | 2012-08-08 21:52:28 +0000 | [diff] [blame] | 370 | return (((p32[0] ^ hash32_ptr(dev)) * hash_rnd[0]) + |
David S. Miller | 2c2aba6 | 2011-12-28 15:06:58 -0500 | [diff] [blame] | 371 | (p32[1] * hash_rnd[1]) + |
| 372 | (p32[2] * hash_rnd[2]) + |
| 373 | (p32[3] * hash_rnd[3])); |
| 374 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 375 | |
YOSHIFUJI Hideaki / 吉藤英明 | ac3175f | 2013-01-17 12:53:22 +0000 | [diff] [blame] | 376 | static inline struct neighbour *__ipv6_neigh_lookup_noref(struct net_device *dev, const void *pkey) |
David S. Miller | f83c779 | 2011-12-28 15:41:23 -0500 | [diff] [blame] | 377 | { |
Eric W. Biederman | 60395a2 | 2015-03-03 17:10:44 -0600 | [diff] [blame] | 378 | return ___neigh_lookup_noref(&nd_tbl, neigh_key_eq128, ndisc_hashfn, pkey, dev); |
YOSHIFUJI Hideaki / 吉藤英明 | ac3175f | 2013-01-17 12:53:22 +0000 | [diff] [blame] | 379 | } |
| 380 | |
| 381 | static inline struct neighbour *__ipv6_neigh_lookup(struct net_device *dev, const void *pkey) |
| 382 | { |
| 383 | struct neighbour *n; |
| 384 | |
| 385 | rcu_read_lock_bh(); |
| 386 | n = __ipv6_neigh_lookup_noref(dev, pkey); |
Reshetova, Elena | 9f23743 | 2017-06-30 13:07:55 +0300 | [diff] [blame] | 387 | if (n && !refcount_inc_not_zero(&n->refcnt)) |
YOSHIFUJI Hideaki / 吉藤英明 | ac3175f | 2013-01-17 12:53:22 +0000 | [diff] [blame] | 388 | n = NULL; |
David S. Miller | f83c779 | 2011-12-28 15:41:23 -0500 | [diff] [blame] | 389 | rcu_read_unlock_bh(); |
| 390 | |
| 391 | return n; |
| 392 | } |
| 393 | |
Julian Anastasov | 63fca65 | 2017-02-06 23:14:15 +0200 | [diff] [blame] | 394 | static inline void __ipv6_confirm_neigh(struct net_device *dev, |
| 395 | const void *pkey) |
| 396 | { |
| 397 | struct neighbour *n; |
| 398 | |
| 399 | rcu_read_lock_bh(); |
| 400 | n = __ipv6_neigh_lookup_noref(dev, pkey); |
| 401 | if (n) { |
| 402 | unsigned long now = jiffies; |
| 403 | |
| 404 | /* avoid dirtying neighbour */ |
| 405 | if (n->confirmed != now) |
| 406 | n->confirmed = now; |
| 407 | } |
| 408 | rcu_read_unlock_bh(); |
| 409 | } |
| 410 | |
Joe Perches | 3cc818a | 2013-09-21 10:22:47 -0700 | [diff] [blame] | 411 | int ndisc_init(void); |
| 412 | int ndisc_late_init(void); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 413 | |
Joe Perches | 3cc818a | 2013-09-21 10:22:47 -0700 | [diff] [blame] | 414 | void ndisc_late_cleanup(void); |
| 415 | void ndisc_cleanup(void); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 416 | |
Joe Perches | 3cc818a | 2013-09-21 10:22:47 -0700 | [diff] [blame] | 417 | int ndisc_rcv(struct sk_buff *skb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 418 | |
Jiri Benc | 38cf595 | 2015-09-22 18:57:13 +0200 | [diff] [blame] | 419 | void ndisc_send_ns(struct net_device *dev, const struct in6_addr *solicit, |
Erik Nordmark | adc176c | 2016-12-02 14:00:08 -0800 | [diff] [blame] | 420 | const struct in6_addr *daddr, const struct in6_addr *saddr, |
| 421 | u64 nonce); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 422 | |
Joe Perches | 3cc818a | 2013-09-21 10:22:47 -0700 | [diff] [blame] | 423 | void ndisc_send_rs(struct net_device *dev, |
| 424 | const struct in6_addr *saddr, const struct in6_addr *daddr); |
Jiri Benc | 38cf595 | 2015-09-22 18:57:13 +0200 | [diff] [blame] | 425 | void ndisc_send_na(struct net_device *dev, const struct in6_addr *daddr, |
Joe Perches | 3cc818a | 2013-09-21 10:22:47 -0700 | [diff] [blame] | 426 | const struct in6_addr *solicited_addr, |
| 427 | bool router, bool solicited, bool override, bool inc_opt); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 428 | |
Joe Perches | 3cc818a | 2013-09-21 10:22:47 -0700 | [diff] [blame] | 429 | void ndisc_send_redirect(struct sk_buff *skb, const struct in6_addr *target); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 430 | |
Joe Perches | 3cc818a | 2013-09-21 10:22:47 -0700 | [diff] [blame] | 431 | int ndisc_mc_map(const struct in6_addr *addr, char *buf, struct net_device *dev, |
| 432 | int dir); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 433 | |
Alexander Aring | f997c55 | 2016-06-15 21:20:23 +0200 | [diff] [blame] | 434 | void ndisc_update(const struct net_device *dev, struct neighbour *neigh, |
| 435 | const u8 *lladdr, u8 new, u32 flags, u8 icmp6_type, |
| 436 | struct ndisc_options *ndopts); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 437 | |
| 438 | /* |
| 439 | * IGMP |
| 440 | */ |
Joe Perches | 3cc818a | 2013-09-21 10:22:47 -0700 | [diff] [blame] | 441 | int igmp6_init(void); |
Vlad Yasevich | 382ed72 | 2017-03-28 14:49:16 -0400 | [diff] [blame] | 442 | int igmp6_late_init(void); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 443 | |
Joe Perches | 3cc818a | 2013-09-21 10:22:47 -0700 | [diff] [blame] | 444 | void igmp6_cleanup(void); |
Vlad Yasevich | 382ed72 | 2017-03-28 14:49:16 -0400 | [diff] [blame] | 445 | void igmp6_late_cleanup(void); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 446 | |
Joe Perches | 3cc818a | 2013-09-21 10:22:47 -0700 | [diff] [blame] | 447 | int igmp6_event_query(struct sk_buff *skb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 448 | |
Joe Perches | 3cc818a | 2013-09-21 10:22:47 -0700 | [diff] [blame] | 449 | int igmp6_event_report(struct sk_buff *skb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 450 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 451 | |
| 452 | #ifdef CONFIG_SYSCTL |
Joe Perches | 3cc818a | 2013-09-21 10:22:47 -0700 | [diff] [blame] | 453 | int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, |
| 454 | void __user *buffer, size_t *lenp, loff_t *ppos); |
Joe Perches | fedaf4f | 2013-06-13 19:37:54 -0700 | [diff] [blame] | 455 | int ndisc_ifinfo_sysctl_strategy(struct ctl_table *ctl, |
Alexey Dobriyan | f221e72 | 2008-10-15 22:04:23 -0700 | [diff] [blame] | 456 | void __user *oldval, size_t __user *oldlenp, |
YOSHIFUJI Hideaki | 0686caa | 2008-05-19 16:25:42 -0700 | [diff] [blame] | 457 | void __user *newval, size_t newlen); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 458 | #endif |
| 459 | |
Joe Perches | 3cc818a | 2013-09-21 10:22:47 -0700 | [diff] [blame] | 460 | void inet6_ifinfo_notify(int event, struct inet6_dev *idev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 461 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 462 | #endif |