2005-04-17 05:20:36 +07:00
|
|
|
#ifndef _IPV6_H
|
|
|
|
#define _IPV6_H
|
|
|
|
|
2012-10-13 16:46:48 +07:00
|
|
|
#include <uapi/linux/ipv6.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
#define ipv6_optlen(p) (((p)->hdrlen+1) << 3)
|
2013-12-04 00:39:29 +07:00
|
|
|
#define ipv6_authlen(p) (((p)->hdrlen+2) << 2)
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* This structure contains configuration options per IPv6 link.
|
|
|
|
*/
|
|
|
|
struct ipv6_devconf {
|
|
|
|
__s32 forwarding;
|
|
|
|
__s32 hop_limit;
|
|
|
|
__s32 mtu6;
|
|
|
|
__s32 accept_ra;
|
|
|
|
__s32 accept_redirects;
|
|
|
|
__s32 autoconf;
|
|
|
|
__s32 dad_transmits;
|
|
|
|
__s32 rtr_solicits;
|
|
|
|
__s32 rtr_solicit_interval;
|
|
|
|
__s32 rtr_solicit_delay;
|
|
|
|
__s32 force_mld_version;
|
2013-08-14 06:03:46 +07:00
|
|
|
__s32 mldv1_unsolicited_report_interval;
|
|
|
|
__s32 mldv2_unsolicited_report_interval;
|
2005-04-17 05:20:36 +07:00
|
|
|
__s32 use_tempaddr;
|
|
|
|
__s32 temp_valid_lft;
|
|
|
|
__s32 temp_prefered_lft;
|
|
|
|
__s32 regen_max_retry;
|
|
|
|
__s32 max_desync_factor;
|
|
|
|
__s32 max_addresses;
|
2006-03-21 07:55:08 +07:00
|
|
|
__s32 accept_ra_defrtr;
|
2006-03-21 07:55:26 +07:00
|
|
|
__s32 accept_ra_pinfo;
|
2006-03-21 08:05:30 +07:00
|
|
|
#ifdef CONFIG_IPV6_ROUTER_PREF
|
|
|
|
__s32 accept_ra_rtr_pref;
|
2006-03-21 08:05:47 +07:00
|
|
|
__s32 rtr_probe_interval;
|
2006-03-21 08:07:03 +07:00
|
|
|
#ifdef CONFIG_IPV6_ROUTE_INFO
|
|
|
|
__s32 accept_ra_rt_info_max_plen;
|
|
|
|
#endif
|
2006-03-21 08:05:30 +07:00
|
|
|
#endif
|
2006-09-23 04:43:49 +07:00
|
|
|
__s32 proxy_ndp;
|
2007-04-25 04:58:30 +07:00
|
|
|
__s32 accept_source_route;
|
2007-04-26 07:08:10 +07:00
|
|
|
#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
|
|
|
|
__s32 optimistic_dad;
|
2008-04-03 07:22:53 +07:00
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_IPV6_MROUTE
|
|
|
|
__s32 mc_forwarding;
|
2007-04-26 07:08:10 +07:00
|
|
|
#endif
|
2008-06-28 12:17:11 +07:00
|
|
|
__s32 disable_ipv6;
|
2008-06-28 12:18:38 +07:00
|
|
|
__s32 accept_dad;
|
2009-10-02 18:39:15 +07:00
|
|
|
__s32 force_tllao;
|
2012-11-06 23:46:20 +07:00
|
|
|
__s32 ndisc_notify;
|
2013-08-27 06:36:51 +07:00
|
|
|
__s32 suppress_frag_ndisc;
|
2005-04-17 05:20:36 +07:00
|
|
|
void *sysctl;
|
|
|
|
};
|
2009-06-01 17:07:33 +07:00
|
|
|
|
|
|
|
struct ipv6_params {
|
|
|
|
__s32 disable_ipv6;
|
|
|
|
__s32 autoconf;
|
|
|
|
};
|
|
|
|
extern struct ipv6_params ipv6_defaults;
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/icmpv6.h>
|
|
|
|
#include <linux/tcp.h>
|
|
|
|
#include <linux/udp.h>
|
|
|
|
|
2005-12-27 11:43:12 +07:00
|
|
|
#include <net/inet_sock.h>
|
|
|
|
|
2007-04-26 07:54:47 +07:00
|
|
|
static inline struct ipv6hdr *ipv6_hdr(const struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
return (struct ipv6hdr *)skb_network_header(skb);
|
|
|
|
}
|
|
|
|
|
2012-12-07 21:14:14 +07:00
|
|
|
static inline struct ipv6hdr *inner_ipv6_hdr(const struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
return (struct ipv6hdr *)skb_inner_network_header(skb);
|
|
|
|
}
|
|
|
|
|
2007-04-11 11:06:25 +07:00
|
|
|
static inline struct ipv6hdr *ipipv6_hdr(const struct sk_buff *skb)
|
|
|
|
{
|
2007-04-26 08:04:18 +07:00
|
|
|
return (struct ipv6hdr *)skb_transport_header(skb);
|
2007-04-11 11:06:25 +07:00
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
This structure contains results of exthdrs parsing
|
|
|
|
as offsets from skb->nh.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct inet6_skb_parm {
|
|
|
|
int iif;
|
2013-01-13 12:02:45 +07:00
|
|
|
__be16 ra;
|
2005-04-17 05:20:36 +07:00
|
|
|
__u16 hop;
|
|
|
|
__u16 dst0;
|
|
|
|
__u16 srcrt;
|
|
|
|
__u16 dst1;
|
[IPV6]: Support several new sockopt / ancillary data in Advanced API (RFC3542).
Support several new socket options / ancillary data:
IPV6_RECVPKTINFO, IPV6_PKTINFO,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS,
IPV6_RECVDSTOPTS, IPV6_DSTOPTS, IPV6_RTHDRDSTOPTS,
IPV6_RECVRTHDR, IPV6_RTHDR,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS
Old semantics are preserved as IPV6_2292xxxx so that
we can maintain backward compatibility.
Signed-off-by: YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
2005-09-08 07:59:17 +07:00
|
|
|
__u16 lastopt;
|
2010-07-20 12:01:26 +07:00
|
|
|
__u16 nhoff;
|
2006-01-07 14:04:54 +07:00
|
|
|
__u16 flags;
|
2007-06-27 13:56:32 +07:00
|
|
|
#if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
|
2006-08-24 09:25:55 +07:00
|
|
|
__u16 dsthao;
|
|
|
|
#endif
|
netfilter: nf_conntrack_ipv6: improve fragmentation handling
The IPv6 conntrack fragmentation currently has a couple of shortcomings.
Fragmentes are collected in PREROUTING/OUTPUT, are defragmented, the
defragmented packet is then passed to conntrack, the resulting conntrack
information is attached to each original fragment and the fragments then
continue their way through the stack.
Helper invocation occurs in the POSTROUTING hook, at which point only
the original fragments are available. The result of this is that
fragmented packets are never passed to helpers.
This patch improves the situation in the following way:
- If a reassembled packet belongs to a connection that has a helper
assigned, the reassembled packet is passed through the stack instead
of the original fragments.
- During defragmentation, the largest received fragment size is stored.
On output, the packet is refragmented if required. If the largest
received fragment size exceeds the outgoing MTU, a "packet too big"
message is generated, thus behaving as if the original fragments
were passed through the stack from an outside point of view.
- The ipv6_helper() hook function can't receive fragments anymore for
connections using a helper, so it is switched to use ipv6_skip_exthdr()
instead of the netfilter specific nf_ct_ipv6_skip_exthdr() and the
reassembled packets are passed to connection tracking helpers.
The result of this is that we can properly track fragmented packets, but
still generate ICMPv6 Packet too big messages if we would have before.
This patch is also required as a precondition for IPv6 NAT, where NAT
helpers might enlarge packets up to a point that they require
fragmentation. In that case we can't generate Packet too big messages
since the proper MTU can't be calculated in all cases (f.i. when
changing textual representation of a variable amount of addresses),
so the packet is transparently fragmented iff the original packet or
fragments would have fit the outgoing MTU.
IPVS parts by Jesper Dangaard Brouer <brouer@redhat.com>.
Signed-off-by: Patrick McHardy <kaber@trash.net>
2012-08-27 00:13:58 +07:00
|
|
|
__u16 frag_max_size;
|
2006-01-07 14:04:54 +07:00
|
|
|
|
|
|
|
#define IP6SKB_XFRM_TRANSFORMED 1
|
2008-04-03 07:22:53 +07:00
|
|
|
#define IP6SKB_FORWARDED 2
|
2010-04-13 20:32:16 +07:00
|
|
|
#define IP6SKB_REROUTED 4
|
2013-01-13 12:02:45 +07:00
|
|
|
#define IP6SKB_ROUTERALERT 8
|
2013-08-16 18:30:07 +07:00
|
|
|
#define IP6SKB_FRAGMENTED 16
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
#define IP6CB(skb) ((struct inet6_skb_parm*)((skb)->cb))
|
2010-04-23 18:26:09 +07:00
|
|
|
#define IP6CBMTU(skb) ((struct ip6_mtuinfo *)((skb)->cb))
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-08-12 19:19:38 +07:00
|
|
|
static inline int inet6_iif(const struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
return IP6CB(skb)->iif;
|
|
|
|
}
|
|
|
|
|
2005-12-14 14:15:40 +07:00
|
|
|
struct tcp6_request_sock {
|
|
|
|
struct tcp_request_sock tcp6rsk_tcp;
|
|
|
|
};
|
[NET] Generalise TCP's struct open_request minisock infrastructure
Kept this first changeset minimal, without changing existing names to
ease peer review.
Basicaly tcp_openreq_alloc now receives the or_calltable, that in turn
has two new members:
->slab, that replaces tcp_openreq_cachep
->obj_size, to inform the size of the openreq descendant for
a specific protocol
The protocol specific fields in struct open_request were moved to a
class hierarchy, with the things that are common to all connection
oriented PF_INET protocols in struct inet_request_sock, the TCP ones
in tcp_request_sock, that is an inet_request_sock, that is an
open_request.
I.e. this uses the same approach used for the struct sock class
hierarchy, with sk_prot indicating if the protocol wants to use the
open_request infrastructure by filling in sk_prot->rsk_prot with an
or_calltable.
Results? Performance is improved and TCP v4 now uses only 64 bytes per
open request minisock, down from 96 without this patch :-)
Next changeset will rename some of the structs, fields and functions
mentioned above, struct or_calltable is way unclear, better name it
struct request_sock_ops, s/struct open_request/struct request_sock/g,
etc.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-06-19 12:46:52 +07:00
|
|
|
|
2007-07-31 07:05:49 +07:00
|
|
|
struct ipv6_mc_socklist;
|
|
|
|
struct ipv6_ac_socklist;
|
|
|
|
struct ipv6_fl_socklist;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/**
|
|
|
|
* struct ipv6_pinfo - ipv6 private area
|
|
|
|
*
|
|
|
|
* In the struct sock hierarchy (tcp6_sock, upd6_sock, etc)
|
|
|
|
* this _must_ be the last member, so that inet6_sk_generic
|
|
|
|
* is able to calculate its offset from the base struct sock
|
|
|
|
* by using the struct proto->slab_obj_size member. -acme
|
|
|
|
*/
|
|
|
|
struct ipv6_pinfo {
|
|
|
|
struct in6_addr saddr;
|
2008-12-16 17:06:23 +07:00
|
|
|
struct in6_pktinfo sticky_pktinfo;
|
2012-07-18 04:38:04 +07:00
|
|
|
const struct in6_addr *daddr_cache;
|
2006-08-30 07:15:09 +07:00
|
|
|
#ifdef CONFIG_IPV6_SUBTREES
|
2012-07-18 04:38:04 +07:00
|
|
|
const struct in6_addr *saddr_cache;
|
2006-08-30 07:15:09 +07:00
|
|
|
#endif
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-11-08 15:25:17 +07:00
|
|
|
__be32 flow_label;
|
2005-04-17 05:20:36 +07:00
|
|
|
__u32 frag_size;
|
2008-03-10 21:56:55 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Packed in 16bits.
|
|
|
|
* Omit one shift by by putting the signed field at MSB.
|
|
|
|
*/
|
|
|
|
#if defined(__BIG_ENDIAN_BITFIELD)
|
|
|
|
__s16 hop_limit:9;
|
|
|
|
__u16 __unused_1:7;
|
|
|
|
#else
|
|
|
|
__u16 __unused_1:7;
|
|
|
|
__s16 hop_limit:9;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(__BIG_ENDIAN_BITFIELD)
|
|
|
|
/* Packed in 16bits. */
|
|
|
|
__s16 mcast_hops:9;
|
|
|
|
__u16 __unused_2:6,
|
|
|
|
mc_loop:1;
|
|
|
|
#else
|
|
|
|
__u16 mc_loop:1,
|
|
|
|
__unused_2:6;
|
|
|
|
__s16 mcast_hops:9;
|
|
|
|
#endif
|
2012-02-08 16:11:08 +07:00
|
|
|
int ucast_oif;
|
2005-04-17 05:20:36 +07:00
|
|
|
int mcast_oif;
|
|
|
|
|
|
|
|
/* pktoption flags */
|
|
|
|
union {
|
|
|
|
struct {
|
2007-05-23 11:28:48 +07:00
|
|
|
__u16 srcrt:1,
|
|
|
|
osrcrt:1,
|
2005-04-17 05:20:36 +07:00
|
|
|
rxinfo:1,
|
[IPV6]: Support several new sockopt / ancillary data in Advanced API (RFC3542).
Support several new socket options / ancillary data:
IPV6_RECVPKTINFO, IPV6_PKTINFO,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS,
IPV6_RECVDSTOPTS, IPV6_DSTOPTS, IPV6_RTHDRDSTOPTS,
IPV6_RECVRTHDR, IPV6_RTHDR,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS
Old semantics are preserved as IPV6_2292xxxx so that
we can maintain backward compatibility.
Signed-off-by: YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
2005-09-08 07:59:17 +07:00
|
|
|
rxoinfo:1,
|
2005-04-17 05:20:36 +07:00
|
|
|
rxhlim:1,
|
[IPV6]: Support several new sockopt / ancillary data in Advanced API (RFC3542).
Support several new socket options / ancillary data:
IPV6_RECVPKTINFO, IPV6_PKTINFO,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS,
IPV6_RECVDSTOPTS, IPV6_DSTOPTS, IPV6_RTHDRDSTOPTS,
IPV6_RECVRTHDR, IPV6_RTHDR,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS
Old semantics are preserved as IPV6_2292xxxx so that
we can maintain backward compatibility.
Signed-off-by: YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
2005-09-08 07:59:17 +07:00
|
|
|
rxohlim:1,
|
2005-04-17 05:20:36 +07:00
|
|
|
hopopts:1,
|
[IPV6]: Support several new sockopt / ancillary data in Advanced API (RFC3542).
Support several new socket options / ancillary data:
IPV6_RECVPKTINFO, IPV6_PKTINFO,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS,
IPV6_RECVDSTOPTS, IPV6_DSTOPTS, IPV6_RTHDRDSTOPTS,
IPV6_RECVRTHDR, IPV6_RTHDR,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS
Old semantics are preserved as IPV6_2292xxxx so that
we can maintain backward compatibility.
Signed-off-by: YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
2005-09-08 07:59:17 +07:00
|
|
|
ohopopts:1,
|
2005-04-17 05:20:36 +07:00
|
|
|
dstopts:1,
|
[IPV6]: Support several new sockopt / ancillary data in Advanced API (RFC3542).
Support several new socket options / ancillary data:
IPV6_RECVPKTINFO, IPV6_PKTINFO,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS,
IPV6_RECVDSTOPTS, IPV6_DSTOPTS, IPV6_RTHDRDSTOPTS,
IPV6_RECVRTHDR, IPV6_RTHDR,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS
Old semantics are preserved as IPV6_2292xxxx so that
we can maintain backward compatibility.
Signed-off-by: YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
2005-09-08 07:59:17 +07:00
|
|
|
odstopts:1,
|
2005-09-08 08:19:03 +07:00
|
|
|
rxflow:1,
|
2010-04-23 18:26:07 +07:00
|
|
|
rxtclass:1,
|
2010-10-21 21:08:28 +07:00
|
|
|
rxpmtu:1,
|
|
|
|
rxorigdstaddr:1;
|
|
|
|
/* 2 bits hole */
|
2005-04-17 05:20:36 +07:00
|
|
|
} bits;
|
[IPV6]: Support several new sockopt / ancillary data in Advanced API (RFC3542).
Support several new socket options / ancillary data:
IPV6_RECVPKTINFO, IPV6_PKTINFO,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS,
IPV6_RECVDSTOPTS, IPV6_DSTOPTS, IPV6_RTHDRDSTOPTS,
IPV6_RECVRTHDR, IPV6_RTHDR,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS
Old semantics are preserved as IPV6_2292xxxx so that
we can maintain backward compatibility.
Signed-off-by: YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
2005-09-08 07:59:17 +07:00
|
|
|
__u16 all;
|
2005-04-17 05:20:36 +07:00
|
|
|
} rxopt;
|
|
|
|
|
|
|
|
/* sockopt flags */
|
2010-04-23 18:26:07 +07:00
|
|
|
__u16 recverr:1,
|
2005-04-17 05:20:36 +07:00
|
|
|
sndflow:1,
|
2014-01-17 23:15:03 +07:00
|
|
|
repflow:1,
|
2013-12-15 09:41:14 +07:00
|
|
|
pmtudisc:3,
|
2008-03-25 07:37:42 +07:00
|
|
|
ipv6only:1,
|
2010-04-23 18:26:07 +07:00
|
|
|
srcprefs:3, /* 001: prefer temporary address
|
2008-03-25 07:37:42 +07:00
|
|
|
* 010: prefer public address
|
|
|
|
* 100: prefer care-of address
|
|
|
|
*/
|
2010-04-23 18:26:07 +07:00
|
|
|
dontfrag:1;
|
IPv6: Generic TTL Security Mechanism (final version)
This patch adds IPv6 support for RFC5082 Generalized TTL Security Mechanism.
Not to users of mapped address; the IPV6 and IPV4 socket options are seperate.
The server does have to deal with both IPv4 and IPv6 socket options
and the client has to handle the different for each family.
On client:
int ttl = 255;
getaddrinfo(argv[1], argv[2], &hint, &result);
for (rp = result; rp != NULL; rp = rp->ai_next) {
s = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
if (s < 0) continue;
if (rp->ai_family == AF_INET) {
setsockopt(s, IPPROTO_IP, IP_TTL, &ttl, sizeof(ttl));
} else if (rp->ai_family == AF_INET6) {
setsockopt(s, IPPROTO_IPV6, IPV6_UNICAST_HOPS,
&ttl, sizeof(ttl)))
}
if (connect(s, rp->ai_addr, rp->ai_addrlen) == 0) {
...
On server:
int minttl = 255 - maxhops;
getaddrinfo(NULL, port, &hints, &result);
for (rp = result; rp != NULL; rp = rp->ai_next) {
s = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
if (s < 0) continue;
if (rp->ai_family == AF_INET6)
setsockopt(s, IPPROTO_IPV6, IPV6_MINHOPCOUNT,
&minttl, sizeof(minttl));
setsockopt(s, IPPROTO_IP, IP_MINTTL, &minttl, sizeof(minttl));
if (bind(s, rp->ai_addr, rp->ai_addrlen) == 0)
break
...
Signed-off-by: Stephen Hemminger <shemminger@vyatta.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-23 05:24:53 +07:00
|
|
|
__u8 min_hopcount;
|
2005-09-08 08:19:03 +07:00
|
|
|
__u8 tclass;
|
2013-12-08 21:46:57 +07:00
|
|
|
__be32 rcv_flowinfo;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
__u32 dst_cookie;
|
2012-08-06 12:09:33 +07:00
|
|
|
__u32 rx_dst_cookie;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-11-23 20:12:15 +07:00
|
|
|
struct ipv6_mc_socklist __rcu *ipv6_mc_list;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct ipv6_ac_socklist *ipv6_ac_list;
|
2013-01-30 16:27:52 +07:00
|
|
|
struct ipv6_fl_socklist __rcu *ipv6_fl_list;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
struct ipv6_txoptions *opt;
|
|
|
|
struct sk_buff *pktoptions;
|
2010-04-23 18:26:09 +07:00
|
|
|
struct sk_buff *rxpmtu;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct {
|
|
|
|
struct ipv6_txoptions *opt;
|
2008-03-10 15:41:33 +07:00
|
|
|
u8 hop_limit;
|
|
|
|
u8 tclass;
|
2005-04-17 05:20:36 +07:00
|
|
|
} cork;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* WARNING: don't change the layout of the members in {raw,udp,tcp}6_sock! */
|
|
|
|
struct raw6_sock {
|
|
|
|
/* inet_sock has to be the first member of raw6_sock */
|
|
|
|
struct inet_sock inet;
|
|
|
|
__u32 checksum; /* perform checksum */
|
|
|
|
__u32 offset; /* checksum offset */
|
|
|
|
struct icmp6_filter filter;
|
ipv6: ip6mr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT6_TABLE. The table number is
stored in the raw socket data and affects all following ip6mr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT6_TABLE_DFLT)
is created with a default routing rule pointing to it. Newly created pim6reg
devices have the table number appended ("pim6regX"), with the exception of
devices created in the default table, which are named just "pim6reg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, SOL_IPV6, MRT6_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip -6 mrule add iif eth0 lookup 123
# ip -6 mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
2010-05-11 19:40:55 +07:00
|
|
|
__u32 ip6mr_table;
|
2005-04-17 05:20:36 +07:00
|
|
|
/* ipv6_pinfo has to be the last member of raw6_sock, see inet6_sk_generic */
|
|
|
|
struct ipv6_pinfo inet6;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct udp6_sock {
|
|
|
|
struct udp_sock udp;
|
|
|
|
/* ipv6_pinfo has to be the last member of udp6_sock, see inet6_sk_generic */
|
|
|
|
struct ipv6_pinfo inet6;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct tcp6_sock {
|
|
|
|
struct tcp_sock tcp;
|
|
|
|
/* ipv6_pinfo has to be the last member of tcp6_sock, see inet6_sk_generic */
|
|
|
|
struct ipv6_pinfo inet6;
|
|
|
|
};
|
|
|
|
|
2005-12-14 14:22:54 +07:00
|
|
|
extern int inet6_sk_rebuild_header(struct sock *sk);
|
|
|
|
|
2012-07-11 16:39:24 +07:00
|
|
|
struct tcp6_timewait_sock {
|
|
|
|
struct tcp_timewait_sock tcp6tw_tcp;
|
|
|
|
};
|
|
|
|
|
2011-12-10 16:48:31 +07:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
2005-04-17 05:20:36 +07:00
|
|
|
static inline struct ipv6_pinfo * inet6_sk(const struct sock *__sk)
|
|
|
|
{
|
|
|
|
return inet_sk(__sk)->pinet6;
|
|
|
|
}
|
|
|
|
|
2005-12-14 14:15:40 +07:00
|
|
|
static inline struct request_sock *inet6_reqsk_alloc(struct request_sock_ops *ops)
|
|
|
|
{
|
|
|
|
struct request_sock *req = reqsk_alloc(ops);
|
|
|
|
|
2013-10-10 05:21:29 +07:00
|
|
|
if (req)
|
|
|
|
inet_rsk(req)->pktopts = NULL;
|
2005-12-14 14:15:40 +07:00
|
|
|
|
|
|
|
return req;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
static inline struct raw6_sock *raw6_sk(const struct sock *sk)
|
|
|
|
{
|
|
|
|
return (struct raw6_sock *)sk;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void inet_sk_copy_descendant(struct sock *sk_to,
|
|
|
|
const struct sock *sk_from)
|
|
|
|
{
|
|
|
|
int ancestor_size = sizeof(struct inet_sock);
|
|
|
|
|
|
|
|
if (sk_from->sk_family == PF_INET6)
|
|
|
|
ancestor_size += sizeof(struct ipv6_pinfo);
|
|
|
|
|
|
|
|
__inet_sk_copy_descendant(sk_to, sk_from, ancestor_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define __ipv6_only_sock(sk) (inet6_sk(sk)->ipv6only)
|
|
|
|
#define ipv6_only_sock(sk) ((sk)->sk_family == PF_INET6 && __ipv6_only_sock(sk))
|
2014-01-20 09:43:08 +07:00
|
|
|
#define ipv6_sk_rxinfo(sk) ((sk)->sk_family == PF_INET6 && \
|
|
|
|
inet6_sk(sk)->rxopt.bits.rxinfo)
|
2005-08-10 10:09:30 +07:00
|
|
|
|
ipv6: make lookups simpler and faster
TCP listener refactoring, part 4 :
To speed up inet lookups, we moved IPv4 addresses from inet to struct
sock_common
Now is time to do the same for IPv6, because it permits us to have fast
lookups for all kind of sockets, including upcoming SYN_RECV.
Getting IPv6 addresses in TCP lookups currently requires two extra cache
lines, plus a dereference (and memory stall).
inet6_sk(sk) does the dereference of inet_sk(__sk)->pinet6
This patch is way bigger than its IPv4 counter part, because for IPv4,
we could add aliases (inet_daddr, inet_rcv_saddr), while on IPv6,
it's not doable easily.
inet6_sk(sk)->daddr becomes sk->sk_v6_daddr
inet6_sk(sk)->rcv_saddr becomes sk->sk_v6_rcv_saddr
And timewait socket also have tw->tw_v6_daddr & tw->tw_v6_rcv_saddr
at the same offset.
We get rid of INET6_TW_MATCH() as INET6_MATCH() is now the generic
macro.
Signed-off-by: Eric Dumazet <edumazet@google.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-10-04 05:42:29 +07:00
|
|
|
static inline const struct in6_addr *inet6_rcv_saddr(const struct sock *sk)
|
2005-08-10 10:09:30 +07:00
|
|
|
{
|
ipv6: make lookups simpler and faster
TCP listener refactoring, part 4 :
To speed up inet lookups, we moved IPv4 addresses from inet to struct
sock_common
Now is time to do the same for IPv6, because it permits us to have fast
lookups for all kind of sockets, including upcoming SYN_RECV.
Getting IPv6 addresses in TCP lookups currently requires two extra cache
lines, plus a dereference (and memory stall).
inet6_sk(sk) does the dereference of inet_sk(__sk)->pinet6
This patch is way bigger than its IPv4 counter part, because for IPv4,
we could add aliases (inet_daddr, inet_rcv_saddr), while on IPv6,
it's not doable easily.
inet6_sk(sk)->daddr becomes sk->sk_v6_daddr
inet6_sk(sk)->rcv_saddr becomes sk->sk_v6_rcv_saddr
And timewait socket also have tw->tw_v6_daddr & tw->tw_v6_rcv_saddr
at the same offset.
We get rid of INET6_TW_MATCH() as INET6_MATCH() is now the generic
macro.
Signed-off-by: Eric Dumazet <edumazet@google.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-10-04 05:42:29 +07:00
|
|
|
if (sk->sk_family == AF_INET6)
|
|
|
|
return &sk->sk_v6_rcv_saddr;
|
|
|
|
return NULL;
|
2005-08-10 10:09:30 +07:00
|
|
|
}
|
|
|
|
|
2005-08-10 10:10:42 +07:00
|
|
|
static inline int inet_v6_ipv6only(const struct sock *sk)
|
2005-08-10 10:09:30 +07:00
|
|
|
{
|
|
|
|
return likely(sk->sk_state != TCP_TIME_WAIT) ?
|
2005-08-10 10:11:08 +07:00
|
|
|
ipv6_only_sock(sk) : inet_twsk(sk)->tw_ipv6only;
|
2005-08-10 10:09:30 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
#else
|
|
|
|
#define __ipv6_only_sock(sk) 0
|
|
|
|
#define ipv6_only_sock(sk) 0
|
2014-01-20 09:43:08 +07:00
|
|
|
#define ipv6_sk_rxinfo(sk) 0
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
static inline struct ipv6_pinfo * inet6_sk(const struct sock *__sk)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2005-12-14 14:15:40 +07:00
|
|
|
static inline struct inet6_request_sock *
|
|
|
|
inet6_rsk(const struct request_sock *rsk)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
static inline struct raw6_sock *raw6_sk(const struct sock *sk)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2005-12-14 14:23:09 +07:00
|
|
|
#define inet6_rcv_saddr(__sk) NULL
|
2005-08-10 10:09:30 +07:00
|
|
|
#define tcp_twsk_ipv6only(__sk) 0
|
2005-08-10 10:10:42 +07:00
|
|
|
#define inet_v6_ipv6only(__sk) 0
|
2011-12-10 16:48:31 +07:00
|
|
|
#endif /* IS_ENABLED(CONFIG_IPV6) */
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2012-11-30 16:49:27 +07:00
|
|
|
#define INET6_MATCH(__sk, __net, __saddr, __daddr, __ports, __dif) \
|
inet: consolidate INET_TW_MATCH
TCP listener refactoring, part 2 :
We can use a generic lookup, sockets being in whatever state, if
we are sure all relevant fields are at the same place in all socket
types (ESTABLISH, TIME_WAIT, SYN_RECV)
This patch removes these macros :
inet_addrpair, inet_addrpair, tw_addrpair, tw_portpair
And adds :
sk_portpair, sk_addrpair, sk_daddr, sk_rcv_saddr
Then, INET_TW_MATCH() is really the same than INET_MATCH()
Signed-off-by: Eric Dumazet <edumazet@google.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-10-02 18:29:50 +07:00
|
|
|
(((__sk)->sk_portpair == (__ports)) && \
|
2012-11-30 16:49:27 +07:00
|
|
|
((__sk)->sk_family == AF_INET6) && \
|
ipv6: make lookups simpler and faster
TCP listener refactoring, part 4 :
To speed up inet lookups, we moved IPv4 addresses from inet to struct
sock_common
Now is time to do the same for IPv6, because it permits us to have fast
lookups for all kind of sockets, including upcoming SYN_RECV.
Getting IPv6 addresses in TCP lookups currently requires two extra cache
lines, plus a dereference (and memory stall).
inet6_sk(sk) does the dereference of inet_sk(__sk)->pinet6
This patch is way bigger than its IPv4 counter part, because for IPv4,
we could add aliases (inet_daddr, inet_rcv_saddr), while on IPv6,
it's not doable easily.
inet6_sk(sk)->daddr becomes sk->sk_v6_daddr
inet6_sk(sk)->rcv_saddr becomes sk->sk_v6_rcv_saddr
And timewait socket also have tw->tw_v6_daddr & tw->tw_v6_rcv_saddr
at the same offset.
We get rid of INET6_TW_MATCH() as INET6_MATCH() is now the generic
macro.
Signed-off-by: Eric Dumazet <edumazet@google.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-10-04 05:42:29 +07:00
|
|
|
ipv6_addr_equal(&(__sk)->sk_v6_daddr, (__saddr)) && \
|
|
|
|
ipv6_addr_equal(&(__sk)->sk_v6_rcv_saddr, (__daddr)) && \
|
2012-11-30 16:49:27 +07:00
|
|
|
(!(__sk)->sk_bound_dev_if || \
|
|
|
|
((__sk)->sk_bound_dev_if == (__dif))) && \
|
|
|
|
net_eq(sock_net(__sk), (__net)))
|
|
|
|
|
2005-08-10 10:09:30 +07:00
|
|
|
#endif /* _IPV6_H */
|