2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* TCP over IPv6
|
2007-02-09 07:24:49 -07:00
|
|
|
* Linux INET6 implementation
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Authors:
|
2007-02-09 07:24:49 -07:00
|
|
|
* Pedro Roque <roque@di.fc.ul.pt>
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2007-02-09 07:24:49 -07:00
|
|
|
* Based on:
|
2005-04-16 16:20:36 -06:00
|
|
|
* linux/net/ipv4/tcp.c
|
|
|
|
* linux/net/ipv4/tcp_input.c
|
|
|
|
* linux/net/ipv4/tcp_output.c
|
|
|
|
*
|
|
|
|
* Fixes:
|
|
|
|
* Hideaki YOSHIFUJI : sin6_scope_id support
|
|
|
|
* YOSHIFUJI Hideaki @USAGI and: Support IPV6_V6ONLY socket option, which
|
|
|
|
* Alexey Kuznetsov allow both IPv4 and IPv6 sockets to bind
|
|
|
|
* a single port at the same time.
|
|
|
|
* YOSHIFUJI Hideaki @USAGI: convert /proc/net/tcp6 to seq_file.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version
|
|
|
|
* 2 of the License, or (at your option) any later version.
|
|
|
|
*/
|
|
|
|
|
2008-12-30 00:04:08 -07:00
|
|
|
#include <linux/bottom_half.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/socket.h>
|
|
|
|
#include <linux/sockios.h>
|
|
|
|
#include <linux/net.h>
|
|
|
|
#include <linux/jiffies.h>
|
|
|
|
#include <linux/in.h>
|
|
|
|
#include <linux/in6.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/jhash.h>
|
|
|
|
#include <linux/ipsec.h>
|
|
|
|
#include <linux/times.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2014-03-28 19:27:29 -06:00
|
|
|
#include <linux/uaccess.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/ipv6.h>
|
|
|
|
#include <linux/icmpv6.h>
|
|
|
|
#include <linux/random.h>
|
|
|
|
|
|
|
|
#include <net/tcp.h>
|
|
|
|
#include <net/ndisc.h>
|
2005-08-12 06:26:18 -06:00
|
|
|
#include <net/inet6_hashtables.h>
|
2005-12-14 00:15:24 -07:00
|
|
|
#include <net/inet6_connection_sock.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <net/ipv6.h>
|
|
|
|
#include <net/transp_v6.h>
|
|
|
|
#include <net/addrconf.h>
|
|
|
|
#include <net/ip6_route.h>
|
|
|
|
#include <net/ip6_checksum.h>
|
|
|
|
#include <net/inet_ecn.h>
|
|
|
|
#include <net/protocol.h>
|
|
|
|
#include <net/xfrm.h>
|
|
|
|
#include <net/snmp.h>
|
|
|
|
#include <net/dsfield.h>
|
2005-12-14 00:25:19 -07:00
|
|
|
#include <net/timewait_sock.h>
|
2007-10-26 23:53:14 -06:00
|
|
|
#include <net/netdma.h>
|
2008-04-03 15:22:32 -06:00
|
|
|
#include <net/inet_common.h>
|
2011-08-03 21:50:44 -06:00
|
|
|
#include <net/secure_seq.h>
|
2011-12-11 14:47:04 -07:00
|
|
|
#include <net/tcp_memcontrol.h>
|
2013-07-10 08:13:17 -06:00
|
|
|
#include <net/busy_poll.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#include <linux/proc_fs.h>
|
|
|
|
#include <linux/seq_file.h>
|
|
|
|
|
2006-11-14 20:07:45 -07:00
|
|
|
#include <linux/crypto.h>
|
|
|
|
#include <linux/scatterlist.h>
|
|
|
|
|
|
|
|
static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb);
|
2008-08-07 00:50:04 -06:00
|
|
|
static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
|
|
|
|
struct request_sock *req);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb);
|
|
|
|
|
2009-09-01 13:25:04 -06:00
|
|
|
static const struct inet_connection_sock_af_ops ipv6_mapped;
|
|
|
|
static const struct inet_connection_sock_af_ops ipv6_specific;
|
2006-11-14 20:53:22 -07:00
|
|
|
#ifdef CONFIG_TCP_MD5SIG
|
2009-09-01 13:25:03 -06:00
|
|
|
static const struct tcp_sock_af_ops tcp_sock_ipv6_specific;
|
|
|
|
static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific;
|
2008-04-17 21:45:16 -06:00
|
|
|
#else
|
|
|
|
static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
|
2011-04-21 22:53:02 -06:00
|
|
|
const struct in6_addr *addr)
|
2008-04-17 21:45:16 -06:00
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
2006-11-14 20:53:22 -07:00
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-08-18 21:30:38 -06:00
|
|
|
static void inet6_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct dst_entry *dst = skb_dst(skb);
|
|
|
|
const struct rt6_info *rt = (const struct rt6_info *)dst;
|
|
|
|
|
|
|
|
dst_hold(dst);
|
|
|
|
sk->sk_rx_dst = dst;
|
|
|
|
inet_sk(sk)->rx_dst_ifindex = skb->skb_iif;
|
|
|
|
if (rt->rt6i_node)
|
|
|
|
inet6_sk(sk)->rx_dst_cookie = rt->rt6i_node->fn_sernum;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static void tcp_v6_hash(struct sock *sk)
|
|
|
|
{
|
|
|
|
if (sk->sk_state != TCP_CLOSE) {
|
2005-12-14 00:15:52 -07:00
|
|
|
if (inet_csk(sk)->icsk_af_ops == &ipv6_mapped) {
|
2005-04-16 16:20:36 -06:00
|
|
|
tcp_prot.hash(sk);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
local_bh_disable();
|
2009-12-03 20:46:54 -07:00
|
|
|
__inet6_hash(sk, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
local_bh_enable();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-21 03:22:42 -06:00
|
|
|
static __u32 tcp_v6_init_sequence(const struct sk_buff *skb)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-04-25 18:54:47 -06:00
|
|
|
return secure_tcpv6_sequence_number(ipv6_hdr(skb)->daddr.s6_addr32,
|
|
|
|
ipv6_hdr(skb)->saddr.s6_addr32,
|
2007-04-10 22:04:22 -06:00
|
|
|
tcp_hdr(skb)->dest,
|
|
|
|
tcp_hdr(skb)->source);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-02-09 07:24:49 -07:00
|
|
|
static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
|
2005-04-16 16:20:36 -06:00
|
|
|
int addr_len)
|
|
|
|
{
|
|
|
|
struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
|
2007-02-09 07:24:49 -07:00
|
|
|
struct inet_sock *inet = inet_sk(sk);
|
2005-12-14 00:26:10 -07:00
|
|
|
struct inet_connection_sock *icsk = inet_csk(sk);
|
2005-04-16 16:20:36 -06:00
|
|
|
struct ipv6_pinfo *np = inet6_sk(sk);
|
|
|
|
struct tcp_sock *tp = tcp_sk(sk);
|
2010-06-01 15:35:01 -06:00
|
|
|
struct in6_addr *saddr = NULL, *final_p, final;
|
2010-12-02 13:14:29 -07:00
|
|
|
struct rt6_info *rt;
|
2011-03-12 14:22:43 -07:00
|
|
|
struct flowi6 fl6;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct dst_entry *dst;
|
|
|
|
int addr_type;
|
|
|
|
int err;
|
|
|
|
|
2007-02-09 07:24:49 -07:00
|
|
|
if (addr_len < SIN6_LEN_RFC2133)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2007-02-09 07:24:49 -07:00
|
|
|
if (usin->sin6_family != AF_INET6)
|
2010-09-22 14:43:57 -06:00
|
|
|
return -EAFNOSUPPORT;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-03-12 14:22:43 -07:00
|
|
|
memset(&fl6, 0, sizeof(fl6));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (np->sndflow) {
|
2011-03-12 14:22:43 -07:00
|
|
|
fl6.flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK;
|
|
|
|
IP6_ECN_flow_init(fl6.flowlabel);
|
|
|
|
if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
|
2005-04-16 16:20:36 -06:00
|
|
|
struct ip6_flowlabel *flowlabel;
|
2011-03-12 14:22:43 -07:00
|
|
|
flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (flowlabel == NULL)
|
|
|
|
return -EINVAL;
|
|
|
|
fl6_sock_release(flowlabel);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2007-02-09 07:24:49 -07:00
|
|
|
* connect() to INADDR_ANY means loopback (BSD'ism).
|
|
|
|
*/
|
|
|
|
|
2013-12-19 03:44:34 -07:00
|
|
|
if (ipv6_addr_any(&usin->sin6_addr))
|
2007-02-09 07:24:49 -07:00
|
|
|
usin->sin6_addr.s6_addr[15] = 0x1;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
addr_type = ipv6_addr_type(&usin->sin6_addr);
|
|
|
|
|
2013-12-19 03:44:34 -07:00
|
|
|
if (addr_type & IPV6_ADDR_MULTICAST)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENETUNREACH;
|
|
|
|
|
|
|
|
if (addr_type&IPV6_ADDR_LINKLOCAL) {
|
|
|
|
if (addr_len >= sizeof(struct sockaddr_in6) &&
|
|
|
|
usin->sin6_scope_id) {
|
|
|
|
/* If interface is set while binding, indices
|
|
|
|
* must coincide.
|
|
|
|
*/
|
|
|
|
if (sk->sk_bound_dev_if &&
|
|
|
|
sk->sk_bound_dev_if != usin->sin6_scope_id)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
sk->sk_bound_dev_if = usin->sin6_scope_id;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Connect to link-local address requires an interface */
|
|
|
|
if (!sk->sk_bound_dev_if)
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tp->rx_opt.ts_recent_stamp &&
|
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-03 16:42:29 -06:00
|
|
|
!ipv6_addr_equal(&sk->sk_v6_daddr, &usin->sin6_addr)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
tp->rx_opt.ts_recent = 0;
|
|
|
|
tp->rx_opt.ts_recent_stamp = 0;
|
|
|
|
tp->write_seq = 0;
|
|
|
|
}
|
|
|
|
|
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-03 16:42:29 -06:00
|
|
|
sk->sk_v6_daddr = usin->sin6_addr;
|
2011-03-12 14:22:43 -07:00
|
|
|
np->flow_label = fl6.flowlabel;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* TCP over IPv4
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (addr_type == IPV6_ADDR_MAPPED) {
|
2005-12-14 00:26:10 -07:00
|
|
|
u32 exthdrlen = icsk->icsk_ext_hdr_len;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct sockaddr_in sin;
|
|
|
|
|
|
|
|
SOCK_DEBUG(sk, "connect: ipv4 mapped\n");
|
|
|
|
|
|
|
|
if (__ipv6_only_sock(sk))
|
|
|
|
return -ENETUNREACH;
|
|
|
|
|
|
|
|
sin.sin_family = AF_INET;
|
|
|
|
sin.sin_port = usin->sin6_port;
|
|
|
|
sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
|
|
|
|
|
2005-12-14 00:26:10 -07:00
|
|
|
icsk->icsk_af_ops = &ipv6_mapped;
|
2005-04-16 16:20:36 -06:00
|
|
|
sk->sk_backlog_rcv = tcp_v4_do_rcv;
|
2006-11-14 20:07:45 -07:00
|
|
|
#ifdef CONFIG_TCP_MD5SIG
|
|
|
|
tp->af_specific = &tcp_sock_ipv6_mapped_specific;
|
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
err = tcp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
|
|
|
|
|
|
|
|
if (err) {
|
2005-12-14 00:26:10 -07:00
|
|
|
icsk->icsk_ext_hdr_len = exthdrlen;
|
|
|
|
icsk->icsk_af_ops = &ipv6_specific;
|
2005-04-16 16:20:36 -06:00
|
|
|
sk->sk_backlog_rcv = tcp_v6_do_rcv;
|
2006-11-14 20:07:45 -07:00
|
|
|
#ifdef CONFIG_TCP_MD5SIG
|
|
|
|
tp->af_specific = &tcp_sock_ipv6_specific;
|
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
goto failure;
|
|
|
|
} else {
|
2009-10-15 00:30:45 -06:00
|
|
|
ipv6_addr_set_v4mapped(inet->inet_saddr, &np->saddr);
|
|
|
|
ipv6_addr_set_v4mapped(inet->inet_rcv_saddr,
|
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-03 16:42:29 -06:00
|
|
|
&sk->sk_v6_rcv_saddr);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
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-03 16:42:29 -06:00
|
|
|
if (!ipv6_addr_any(&sk->sk_v6_rcv_saddr))
|
|
|
|
saddr = &sk->sk_v6_rcv_saddr;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-03-12 14:22:43 -07:00
|
|
|
fl6.flowi6_proto = IPPROTO_TCP;
|
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-03 16:42:29 -06:00
|
|
|
fl6.daddr = sk->sk_v6_daddr;
|
2011-11-20 20:39:03 -07:00
|
|
|
fl6.saddr = saddr ? *saddr : np->saddr;
|
2011-03-12 14:22:43 -07:00
|
|
|
fl6.flowi6_oif = sk->sk_bound_dev_if;
|
|
|
|
fl6.flowi6_mark = sk->sk_mark;
|
2011-03-12 14:36:19 -07:00
|
|
|
fl6.fl6_dport = usin->sin6_port;
|
|
|
|
fl6.fl6_sport = inet->inet_sport;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-03-12 14:22:43 -07:00
|
|
|
final_p = fl6_update_dst(&fl6, np->opt, &final);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-03-12 14:22:43 -07:00
|
|
|
security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
|
2006-08-05 00:12:42 -06:00
|
|
|
|
2013-08-28 00:04:14 -06:00
|
|
|
dst = ip6_dst_lookup_flow(sk, &fl6, final_p);
|
2011-03-01 14:19:07 -07:00
|
|
|
if (IS_ERR(dst)) {
|
|
|
|
err = PTR_ERR(dst);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto failure;
|
2007-05-24 19:17:54 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (saddr == NULL) {
|
2011-03-12 14:22:43 -07:00
|
|
|
saddr = &fl6.saddr;
|
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-03 16:42:29 -06:00
|
|
|
sk->sk_v6_rcv_saddr = *saddr;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* set the source address */
|
2011-11-20 20:39:03 -07:00
|
|
|
np->saddr = *saddr;
|
2009-10-15 00:30:45 -06:00
|
|
|
inet->inet_rcv_saddr = LOOPBACK4_IPV6;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-06-30 14:37:03 -06:00
|
|
|
sk->sk_gso_type = SKB_GSO_TCPV6;
|
2006-08-29 18:15:09 -06:00
|
|
|
__ip6_dst_store(sk, dst, NULL, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-12-02 13:14:29 -07:00
|
|
|
rt = (struct rt6_info *) dst;
|
|
|
|
if (tcp_death_row.sysctl_tw_recycle &&
|
|
|
|
!tp->rx_opt.ts_recent_stamp &&
|
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-03 16:42:29 -06:00
|
|
|
ipv6_addr_equal(&rt->rt6i_dst.addr, &sk->sk_v6_daddr))
|
2012-07-10 04:14:24 -06:00
|
|
|
tcp_fetch_timewait_stamp(sk, dst);
|
2010-12-02 13:14:29 -07:00
|
|
|
|
2005-12-14 00:26:10 -07:00
|
|
|
icsk->icsk_ext_hdr_len = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (np->opt)
|
2005-12-14 00:26:10 -07:00
|
|
|
icsk->icsk_ext_hdr_len = (np->opt->opt_flen +
|
|
|
|
np->opt->opt_nflen);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
tp->rx_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
|
|
|
|
|
2009-10-15 00:30:45 -06:00
|
|
|
inet->inet_dport = usin->sin6_port;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
tcp_set_state(sk, TCP_SYN_SENT);
|
2005-12-14 00:25:44 -07:00
|
|
|
err = inet6_hash_connect(&tcp_death_row, sk);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (err)
|
|
|
|
goto late_failure;
|
|
|
|
|
2012-11-21 18:13:58 -07:00
|
|
|
if (!tp->write_seq && likely(!tp->repair))
|
2005-04-16 16:20:36 -06:00
|
|
|
tp->write_seq = secure_tcpv6_sequence_number(np->saddr.s6_addr32,
|
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-03 16:42:29 -06:00
|
|
|
sk->sk_v6_daddr.s6_addr32,
|
2009-10-15 00:30:45 -06:00
|
|
|
inet->inet_sport,
|
|
|
|
inet->inet_dport);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
err = tcp_connect(sk);
|
|
|
|
if (err)
|
|
|
|
goto late_failure;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
late_failure:
|
|
|
|
tcp_set_state(sk, TCP_CLOSE);
|
|
|
|
__sk_dst_reset(sk);
|
|
|
|
failure:
|
2009-10-15 00:30:45 -06:00
|
|
|
inet->inet_dport = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
sk->sk_route_caps = 0;
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2012-07-23 01:48:52 -06:00
|
|
|
static void tcp_v6_mtu_reduced(struct sock *sk)
|
|
|
|
{
|
|
|
|
struct dst_entry *dst;
|
|
|
|
|
|
|
|
if ((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE))
|
|
|
|
return;
|
|
|
|
|
|
|
|
dst = inet6_csk_update_pmtu(sk, tcp_sk(sk)->mtu_info);
|
|
|
|
if (!dst)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst)) {
|
|
|
|
tcp_sync_mss(sk, dst_mtu(dst));
|
|
|
|
tcp_simple_retransmit(sk);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
|
2009-06-23 05:31:07 -06:00
|
|
|
u8 type, u8 code, int offset, __be32 info)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-12-19 03:44:34 -07:00
|
|
|
const struct ipv6hdr *hdr = (const struct ipv6hdr *)skb->data;
|
2005-08-12 06:19:38 -06:00
|
|
|
const struct tcphdr *th = (struct tcphdr *)(skb->data+offset);
|
2005-04-16 16:20:36 -06:00
|
|
|
struct ipv6_pinfo *np;
|
|
|
|
struct sock *sk;
|
|
|
|
int err;
|
2007-02-09 07:24:49 -07:00
|
|
|
struct tcp_sock *tp;
|
2014-05-11 21:22:12 -06:00
|
|
|
struct request_sock *fastopen;
|
|
|
|
__u32 seq, snd_una;
|
2008-07-16 21:28:42 -06:00
|
|
|
struct net *net = dev_net(skb->dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-07-16 21:28:42 -06:00
|
|
|
sk = inet6_lookup(net, &tcp_hashinfo, &hdr->daddr,
|
2008-01-31 06:07:21 -07:00
|
|
|
th->dest, &hdr->saddr, th->source, skb->dev->ifindex);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (sk == NULL) {
|
2008-10-08 11:33:26 -06:00
|
|
|
ICMP6_INC_STATS_BH(net, __in6_dev_get(skb->dev),
|
|
|
|
ICMP6_MIB_INERRORS);
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sk->sk_state == TCP_TIME_WAIT) {
|
2006-10-10 20:41:46 -06:00
|
|
|
inet_twsk_put(inet_twsk(sk));
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
bh_lock_sock(sk);
|
2012-07-23 01:48:52 -06:00
|
|
|
if (sock_owned_by_user(sk) && type != ICMPV6_PKT_TOOBIG)
|
2008-07-16 21:31:16 -06:00
|
|
|
NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (sk->sk_state == TCP_CLOSE)
|
|
|
|
goto out;
|
|
|
|
|
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-22 16:24:53 -06:00
|
|
|
if (ipv6_hdr(skb)->hop_limit < inet6_sk(sk)->min_hopcount) {
|
|
|
|
NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
tp = tcp_sk(sk);
|
2007-02-09 07:24:49 -07:00
|
|
|
seq = ntohl(th->seq);
|
2014-05-11 21:22:12 -06:00
|
|
|
/* XXX (TFO) - tp->snd_una should be ISN (tcp_create_openreq_child() */
|
|
|
|
fastopen = tp->fastopen_rsk;
|
|
|
|
snd_una = fastopen ? tcp_rsk(fastopen)->snt_isn : tp->snd_una;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (sk->sk_state != TCP_LISTEN &&
|
2014-05-11 21:22:12 -06:00
|
|
|
!between(seq, snd_una, tp->snd_nxt)) {
|
2008-07-16 21:31:16 -06:00
|
|
|
NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
np = inet6_sk(sk);
|
|
|
|
|
2012-07-12 01:25:15 -06:00
|
|
|
if (type == NDISC_REDIRECT) {
|
|
|
|
struct dst_entry *dst = __sk_dst_check(sk, np->dst_cookie);
|
|
|
|
|
2012-07-12 01:41:25 -06:00
|
|
|
if (dst)
|
2012-07-17 04:29:28 -06:00
|
|
|
dst->ops->redirect(dst, sk, skb);
|
2013-04-06 22:53:15 -06:00
|
|
|
goto out;
|
2012-07-12 01:25:15 -06:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (type == ICMPV6_PKT_TOOBIG) {
|
2013-03-18 01:01:28 -06:00
|
|
|
/* We are not interested in TCP_LISTEN and open_requests
|
|
|
|
* (SYN-ACKs send out by Linux are always <576bytes so
|
|
|
|
* they should go through unfragmented).
|
|
|
|
*/
|
|
|
|
if (sk->sk_state == TCP_LISTEN)
|
|
|
|
goto out;
|
|
|
|
|
2013-12-14 19:41:14 -07:00
|
|
|
if (!ip6_sk_accept_pmtu(sk))
|
|
|
|
goto out;
|
|
|
|
|
2012-07-23 01:48:52 -06:00
|
|
|
tp->mtu_info = ntohl(info);
|
|
|
|
if (!sock_owned_by_user(sk))
|
|
|
|
tcp_v6_mtu_reduced(sk);
|
2012-09-05 04:53:18 -06:00
|
|
|
else if (!test_and_set_bit(TCP_MTU_REDUCED_DEFERRED,
|
|
|
|
&tp->tsq_flags))
|
|
|
|
sock_hold(sk);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
icmpv6_err_convert(type, code, &err);
|
|
|
|
|
2005-06-18 23:47:21 -06:00
|
|
|
/* Might be for an request_sock */
|
2005-04-16 16:20:36 -06:00
|
|
|
switch (sk->sk_state) {
|
2005-06-18 23:47:21 -06:00
|
|
|
struct request_sock *req, **prev;
|
2005-04-16 16:20:36 -06:00
|
|
|
case TCP_LISTEN:
|
|
|
|
if (sock_owned_by_user(sk))
|
|
|
|
goto out;
|
|
|
|
|
2005-12-14 00:15:24 -07:00
|
|
|
req = inet6_csk_search_req(sk, &prev, th->dest, &hdr->daddr,
|
|
|
|
&hdr->saddr, inet6_iif(skb));
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!req)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* ICMPs are not backlogged, hence we cannot get
|
|
|
|
* an established socket here.
|
|
|
|
*/
|
2008-07-25 22:43:18 -06:00
|
|
|
WARN_ON(req->sk != NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
[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-18 23:46:52 -06:00
|
|
|
if (seq != tcp_rsk(req)->snt_isn) {
|
2008-07-16 21:31:16 -06:00
|
|
|
NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2005-08-09 21:10:42 -06:00
|
|
|
inet_csk_reqsk_queue_drop(sk, req, prev);
|
2013-01-31 01:24:19 -07:00
|
|
|
NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
case TCP_SYN_SENT:
|
2014-05-11 21:22:12 -06:00
|
|
|
case TCP_SYN_RECV:
|
|
|
|
/* Only in fast or simultaneous open. If a fast open socket is
|
|
|
|
* is already accepted it is treated as a connected one below.
|
|
|
|
*/
|
|
|
|
if (fastopen && fastopen->sk == NULL)
|
|
|
|
break;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!sock_owned_by_user(sk)) {
|
|
|
|
sk->sk_err = err;
|
|
|
|
sk->sk_error_report(sk); /* Wake people up to see the error (see connect in sock.c) */
|
|
|
|
|
|
|
|
tcp_done(sk);
|
|
|
|
} else
|
|
|
|
sk->sk_err_soft = err;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!sock_owned_by_user(sk) && np->recverr) {
|
|
|
|
sk->sk_err = err;
|
|
|
|
sk->sk_error_report(sk);
|
|
|
|
} else
|
|
|
|
sk->sk_err_soft = err;
|
|
|
|
|
|
|
|
out:
|
|
|
|
bh_unlock_sock(sk);
|
|
|
|
sock_put(sk);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-06-28 06:34:21 -06:00
|
|
|
static int tcp_v6_send_synack(struct sock *sk, struct dst_entry *dst,
|
|
|
|
struct flowi6 *fl6,
|
2012-06-28 06:34:19 -06:00
|
|
|
struct request_sock *req,
|
2014-05-11 21:22:13 -06:00
|
|
|
u16 queue_mapping,
|
|
|
|
struct tcp_fastopen_cookie *foc)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-10-09 16:21:29 -06:00
|
|
|
struct inet_request_sock *ireq = inet_rsk(req);
|
2005-04-16 16:20:36 -06:00
|
|
|
struct ipv6_pinfo *np = inet6_sk(sk);
|
2013-12-19 03:44:34 -07:00
|
|
|
struct sk_buff *skb;
|
2012-06-28 06:34:20 -06:00
|
|
|
int err = -ENOMEM;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-06-28 06:34:21 -06:00
|
|
|
/* First, grab a route. */
|
|
|
|
if (!dst && (dst = inet6_csk_route_req(sk, fl6, req)) == NULL)
|
2008-02-29 12:43:03 -07:00
|
|
|
goto done;
|
2012-06-28 06:34:20 -06:00
|
|
|
|
2014-05-11 21:22:13 -06:00
|
|
|
skb = tcp_make_synack(sk, dst, req, foc);
|
2012-06-28 06:34:20 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (skb) {
|
2013-10-09 16:21:29 -06:00
|
|
|
__tcp_v6_send_check(skb, &ireq->ir_v6_loc_addr,
|
|
|
|
&ireq->ir_v6_rmt_addr);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-10-09 16:21:29 -06:00
|
|
|
fl6->daddr = ireq->ir_v6_rmt_addr;
|
2014-01-17 09:15:03 -07:00
|
|
|
if (np->repflow && (ireq->pktopts != NULL))
|
|
|
|
fl6->flowlabel = ip6_flowlabel(ipv6_hdr(ireq->pktopts));
|
|
|
|
|
2012-05-31 19:47:50 -06:00
|
|
|
skb_set_queue_mapping(skb, queue_mapping);
|
2012-07-01 11:18:59 -06:00
|
|
|
err = ip6_xmit(sk, skb, fl6, np->opt, np->tclass);
|
2006-11-14 06:21:36 -07:00
|
|
|
err = net_xmit_eval(err);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
done:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2013-03-17 02:23:34 -06:00
|
|
|
static int tcp_v6_rtx_synack(struct sock *sk, struct request_sock *req)
|
2010-01-17 20:09:39 -07:00
|
|
|
{
|
2012-06-28 06:34:21 -06:00
|
|
|
struct flowi6 fl6;
|
2012-10-27 17:16:46 -06:00
|
|
|
int res;
|
2012-06-28 06:34:21 -06:00
|
|
|
|
2014-05-11 21:22:13 -06:00
|
|
|
res = tcp_v6_send_synack(sk, NULL, &fl6, req, 0, NULL);
|
2014-03-03 13:31:36 -07:00
|
|
|
if (!res) {
|
2012-10-27 17:16:46 -06:00
|
|
|
TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_RETRANSSEGS);
|
2014-03-03 13:31:36 -07:00
|
|
|
NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPSYNRETRANS);
|
|
|
|
}
|
2012-10-27 17:16:46 -06:00
|
|
|
return res;
|
2010-01-17 20:09:39 -07:00
|
|
|
}
|
|
|
|
|
2005-06-18 23:47:21 -06:00
|
|
|
static void tcp_v6_reqsk_destructor(struct request_sock *req)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-10-09 16:21:29 -06:00
|
|
|
kfree_skb(inet_rsk(req)->pktopts);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-11-14 20:07:45 -07:00
|
|
|
#ifdef CONFIG_TCP_MD5SIG
|
|
|
|
static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
|
2011-04-21 22:53:02 -06:00
|
|
|
const struct in6_addr *addr)
|
2006-11-14 20:07:45 -07:00
|
|
|
{
|
2012-01-30 22:18:33 -07:00
|
|
|
return tcp_md5_do_lookup(sk, (union tcp_md5_addr *)addr, AF_INET6);
|
2006-11-14 20:07:45 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct tcp_md5sig_key *tcp_v6_md5_lookup(struct sock *sk,
|
|
|
|
struct sock *addr_sk)
|
|
|
|
{
|
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-03 16:42:29 -06:00
|
|
|
return tcp_v6_md5_do_lookup(sk, &addr_sk->sk_v6_daddr);
|
2006-11-14 20:07:45 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct tcp_md5sig_key *tcp_v6_reqsk_md5_lookup(struct sock *sk,
|
|
|
|
struct request_sock *req)
|
|
|
|
{
|
2013-10-09 16:21:29 -06:00
|
|
|
return tcp_v6_md5_do_lookup(sk, &inet_rsk(req)->ir_v6_rmt_addr);
|
2006-11-14 20:07:45 -07:00
|
|
|
}
|
|
|
|
|
2014-03-28 19:27:29 -06:00
|
|
|
static int tcp_v6_parse_md5_keys(struct sock *sk, char __user *optval,
|
|
|
|
int optlen)
|
2006-11-14 20:07:45 -07:00
|
|
|
{
|
|
|
|
struct tcp_md5sig cmd;
|
|
|
|
struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&cmd.tcpm_addr;
|
|
|
|
|
|
|
|
if (optlen < sizeof(cmd))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (copy_from_user(&cmd, optval, sizeof(cmd)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
if (sin6->sin6_family != AF_INET6)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!cmd.tcpm_keylen) {
|
2007-08-25 00:16:08 -06:00
|
|
|
if (ipv6_addr_v4mapped(&sin6->sin6_addr))
|
2012-01-30 22:18:33 -07:00
|
|
|
return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3],
|
|
|
|
AF_INET);
|
|
|
|
return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr,
|
|
|
|
AF_INET6);
|
2006-11-14 20:07:45 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2012-01-30 22:18:33 -07:00
|
|
|
if (ipv6_addr_v4mapped(&sin6->sin6_addr))
|
|
|
|
return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3],
|
|
|
|
AF_INET, cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
|
2006-11-14 20:07:45 -07:00
|
|
|
|
2012-01-30 22:18:33 -07:00
|
|
|
return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr,
|
|
|
|
AF_INET6, cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
|
2006-11-14 20:07:45 -07:00
|
|
|
}
|
|
|
|
|
2008-07-19 01:01:42 -06:00
|
|
|
static int tcp_v6_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
|
2011-04-21 22:53:02 -06:00
|
|
|
const struct in6_addr *daddr,
|
|
|
|
const struct in6_addr *saddr, int nbytes)
|
2006-11-14 20:07:45 -07:00
|
|
|
{
|
|
|
|
struct tcp6_pseudohdr *bp;
|
2008-07-19 01:01:42 -06:00
|
|
|
struct scatterlist sg;
|
2008-04-16 22:19:16 -06:00
|
|
|
|
2006-11-14 20:07:45 -07:00
|
|
|
bp = &hp->md5_blk.ip6;
|
|
|
|
/* 1. TCP pseudo-header (RFC2460) */
|
2011-11-20 20:39:03 -07:00
|
|
|
bp->saddr = *saddr;
|
|
|
|
bp->daddr = *daddr;
|
2008-07-19 01:01:42 -06:00
|
|
|
bp->protocol = cpu_to_be32(IPPROTO_TCP);
|
2008-07-31 22:36:07 -06:00
|
|
|
bp->len = cpu_to_be32(nbytes);
|
2006-11-14 20:07:45 -07:00
|
|
|
|
2008-07-19 01:01:42 -06:00
|
|
|
sg_init_one(&sg, bp, sizeof(*bp));
|
|
|
|
return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
|
|
|
|
}
|
2007-10-26 01:41:21 -06:00
|
|
|
|
2008-07-19 01:01:42 -06:00
|
|
|
static int tcp_v6_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key,
|
2011-04-21 22:53:02 -06:00
|
|
|
const struct in6_addr *daddr, struct in6_addr *saddr,
|
2011-10-24 00:46:04 -06:00
|
|
|
const struct tcphdr *th)
|
2008-07-19 01:01:42 -06:00
|
|
|
{
|
|
|
|
struct tcp_md5sig_pool *hp;
|
|
|
|
struct hash_desc *desc;
|
|
|
|
|
|
|
|
hp = tcp_get_md5sig_pool();
|
|
|
|
if (!hp)
|
|
|
|
goto clear_hash_noput;
|
|
|
|
desc = &hp->md5_desc;
|
|
|
|
|
|
|
|
if (crypto_hash_init(desc))
|
|
|
|
goto clear_hash;
|
|
|
|
if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
|
|
|
|
goto clear_hash;
|
|
|
|
if (tcp_md5_hash_header(hp, th))
|
|
|
|
goto clear_hash;
|
|
|
|
if (tcp_md5_hash_key(hp, key))
|
|
|
|
goto clear_hash;
|
|
|
|
if (crypto_hash_final(desc, md5_hash))
|
2006-11-14 20:07:45 -07:00
|
|
|
goto clear_hash;
|
|
|
|
|
|
|
|
tcp_put_md5sig_pool();
|
|
|
|
return 0;
|
2008-07-19 01:01:42 -06:00
|
|
|
|
2006-11-14 20:07:45 -07:00
|
|
|
clear_hash:
|
|
|
|
tcp_put_md5sig_pool();
|
|
|
|
clear_hash_noput:
|
|
|
|
memset(md5_hash, 0, 16);
|
2008-07-19 01:01:42 -06:00
|
|
|
return 1;
|
2006-11-14 20:07:45 -07:00
|
|
|
}
|
|
|
|
|
2008-07-19 01:01:42 -06:00
|
|
|
static int tcp_v6_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
|
2011-10-24 00:46:04 -06:00
|
|
|
const struct sock *sk,
|
|
|
|
const struct request_sock *req,
|
|
|
|
const struct sk_buff *skb)
|
2006-11-14 20:07:45 -07:00
|
|
|
{
|
2011-04-21 22:53:02 -06:00
|
|
|
const struct in6_addr *saddr, *daddr;
|
2008-07-19 01:01:42 -06:00
|
|
|
struct tcp_md5sig_pool *hp;
|
|
|
|
struct hash_desc *desc;
|
2011-10-24 00:46:04 -06:00
|
|
|
const struct tcphdr *th = tcp_hdr(skb);
|
2006-11-14 20:07:45 -07:00
|
|
|
|
|
|
|
if (sk) {
|
|
|
|
saddr = &inet6_sk(sk)->saddr;
|
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-03 16:42:29 -06:00
|
|
|
daddr = &sk->sk_v6_daddr;
|
2008-07-19 01:01:42 -06:00
|
|
|
} else if (req) {
|
2013-10-09 16:21:29 -06:00
|
|
|
saddr = &inet_rsk(req)->ir_v6_loc_addr;
|
|
|
|
daddr = &inet_rsk(req)->ir_v6_rmt_addr;
|
2008-07-19 01:01:42 -06:00
|
|
|
} else {
|
2011-04-21 22:53:02 -06:00
|
|
|
const struct ipv6hdr *ip6h = ipv6_hdr(skb);
|
2008-07-19 01:01:42 -06:00
|
|
|
saddr = &ip6h->saddr;
|
|
|
|
daddr = &ip6h->daddr;
|
2006-11-14 20:07:45 -07:00
|
|
|
}
|
2008-07-19 01:01:42 -06:00
|
|
|
|
|
|
|
hp = tcp_get_md5sig_pool();
|
|
|
|
if (!hp)
|
|
|
|
goto clear_hash_noput;
|
|
|
|
desc = &hp->md5_desc;
|
|
|
|
|
|
|
|
if (crypto_hash_init(desc))
|
|
|
|
goto clear_hash;
|
|
|
|
|
|
|
|
if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
|
|
|
|
goto clear_hash;
|
|
|
|
if (tcp_md5_hash_header(hp, th))
|
|
|
|
goto clear_hash;
|
|
|
|
if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
|
|
|
|
goto clear_hash;
|
|
|
|
if (tcp_md5_hash_key(hp, key))
|
|
|
|
goto clear_hash;
|
|
|
|
if (crypto_hash_final(desc, md5_hash))
|
|
|
|
goto clear_hash;
|
|
|
|
|
|
|
|
tcp_put_md5sig_pool();
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
clear_hash:
|
|
|
|
tcp_put_md5sig_pool();
|
|
|
|
clear_hash_noput:
|
|
|
|
memset(md5_hash, 0, 16);
|
|
|
|
return 1;
|
2006-11-14 20:07:45 -07:00
|
|
|
}
|
|
|
|
|
2011-10-24 00:46:04 -06:00
|
|
|
static int tcp_v6_inbound_md5_hash(struct sock *sk, const struct sk_buff *skb)
|
2006-11-14 20:07:45 -07:00
|
|
|
{
|
2011-10-21 03:22:42 -06:00
|
|
|
const __u8 *hash_location = NULL;
|
2006-11-14 20:07:45 -07:00
|
|
|
struct tcp_md5sig_key *hash_expected;
|
2011-04-21 22:53:02 -06:00
|
|
|
const struct ipv6hdr *ip6h = ipv6_hdr(skb);
|
2011-10-24 00:46:04 -06:00
|
|
|
const struct tcphdr *th = tcp_hdr(skb);
|
2006-11-14 20:07:45 -07:00
|
|
|
int genhash;
|
|
|
|
u8 newhash[16];
|
|
|
|
|
|
|
|
hash_expected = tcp_v6_md5_do_lookup(sk, &ip6h->saddr);
|
2008-04-16 21:29:53 -06:00
|
|
|
hash_location = tcp_parse_md5sig_option(th);
|
2006-11-14 20:07:45 -07:00
|
|
|
|
2008-07-30 04:03:15 -06:00
|
|
|
/* We've parsed the options - do we have a hash? */
|
|
|
|
if (!hash_expected && !hash_location)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (hash_expected && !hash_location) {
|
|
|
|
NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
|
2006-11-14 20:07:45 -07:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-07-30 04:03:15 -06:00
|
|
|
if (!hash_expected && hash_location) {
|
|
|
|
NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
|
2006-11-14 20:07:45 -07:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* check the signature */
|
2008-07-19 01:01:42 -06:00
|
|
|
genhash = tcp_v6_md5_hash_skb(newhash,
|
|
|
|
hash_expected,
|
|
|
|
NULL, NULL, skb);
|
|
|
|
|
2006-11-14 20:07:45 -07:00
|
|
|
if (genhash || memcmp(hash_location, newhash, 16) != 0) {
|
2012-05-13 15:56:26 -06:00
|
|
|
net_info_ratelimited("MD5 Hash %s for [%pI6c]:%u->[%pI6c]:%u\n",
|
|
|
|
genhash ? "failed" : "mismatch",
|
|
|
|
&ip6h->saddr, ntohs(th->source),
|
|
|
|
&ip6h->daddr, ntohs(th->dest));
|
2006-11-14 20:07:45 -07:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-02-07 22:49:26 -07:00
|
|
|
struct request_sock_ops tcp6_request_sock_ops __read_mostly = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.family = AF_INET6,
|
[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-18 23:46:52 -06:00
|
|
|
.obj_size = sizeof(struct tcp6_request_sock),
|
2010-01-17 20:09:39 -07:00
|
|
|
.rtx_syn_ack = tcp_v6_rtx_synack,
|
2005-06-18 23:47:21 -06:00
|
|
|
.send_ack = tcp_v6_reqsk_send_ack,
|
|
|
|
.destructor = tcp_v6_reqsk_destructor,
|
2010-01-17 20:09:39 -07:00
|
|
|
.send_reset = tcp_v6_send_reset,
|
2014-03-28 19:27:29 -06:00
|
|
|
.syn_ack_timeout = tcp_syn_ack_timeout,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2006-11-14 20:07:45 -07:00
|
|
|
#ifdef CONFIG_TCP_MD5SIG
|
2009-09-01 13:25:03 -06:00
|
|
|
static const struct tcp_request_sock_ops tcp_request_sock_ipv6_ops = {
|
2006-11-14 20:07:45 -07:00
|
|
|
.md5_lookup = tcp_v6_reqsk_md5_lookup,
|
2009-07-15 23:04:51 -06:00
|
|
|
.calc_md5_hash = tcp_v6_md5_hash_skb,
|
2006-11-14 20:07:45 -07:00
|
|
|
};
|
2006-11-30 20:16:28 -07:00
|
|
|
#endif
|
2006-11-14 20:07:45 -07:00
|
|
|
|
2008-10-09 15:42:40 -06:00
|
|
|
static void tcp_v6_send_response(struct sk_buff *skb, u32 seq, u32 ack, u32 win,
|
2014-03-28 19:27:31 -06:00
|
|
|
u32 tsval, u32 tsecr, int oif,
|
2014-01-16 09:21:22 -07:00
|
|
|
struct tcp_md5sig_key *key, int rst, u8 tclass,
|
|
|
|
u32 label)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-10-21 03:22:42 -06:00
|
|
|
const struct tcphdr *th = tcp_hdr(skb);
|
|
|
|
struct tcphdr *t1;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct sk_buff *buff;
|
2011-03-12 14:22:43 -07:00
|
|
|
struct flowi6 fl6;
|
2009-06-01 23:19:30 -06:00
|
|
|
struct net *net = dev_net(skb_dst(skb)->dev);
|
2008-03-07 12:16:26 -07:00
|
|
|
struct sock *ctl_sk = net->ipv6.tcp_sk;
|
2008-10-09 15:41:38 -06:00
|
|
|
unsigned int tot_len = sizeof(struct tcphdr);
|
2009-06-01 23:19:30 -06:00
|
|
|
struct dst_entry *dst;
|
tcpv6: convert opt[] -> topt in tcp_v6_send_reset
after this I get:
$ diff-funcs tcp_v6_send_reset tcp_ipv6.c tcp_ipv6.c tcp_v6_send_ack
--- tcp_ipv6.c:tcp_v6_send_reset()
+++ tcp_ipv6.c:tcp_v6_send_ack()
@@ -1,4 +1,5 @@
-static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb)
+static void tcp_v6_send_ack(struct sk_buff *skb, u32 seq, u32 ack, u32 win,
u32 ts,
+ struct tcp_md5sig_key *key)
{
struct tcphdr *th = tcp_hdr(skb), *t1;
struct sk_buff *buff;
@@ -7,31 +8,14 @@
struct sock *ctl_sk = net->ipv6.tcp_sk;
unsigned int tot_len = sizeof(struct tcphdr);
__be32 *topt;
-#ifdef CONFIG_TCP_MD5SIG
- struct tcp_md5sig_key *key;
-#endif
-
- if (th->rst)
- return;
-
- if (!ipv6_unicast_destination(skb))
- return;
+ if (ts)
+ tot_len += TCPOLEN_TSTAMP_ALIGNED;
#ifdef CONFIG_TCP_MD5SIG
- if (sk)
- key = tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr);
- else
- key = NULL;
-
if (key)
tot_len += TCPOLEN_MD5SIG_ALIGNED;
#endif
- /*
- * We need to grab some memory, and put together an RST,
- * and then put it into the queue to be sent.
- */
-
buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
GFP_ATOMIC);
if (buff == NULL)
@@ -46,18 +30,20 @@
t1->dest = th->source;
t1->source = th->dest;
t1->doff = tot_len / 4;
- t1->rst = 1;
-
- if(th->ack) {
- t1->seq = th->ack_seq;
- } else {
- t1->ack = 1;
- t1->ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin
- + skb->len - (th->doff<<2));
- }
+ t1->seq = htonl(seq);
+ t1->ack_seq = htonl(ack);
+ t1->ack = 1;
+ t1->window = htons(win);
topt = (__be32 *)(t1 + 1);
+ if (ts) {
+ *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
+ (TCPOPT_TIMESTAMP << 8) |
TCPOLEN_TIMESTAMP);
+ *topt++ = htonl(tcp_time_stamp);
+ *topt++ = htonl(ts);
+ }
+
#ifdef CONFIG_TCP_MD5SIG
if (key) {
*topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
@@ -84,15 +70,10 @@
fl.fl_ip_sport = t1->source;
security_skb_classify_flow(skb, &fl);
- /* Pass a socket to ip6_dst_lookup either it is for RST
- * Underlying function will use this to retrieve the network
- * namespace
- */
if (!ip6_dst_lookup(ctl_sk, &buff->dst, &fl)) {
if (xfrm_lookup(&buff->dst, &fl, NULL, 0) >= 0) {
ip6_xmit(ctl_sk, buff, &fl, NULL, 0);
TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
- TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
return;
}
}
...which starts to be trivial to combine.
Signed-off-by: Ilpo Järvinen <ilpo.jarvinen@helsinki.fi>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-10-09 15:42:01 -06:00
|
|
|
__be32 *topt;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-02-10 22:50:19 -07:00
|
|
|
if (tsecr)
|
2008-10-09 15:42:40 -06:00
|
|
|
tot_len += TCPOLEN_TSTAMP_ALIGNED;
|
2006-11-14 20:07:45 -07:00
|
|
|
#ifdef CONFIG_TCP_MD5SIG
|
|
|
|
if (key)
|
|
|
|
tot_len += TCPOLEN_MD5SIG_ALIGNED;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
|
2005-04-16 16:20:36 -06:00
|
|
|
GFP_ATOMIC);
|
2007-02-09 07:24:49 -07:00
|
|
|
if (buff == NULL)
|
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-11-14 20:07:45 -07:00
|
|
|
skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-11-14 20:07:45 -07:00
|
|
|
t1 = (struct tcphdr *) skb_push(buff, tot_len);
|
2010-04-21 01:47:15 -06:00
|
|
|
skb_reset_transport_header(buff);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Swap the send and the receive. */
|
|
|
|
memset(t1, 0, sizeof(*t1));
|
|
|
|
t1->dest = th->source;
|
|
|
|
t1->source = th->dest;
|
2006-11-14 20:07:45 -07:00
|
|
|
t1->doff = tot_len / 4;
|
2008-10-09 15:42:40 -06:00
|
|
|
t1->seq = htonl(seq);
|
|
|
|
t1->ack_seq = htonl(ack);
|
|
|
|
t1->ack = !rst || !th->ack;
|
|
|
|
t1->rst = rst;
|
|
|
|
t1->window = htons(win);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
tcpv6: convert opt[] -> topt in tcp_v6_send_reset
after this I get:
$ diff-funcs tcp_v6_send_reset tcp_ipv6.c tcp_ipv6.c tcp_v6_send_ack
--- tcp_ipv6.c:tcp_v6_send_reset()
+++ tcp_ipv6.c:tcp_v6_send_ack()
@@ -1,4 +1,5 @@
-static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb)
+static void tcp_v6_send_ack(struct sk_buff *skb, u32 seq, u32 ack, u32 win,
u32 ts,
+ struct tcp_md5sig_key *key)
{
struct tcphdr *th = tcp_hdr(skb), *t1;
struct sk_buff *buff;
@@ -7,31 +8,14 @@
struct sock *ctl_sk = net->ipv6.tcp_sk;
unsigned int tot_len = sizeof(struct tcphdr);
__be32 *topt;
-#ifdef CONFIG_TCP_MD5SIG
- struct tcp_md5sig_key *key;
-#endif
-
- if (th->rst)
- return;
-
- if (!ipv6_unicast_destination(skb))
- return;
+ if (ts)
+ tot_len += TCPOLEN_TSTAMP_ALIGNED;
#ifdef CONFIG_TCP_MD5SIG
- if (sk)
- key = tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr);
- else
- key = NULL;
-
if (key)
tot_len += TCPOLEN_MD5SIG_ALIGNED;
#endif
- /*
- * We need to grab some memory, and put together an RST,
- * and then put it into the queue to be sent.
- */
-
buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
GFP_ATOMIC);
if (buff == NULL)
@@ -46,18 +30,20 @@
t1->dest = th->source;
t1->source = th->dest;
t1->doff = tot_len / 4;
- t1->rst = 1;
-
- if(th->ack) {
- t1->seq = th->ack_seq;
- } else {
- t1->ack = 1;
- t1->ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin
- + skb->len - (th->doff<<2));
- }
+ t1->seq = htonl(seq);
+ t1->ack_seq = htonl(ack);
+ t1->ack = 1;
+ t1->window = htons(win);
topt = (__be32 *)(t1 + 1);
+ if (ts) {
+ *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
+ (TCPOPT_TIMESTAMP << 8) |
TCPOLEN_TIMESTAMP);
+ *topt++ = htonl(tcp_time_stamp);
+ *topt++ = htonl(ts);
+ }
+
#ifdef CONFIG_TCP_MD5SIG
if (key) {
*topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
@@ -84,15 +70,10 @@
fl.fl_ip_sport = t1->source;
security_skb_classify_flow(skb, &fl);
- /* Pass a socket to ip6_dst_lookup either it is for RST
- * Underlying function will use this to retrieve the network
- * namespace
- */
if (!ip6_dst_lookup(ctl_sk, &buff->dst, &fl)) {
if (xfrm_lookup(&buff->dst, &fl, NULL, 0) >= 0) {
ip6_xmit(ctl_sk, buff, &fl, NULL, 0);
TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
- TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
return;
}
}
...which starts to be trivial to combine.
Signed-off-by: Ilpo Järvinen <ilpo.jarvinen@helsinki.fi>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-10-09 15:42:01 -06:00
|
|
|
topt = (__be32 *)(t1 + 1);
|
|
|
|
|
2013-02-10 22:50:19 -07:00
|
|
|
if (tsecr) {
|
2008-10-09 15:42:40 -06:00
|
|
|
*topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
|
|
|
|
(TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
|
2013-02-10 22:50:19 -07:00
|
|
|
*topt++ = htonl(tsval);
|
|
|
|
*topt++ = htonl(tsecr);
|
2008-10-09 15:42:40 -06:00
|
|
|
}
|
|
|
|
|
2006-11-14 20:07:45 -07:00
|
|
|
#ifdef CONFIG_TCP_MD5SIG
|
|
|
|
if (key) {
|
tcpv6: convert opt[] -> topt in tcp_v6_send_reset
after this I get:
$ diff-funcs tcp_v6_send_reset tcp_ipv6.c tcp_ipv6.c tcp_v6_send_ack
--- tcp_ipv6.c:tcp_v6_send_reset()
+++ tcp_ipv6.c:tcp_v6_send_ack()
@@ -1,4 +1,5 @@
-static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb)
+static void tcp_v6_send_ack(struct sk_buff *skb, u32 seq, u32 ack, u32 win,
u32 ts,
+ struct tcp_md5sig_key *key)
{
struct tcphdr *th = tcp_hdr(skb), *t1;
struct sk_buff *buff;
@@ -7,31 +8,14 @@
struct sock *ctl_sk = net->ipv6.tcp_sk;
unsigned int tot_len = sizeof(struct tcphdr);
__be32 *topt;
-#ifdef CONFIG_TCP_MD5SIG
- struct tcp_md5sig_key *key;
-#endif
-
- if (th->rst)
- return;
-
- if (!ipv6_unicast_destination(skb))
- return;
+ if (ts)
+ tot_len += TCPOLEN_TSTAMP_ALIGNED;
#ifdef CONFIG_TCP_MD5SIG
- if (sk)
- key = tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr);
- else
- key = NULL;
-
if (key)
tot_len += TCPOLEN_MD5SIG_ALIGNED;
#endif
- /*
- * We need to grab some memory, and put together an RST,
- * and then put it into the queue to be sent.
- */
-
buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
GFP_ATOMIC);
if (buff == NULL)
@@ -46,18 +30,20 @@
t1->dest = th->source;
t1->source = th->dest;
t1->doff = tot_len / 4;
- t1->rst = 1;
-
- if(th->ack) {
- t1->seq = th->ack_seq;
- } else {
- t1->ack = 1;
- t1->ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin
- + skb->len - (th->doff<<2));
- }
+ t1->seq = htonl(seq);
+ t1->ack_seq = htonl(ack);
+ t1->ack = 1;
+ t1->window = htons(win);
topt = (__be32 *)(t1 + 1);
+ if (ts) {
+ *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
+ (TCPOPT_TIMESTAMP << 8) |
TCPOLEN_TIMESTAMP);
+ *topt++ = htonl(tcp_time_stamp);
+ *topt++ = htonl(ts);
+ }
+
#ifdef CONFIG_TCP_MD5SIG
if (key) {
*topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
@@ -84,15 +70,10 @@
fl.fl_ip_sport = t1->source;
security_skb_classify_flow(skb, &fl);
- /* Pass a socket to ip6_dst_lookup either it is for RST
- * Underlying function will use this to retrieve the network
- * namespace
- */
if (!ip6_dst_lookup(ctl_sk, &buff->dst, &fl)) {
if (xfrm_lookup(&buff->dst, &fl, NULL, 0) >= 0) {
ip6_xmit(ctl_sk, buff, &fl, NULL, 0);
TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
- TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
return;
}
}
...which starts to be trivial to combine.
Signed-off-by: Ilpo Järvinen <ilpo.jarvinen@helsinki.fi>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-10-09 15:42:01 -06:00
|
|
|
*topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
|
|
|
|
(TCPOPT_MD5SIG << 8) | TCPOLEN_MD5SIG);
|
|
|
|
tcp_v6_md5_hash_hdr((__u8 *)topt, key,
|
2008-10-09 15:37:47 -06:00
|
|
|
&ipv6_hdr(skb)->saddr,
|
|
|
|
&ipv6_hdr(skb)->daddr, t1);
|
2006-11-14 20:07:45 -07:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2011-03-12 14:22:43 -07:00
|
|
|
memset(&fl6, 0, sizeof(fl6));
|
2011-11-20 20:39:03 -07:00
|
|
|
fl6.daddr = ipv6_hdr(skb)->saddr;
|
|
|
|
fl6.saddr = ipv6_hdr(skb)->daddr;
|
2014-01-16 09:21:22 -07:00
|
|
|
fl6.flowlabel = label;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-04-21 15:59:20 -06:00
|
|
|
buff->ip_summed = CHECKSUM_PARTIAL;
|
|
|
|
buff->csum = 0;
|
|
|
|
|
2011-03-12 14:22:43 -07:00
|
|
|
__tcp_v6_send_check(buff, &fl6.saddr, &fl6.daddr);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-03-12 14:22:43 -07:00
|
|
|
fl6.flowi6_proto = IPPROTO_TCP;
|
net: ipv6: Fix oif in TCP SYN+ACK route lookup.
net-next commit 9c76a11, ipv6: tcp_ipv6 policy route issue, had
a boolean logic error that caused incorrect behaviour for TCP
SYN+ACK when oif-based rules are in use. Specifically:
1. If a SYN comes in from a global address, and sk_bound_dev_if
is not set, the routing lookup has oif set to the interface
the SYN came in on. Instead, it should have oif unset,
because for global addresses, the incoming interface doesn't
necessarily have any bearing on the interface the SYN+ACK is
sent out on.
2. If a SYN comes in from a link-local address, and
sk_bound_dev_if is set, the routing lookup has oif set to the
interface the SYN came in on. Instead, it should have oif set
to sk_bound_dev_if, because that's what the application
requested.
Signed-off-by: Lorenzo Colitti <lorenzo@google.com>
Acked-by: Hannes Frederic Sowa <hannes@stressinduktion.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-04-10 22:19:12 -06:00
|
|
|
if (rt6_need_strict(&fl6.daddr) && !oif)
|
2012-10-11 22:34:17 -06:00
|
|
|
fl6.flowi6_oif = inet6_iif(skb);
|
2014-03-28 19:27:31 -06:00
|
|
|
else
|
|
|
|
fl6.flowi6_oif = oif;
|
2014-05-13 11:17:33 -06:00
|
|
|
fl6.flowi6_mark = IP6_REPLY_MARK(net, skb->mark);
|
2011-03-12 14:36:19 -07:00
|
|
|
fl6.fl6_dport = t1->dest;
|
|
|
|
fl6.fl6_sport = t1->source;
|
2011-03-12 14:22:43 -07:00
|
|
|
security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-03-05 11:48:35 -07:00
|
|
|
/* Pass a socket to ip6_dst_lookup either it is for RST
|
|
|
|
* Underlying function will use this to retrieve the network
|
|
|
|
* namespace
|
|
|
|
*/
|
2013-08-28 00:04:14 -06:00
|
|
|
dst = ip6_dst_lookup_flow(ctl_sk, &fl6, NULL);
|
2011-03-01 14:19:07 -07:00
|
|
|
if (!IS_ERR(dst)) {
|
|
|
|
skb_dst_set(buff, dst);
|
2011-10-26 22:44:35 -06:00
|
|
|
ip6_xmit(ctl_sk, buff, &fl6, NULL, tclass);
|
2011-03-01 14:19:07 -07:00
|
|
|
TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
|
|
|
|
if (rst)
|
|
|
|
TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
|
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
kfree_skb(buff);
|
|
|
|
}
|
|
|
|
|
2008-10-09 15:42:40 -06:00
|
|
|
static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-10-21 03:22:42 -06:00
|
|
|
const struct tcphdr *th = tcp_hdr(skb);
|
2008-10-09 15:42:40 -06:00
|
|
|
u32 seq = 0, ack_seq = 0;
|
2008-10-09 22:11:56 -06:00
|
|
|
struct tcp_md5sig_key *key = NULL;
|
2012-01-31 15:35:48 -07:00
|
|
|
#ifdef CONFIG_TCP_MD5SIG
|
|
|
|
const __u8 *hash_location = NULL;
|
|
|
|
struct ipv6hdr *ipv6h = ipv6_hdr(skb);
|
|
|
|
unsigned char newhash[16];
|
|
|
|
int genhash;
|
|
|
|
struct sock *sk1 = NULL;
|
|
|
|
#endif
|
2014-03-28 19:27:31 -06:00
|
|
|
int oif;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-10-09 15:42:40 -06:00
|
|
|
if (th->rst)
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
|
2008-10-09 15:42:40 -06:00
|
|
|
if (!ipv6_unicast_destination(skb))
|
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-11-14 20:07:45 -07:00
|
|
|
#ifdef CONFIG_TCP_MD5SIG
|
2012-01-31 15:35:48 -07:00
|
|
|
hash_location = tcp_parse_md5sig_option(th);
|
|
|
|
if (!sk && hash_location) {
|
|
|
|
/*
|
|
|
|
* active side is lost. Try to find listening socket through
|
|
|
|
* source port, and then find md5 key through listening socket.
|
|
|
|
* we are not loose security here:
|
|
|
|
* Incoming packet is checked with md5 hash with finding key,
|
|
|
|
* no RST generated if md5 hash doesn't match.
|
|
|
|
*/
|
|
|
|
sk1 = inet6_lookup_listener(dev_net(skb_dst(skb)->dev),
|
2013-01-22 02:50:39 -07:00
|
|
|
&tcp_hashinfo, &ipv6h->saddr,
|
|
|
|
th->source, &ipv6h->daddr,
|
2012-01-31 15:35:48 -07:00
|
|
|
ntohs(th->source), inet6_iif(skb));
|
|
|
|
if (!sk1)
|
|
|
|
return;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
key = tcp_v6_md5_do_lookup(sk1, &ipv6h->saddr);
|
|
|
|
if (!key)
|
|
|
|
goto release_sk1;
|
|
|
|
|
|
|
|
genhash = tcp_v6_md5_hash_skb(newhash, key, NULL, NULL, skb);
|
|
|
|
if (genhash || memcmp(hash_location, newhash, 16) != 0)
|
|
|
|
goto release_sk1;
|
|
|
|
} else {
|
|
|
|
key = sk ? tcp_v6_md5_do_lookup(sk, &ipv6h->saddr) : NULL;
|
|
|
|
}
|
2006-11-14 20:07:45 -07:00
|
|
|
#endif
|
|
|
|
|
2008-10-09 15:42:40 -06:00
|
|
|
if (th->ack)
|
|
|
|
seq = ntohl(th->ack_seq);
|
|
|
|
else
|
|
|
|
ack_seq = ntohl(th->seq) + th->syn + th->fin + skb->len -
|
|
|
|
(th->doff << 2);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-03-28 19:27:31 -06:00
|
|
|
oif = sk ? sk->sk_bound_dev_if : 0;
|
|
|
|
tcp_v6_send_response(skb, seq, ack_seq, 0, 0, 0, oif, key, 1, 0, 0);
|
2012-01-31 15:35:48 -07:00
|
|
|
|
|
|
|
#ifdef CONFIG_TCP_MD5SIG
|
|
|
|
release_sk1:
|
|
|
|
if (sk1) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
sock_put(sk1);
|
|
|
|
}
|
|
|
|
#endif
|
2008-10-09 15:42:40 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-02-10 22:50:19 -07:00
|
|
|
static void tcp_v6_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
|
2014-03-28 19:27:31 -06:00
|
|
|
u32 win, u32 tsval, u32 tsecr, int oif,
|
2014-01-16 09:21:22 -07:00
|
|
|
struct tcp_md5sig_key *key, u8 tclass,
|
|
|
|
u32 label)
|
2008-10-09 15:42:40 -06:00
|
|
|
{
|
2014-03-28 19:27:31 -06:00
|
|
|
tcp_v6_send_response(skb, seq, ack, win, tsval, tsecr, oif, key, 0, tclass,
|
2014-01-16 09:21:22 -07:00
|
|
|
label);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
|
|
|
|
{
|
2005-08-09 21:09:30 -06:00
|
|
|
struct inet_timewait_sock *tw = inet_twsk(sk);
|
2006-11-14 20:07:45 -07:00
|
|
|
struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-04-17 21:45:16 -06:00
|
|
|
tcp_v6_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
|
2005-08-09 21:09:30 -06:00
|
|
|
tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
|
2013-02-10 22:50:19 -07:00
|
|
|
tcp_time_stamp + tcptw->tw_ts_offset,
|
2014-03-28 19:27:31 -06:00
|
|
|
tcptw->tw_ts_recent, tw->tw_bound_dev_if, tcp_twsk_md5_key(tcptw),
|
2014-01-16 09:21:22 -07:00
|
|
|
tw->tw_tclass, (tw->tw_flowlabel << 12));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-08-09 21:09:30 -06:00
|
|
|
inet_twsk_put(tw);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-08-07 00:50:04 -06:00
|
|
|
static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
|
|
|
|
struct request_sock *req)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2014-05-11 21:22:13 -06:00
|
|
|
/* sk->sk_state == TCP_LISTEN -> for regular TCP_SYN_RECV
|
|
|
|
* sk->sk_state == TCP_SYN_RECV -> for Fast Open.
|
|
|
|
*/
|
|
|
|
tcp_v6_send_ack(skb, (sk->sk_state == TCP_LISTEN) ?
|
|
|
|
tcp_rsk(req)->snt_isn + 1 : tcp_sk(sk)->snd_nxt,
|
|
|
|
tcp_rsk(req)->rcv_nxt,
|
2014-03-28 19:27:31 -06:00
|
|
|
req->rcv_wnd, tcp_time_stamp, req->ts_recent, sk->sk_bound_dev_if,
|
2014-01-16 09:21:22 -07:00
|
|
|
tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr),
|
|
|
|
0, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-12-19 03:44:34 -07:00
|
|
|
static struct sock *tcp_v6_hnd_req(struct sock *sk, struct sk_buff *skb)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-06-18 23:47:21 -06:00
|
|
|
struct request_sock *req, **prev;
|
2007-04-10 22:04:22 -06:00
|
|
|
const struct tcphdr *th = tcp_hdr(skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
struct sock *nsk;
|
|
|
|
|
|
|
|
/* Find possible connection requests. */
|
2005-12-14 00:15:24 -07:00
|
|
|
req = inet6_csk_search_req(sk, &prev, th->source,
|
2007-04-25 18:54:47 -06:00
|
|
|
&ipv6_hdr(skb)->saddr,
|
|
|
|
&ipv6_hdr(skb)->daddr, inet6_iif(skb));
|
2005-04-16 16:20:36 -06:00
|
|
|
if (req)
|
2012-08-31 06:29:12 -06:00
|
|
|
return tcp_check_req(sk, skb, req, prev, false);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-03-25 11:26:21 -06:00
|
|
|
nsk = __inet6_lookup_established(sock_net(sk), &tcp_hashinfo,
|
2008-01-31 06:07:21 -07:00
|
|
|
&ipv6_hdr(skb)->saddr, th->source,
|
|
|
|
&ipv6_hdr(skb)->daddr, ntohs(th->dest), inet6_iif(skb));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (nsk) {
|
|
|
|
if (nsk->sk_state != TCP_TIME_WAIT) {
|
|
|
|
bh_lock_sock(nsk);
|
|
|
|
return nsk;
|
|
|
|
}
|
2006-10-10 20:41:46 -06:00
|
|
|
inet_twsk_put(inet_twsk(nsk));
|
2005-04-16 16:20:36 -06:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-02-07 22:49:26 -07:00
|
|
|
#ifdef CONFIG_SYN_COOKIES
|
2010-06-02 18:43:44 -06:00
|
|
|
if (!th->syn)
|
2008-02-07 22:49:26 -07:00
|
|
|
sk = cookie_v6_check(sk, skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
return sk;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* FIXME: this is substantially similar to the ipv4 code.
|
|
|
|
* Can some kind of merge be done? -- erics
|
|
|
|
*/
|
|
|
|
static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
|
|
|
|
{
|
2009-12-02 11:07:39 -07:00
|
|
|
struct tcp_options_received tmp_opt;
|
|
|
|
struct request_sock *req;
|
2013-10-09 16:21:29 -06:00
|
|
|
struct inet_request_sock *ireq;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct ipv6_pinfo *np = inet6_sk(sk);
|
|
|
|
struct tcp_sock *tp = tcp_sk(sk);
|
2009-12-02 11:07:39 -07:00
|
|
|
__u32 isn = TCP_SKB_CB(skb)->when;
|
2010-12-02 13:14:29 -07:00
|
|
|
struct dst_entry *dst = NULL;
|
2014-05-11 21:22:13 -06:00
|
|
|
struct tcp_fastopen_cookie foc = { .len = -1 };
|
|
|
|
bool want_cookie = false, fastopen;
|
2012-06-28 06:34:19 -06:00
|
|
|
struct flowi6 fl6;
|
2014-05-11 21:22:13 -06:00
|
|
|
int err;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (skb->protocol == htons(ETH_P_IP))
|
|
|
|
return tcp_v4_conn_request(sk, skb);
|
|
|
|
|
|
|
|
if (!ipv6_unicast_destination(skb))
|
2007-02-09 07:24:49 -07:00
|
|
|
goto drop;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-07-26 09:43:23 -06:00
|
|
|
if ((sysctl_tcp_syncookies == 2 ||
|
|
|
|
inet_csk_reqsk_queue_is_full(sk)) && !isn) {
|
2011-08-29 21:21:44 -06:00
|
|
|
want_cookie = tcp_syn_flood_action(sk, skb, "TCPv6");
|
|
|
|
if (!want_cookie)
|
|
|
|
goto drop;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2013-01-31 01:24:19 -07:00
|
|
|
if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1) {
|
|
|
|
NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto drop;
|
2013-01-31 01:24:19 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-12-14 00:15:40 -07:00
|
|
|
req = inet6_reqsk_alloc(&tcp6_request_sock_ops);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (req == NULL)
|
|
|
|
goto drop;
|
|
|
|
|
2006-11-14 20:07:45 -07:00
|
|
|
#ifdef CONFIG_TCP_MD5SIG
|
|
|
|
tcp_rsk(req)->af_specific = &tcp_request_sock_ipv6_ops;
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
tcp_clear_options(&tmp_opt);
|
|
|
|
tmp_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
|
|
|
|
tmp_opt.user_mss = tp->rx_opt.user_mss;
|
2014-05-11 21:22:13 -06:00
|
|
|
tcp_parse_options(skb, &tmp_opt, 0, want_cookie ? NULL : &foc);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-04-10 04:12:40 -06:00
|
|
|
if (want_cookie && !tmp_opt.saw_tstamp)
|
2008-02-07 22:49:26 -07:00
|
|
|
tcp_clear_options(&tmp_opt);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
|
|
|
|
tcp_openreq_init(req, &tmp_opt, skb);
|
|
|
|
|
2013-10-09 16:21:29 -06:00
|
|
|
ireq = inet_rsk(req);
|
|
|
|
ireq->ir_v6_rmt_addr = ipv6_hdr(skb)->saddr;
|
|
|
|
ireq->ir_v6_loc_addr = ipv6_hdr(skb)->daddr;
|
2010-06-21 05:48:45 -06:00
|
|
|
if (!want_cookie || tmp_opt.tstamp_ok)
|
2013-01-05 09:10:48 -07:00
|
|
|
TCP_ECN_create_request(req, skb, sock_net(sk));
|
2008-02-07 22:49:26 -07:00
|
|
|
|
2013-10-09 16:21:29 -06:00
|
|
|
ireq->ir_iif = sk->sk_bound_dev_if;
|
net: support marking accepting TCP sockets
When using mark-based routing, sockets returned from accept()
may need to be marked differently depending on the incoming
connection request.
This is the case, for example, if different socket marks identify
different networks: a listening socket may want to accept
connections from all networks, but each connection should be
marked with the network that the request came in on, so that
subsequent packets are sent on the correct network.
This patch adds a sysctl to mark TCP sockets based on the fwmark
of the incoming SYN packet. If enabled, and an unmarked socket
receives a SYN, then the SYN packet's fwmark is written to the
connection's inet_request_sock, and later written back to the
accepted socket when the connection is established. If the
socket already has a nonzero mark, then the behaviour is the same
as it is today, i.e., the listening socket's fwmark is used.
Black-box tested using user-mode linux:
- IPv4/IPv6 SYN+ACK, FIN, etc. packets are routed based on the
mark of the incoming SYN packet.
- The socket returned by accept() is marked with the mark of the
incoming SYN packet.
- Tested with syncookies=1 and syncookies=2.
Signed-off-by: Lorenzo Colitti <lorenzo@google.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-05-13 11:17:35 -06:00
|
|
|
ireq->ir_mark = inet_request_mark(sk, skb);
|
2011-11-23 15:29:23 -07:00
|
|
|
|
|
|
|
/* So that link locals have meaning */
|
|
|
|
if (!sk->sk_bound_dev_if &&
|
2013-10-09 16:21:29 -06:00
|
|
|
ipv6_addr_type(&ireq->ir_v6_rmt_addr) & IPV6_ADDR_LINKLOCAL)
|
|
|
|
ireq->ir_iif = inet6_iif(skb);
|
2011-11-23 15:29:23 -07:00
|
|
|
|
2010-06-13 05:29:39 -06:00
|
|
|
if (!isn) {
|
2008-02-07 22:49:26 -07:00
|
|
|
if (ipv6_opt_accepted(sk, skb) ||
|
|
|
|
np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo ||
|
2014-01-17 09:15:03 -07:00
|
|
|
np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim ||
|
|
|
|
np->repflow) {
|
2008-02-07 22:49:26 -07:00
|
|
|
atomic_inc(&skb->users);
|
2013-10-09 16:21:29 -06:00
|
|
|
ireq->pktopts = skb;
|
2008-02-07 22:49:26 -07:00
|
|
|
}
|
2010-12-02 13:14:29 -07:00
|
|
|
|
|
|
|
if (want_cookie) {
|
2010-06-13 05:29:39 -06:00
|
|
|
isn = cookie_v6_init_sequence(sk, skb, &req->mss);
|
|
|
|
req->cookie_ts = tmp_opt.tstamp_ok;
|
2010-12-02 13:14:29 -07:00
|
|
|
goto have_isn;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* VJ's idea. We save last timestamp seen
|
|
|
|
* from the destination in peer table, when entering
|
|
|
|
* state TIME-WAIT, and check against it before
|
|
|
|
* accepting new connection request.
|
|
|
|
*
|
|
|
|
* If "isn" is not zero, this request hit alive
|
|
|
|
* timewait bucket, so that all the necessary checks
|
|
|
|
* are made in the function processing timewait state.
|
|
|
|
*/
|
|
|
|
if (tmp_opt.saw_tstamp &&
|
|
|
|
tcp_death_row.sysctl_tw_recycle &&
|
2012-07-10 04:14:24 -06:00
|
|
|
(dst = inet6_csk_route_req(sk, &fl6, req)) != NULL) {
|
|
|
|
if (!tcp_peer_is_proven(req, dst, true)) {
|
2010-12-02 13:14:29 -07:00
|
|
|
NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSPASSIVEREJECTED);
|
|
|
|
goto drop_and_release;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Kill the following clause, if you dislike this way. */
|
|
|
|
else if (!sysctl_tcp_syncookies &&
|
|
|
|
(sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
|
|
|
|
(sysctl_max_syn_backlog >> 2)) &&
|
2012-07-10 04:14:24 -06:00
|
|
|
!tcp_peer_is_proven(req, dst, false)) {
|
2010-12-02 13:14:29 -07:00
|
|
|
/* Without syncookies last quarter of
|
|
|
|
* backlog is filled with destinations,
|
|
|
|
* proven to be alive.
|
|
|
|
* It means that we continue to communicate
|
|
|
|
* to destinations, already remembered
|
|
|
|
* to the moment of synflood.
|
|
|
|
*/
|
|
|
|
LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open request from %pI6/%u\n",
|
2013-10-09 16:21:29 -06:00
|
|
|
&ireq->ir_v6_rmt_addr, ntohs(tcp_hdr(skb)->source));
|
2010-12-02 13:14:29 -07:00
|
|
|
goto drop_and_release;
|
2010-06-13 05:29:39 -06:00
|
|
|
}
|
2010-12-02 13:14:29 -07:00
|
|
|
|
|
|
|
isn = tcp_v6_init_sequence(skb);
|
2008-02-07 22:49:26 -07:00
|
|
|
}
|
2010-12-02 13:14:29 -07:00
|
|
|
have_isn:
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-06-23 13:22:00 -06:00
|
|
|
if (security_inet_conn_request(sk, skb, req))
|
|
|
|
goto drop_and_release;
|
2006-07-25 00:32:50 -06:00
|
|
|
|
2014-05-11 21:22:13 -06:00
|
|
|
if (!dst && (dst = inet6_csk_route_req(sk, &fl6, req)) == NULL)
|
2009-12-02 11:07:39 -07:00
|
|
|
goto drop_and_free;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-05-11 21:22:13 -06:00
|
|
|
tcp_rsk(req)->snt_isn = isn;
|
2012-09-21 22:18:55 -06:00
|
|
|
tcp_rsk(req)->snt_synack = tcp_time_stamp;
|
2014-05-11 21:22:13 -06:00
|
|
|
tcp_openreq_init_rwin(req, sk, dst);
|
|
|
|
fastopen = !want_cookie &&
|
|
|
|
tcp_try_fastopen(sk, skb, req, &foc, dst);
|
|
|
|
err = tcp_v6_send_synack(sk, dst, &fl6, req,
|
|
|
|
skb_get_queue_mapping(skb), &foc);
|
|
|
|
if (!fastopen) {
|
|
|
|
if (err || want_cookie)
|
|
|
|
goto drop_and_free;
|
|
|
|
|
|
|
|
tcp_rsk(req)->listener = NULL;
|
|
|
|
inet6_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
|
|
|
|
}
|
2009-12-02 11:07:39 -07:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-12-02 13:14:29 -07:00
|
|
|
drop_and_release:
|
|
|
|
dst_release(dst);
|
2009-12-02 11:07:39 -07:00
|
|
|
drop_and_free:
|
|
|
|
reqsk_free(req);
|
2005-04-16 16:20:36 -06:00
|
|
|
drop:
|
2013-01-31 01:24:19 -07:00
|
|
|
NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0; /* don't send reset */
|
|
|
|
}
|
|
|
|
|
2013-12-19 03:44:34 -07:00
|
|
|
static struct sock *tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
|
|
|
|
struct request_sock *req,
|
|
|
|
struct dst_entry *dst)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-10-09 16:21:29 -06:00
|
|
|
struct inet_request_sock *ireq;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
|
|
|
|
struct tcp6_sock *newtcp6sk;
|
|
|
|
struct inet_sock *newinet;
|
|
|
|
struct tcp_sock *newtp;
|
|
|
|
struct sock *newsk;
|
2006-11-14 20:07:45 -07:00
|
|
|
#ifdef CONFIG_TCP_MD5SIG
|
|
|
|
struct tcp_md5sig_key *key;
|
|
|
|
#endif
|
2012-06-28 06:34:19 -06:00
|
|
|
struct flowi6 fl6;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (skb->protocol == htons(ETH_P_IP)) {
|
|
|
|
/*
|
|
|
|
* v6 mapped
|
|
|
|
*/
|
|
|
|
|
|
|
|
newsk = tcp_v4_syn_recv_sock(sk, skb, req, dst);
|
|
|
|
|
2007-02-09 07:24:49 -07:00
|
|
|
if (newsk == NULL)
|
2005-04-16 16:20:36 -06:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
newtcp6sk = (struct tcp6_sock *)newsk;
|
|
|
|
inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
|
|
|
|
|
|
|
|
newinet = inet_sk(newsk);
|
|
|
|
newnp = inet6_sk(newsk);
|
|
|
|
newtp = tcp_sk(newsk);
|
|
|
|
|
|
|
|
memcpy(newnp, np, sizeof(struct ipv6_pinfo));
|
|
|
|
|
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-03 16:42:29 -06:00
|
|
|
ipv6_addr_set_v4mapped(newinet->inet_daddr, &newsk->sk_v6_daddr);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-10-15 00:30:45 -06:00
|
|
|
ipv6_addr_set_v4mapped(newinet->inet_saddr, &newnp->saddr);
|
2005-04-16 16:20:36 -06: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-03 16:42:29 -06:00
|
|
|
newsk->sk_v6_rcv_saddr = newnp->saddr;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-12-14 00:15:52 -07:00
|
|
|
inet_csk(newsk)->icsk_af_ops = &ipv6_mapped;
|
2005-04-16 16:20:36 -06:00
|
|
|
newsk->sk_backlog_rcv = tcp_v4_do_rcv;
|
2006-11-14 20:07:45 -07:00
|
|
|
#ifdef CONFIG_TCP_MD5SIG
|
|
|
|
newtp->af_specific = &tcp_sock_ipv6_mapped_specific;
|
|
|
|
#endif
|
|
|
|
|
2011-09-24 20:21:30 -06:00
|
|
|
newnp->ipv6_ac_list = NULL;
|
|
|
|
newnp->ipv6_fl_list = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
newnp->pktoptions = NULL;
|
|
|
|
newnp->opt = NULL;
|
2005-08-12 06:19:38 -06:00
|
|
|
newnp->mcast_oif = inet6_iif(skb);
|
2007-04-25 18:54:47 -06:00
|
|
|
newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
|
2013-12-08 07:46:57 -07:00
|
|
|
newnp->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(skb));
|
2014-01-17 09:15:03 -07:00
|
|
|
if (np->repflow)
|
|
|
|
newnp->flow_label = ip6_flowlabel(ipv6_hdr(skb));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-08-09 20:45:38 -06:00
|
|
|
/*
|
|
|
|
* No need to charge this sock to the relevant IPv6 refcnt debug socks count
|
|
|
|
* here, tcp_create_openreq_child now does this for us, see the comment in
|
|
|
|
* that function for the gory details. -acme
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
/* It is tricky place. Until this moment IPv4 tcp
|
2005-12-14 00:15:52 -07:00
|
|
|
worked with IPv6 icsk.icsk_af_ops.
|
2005-04-16 16:20:36 -06:00
|
|
|
Sync it now.
|
|
|
|
*/
|
2005-12-14 00:26:10 -07:00
|
|
|
tcp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return newsk;
|
|
|
|
}
|
|
|
|
|
2013-10-09 16:21:29 -06:00
|
|
|
ireq = inet_rsk(req);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (sk_acceptq_is_full(sk))
|
|
|
|
goto out_overflow;
|
|
|
|
|
2010-12-02 13:14:29 -07:00
|
|
|
if (!dst) {
|
2012-06-28 06:34:19 -06:00
|
|
|
dst = inet6_csk_route_req(sk, &fl6, req);
|
2010-12-02 13:14:29 -07:00
|
|
|
if (!dst)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out;
|
2007-02-09 07:24:49 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
newsk = tcp_create_openreq_child(sk, req, skb);
|
|
|
|
if (newsk == NULL)
|
2010-10-21 05:06:43 -06:00
|
|
|
goto out_nonewsk;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-08-09 20:45:38 -06:00
|
|
|
/*
|
|
|
|
* No need to charge this sock to the relevant IPv6 refcnt debug socks
|
|
|
|
* count here, tcp_create_openreq_child now does this for us, see the
|
|
|
|
* comment in that function for the gory details. -acme
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-08-25 16:55:43 -06:00
|
|
|
newsk->sk_gso_type = SKB_GSO_TCPV6;
|
2006-08-29 18:15:09 -06:00
|
|
|
__ip6_dst_store(newsk, dst, NULL, NULL);
|
2012-08-18 21:30:38 -06:00
|
|
|
inet6_sk_rx_dst_set(newsk, skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
newtcp6sk = (struct tcp6_sock *)newsk;
|
|
|
|
inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
|
|
|
|
|
|
|
|
newtp = tcp_sk(newsk);
|
|
|
|
newinet = inet_sk(newsk);
|
|
|
|
newnp = inet6_sk(newsk);
|
|
|
|
|
|
|
|
memcpy(newnp, np, sizeof(struct ipv6_pinfo));
|
|
|
|
|
2013-10-09 16:21:29 -06:00
|
|
|
newsk->sk_v6_daddr = ireq->ir_v6_rmt_addr;
|
|
|
|
newnp->saddr = ireq->ir_v6_loc_addr;
|
|
|
|
newsk->sk_v6_rcv_saddr = ireq->ir_v6_loc_addr;
|
|
|
|
newsk->sk_bound_dev_if = ireq->ir_iif;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-09 07:24:49 -07:00
|
|
|
/* Now IPv6 options...
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
First: no IPv4 options.
|
|
|
|
*/
|
2011-04-21 03:45:37 -06:00
|
|
|
newinet->inet_opt = NULL;
|
2011-09-24 20:21:30 -06:00
|
|
|
newnp->ipv6_ac_list = NULL;
|
2007-03-16 17:14:03 -06:00
|
|
|
newnp->ipv6_fl_list = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Clone RX bits */
|
|
|
|
newnp->rxopt.all = np->rxopt.all;
|
|
|
|
|
|
|
|
/* Clone pktoptions received with SYN */
|
|
|
|
newnp->pktoptions = NULL;
|
2013-10-09 16:21:29 -06:00
|
|
|
if (ireq->pktopts != NULL) {
|
|
|
|
newnp->pktoptions = skb_clone(ireq->pktopts,
|
2012-07-31 17:44:14 -06:00
|
|
|
sk_gfp_atomic(sk, GFP_ATOMIC));
|
2013-10-09 16:21:29 -06:00
|
|
|
consume_skb(ireq->pktopts);
|
|
|
|
ireq->pktopts = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (newnp->pktoptions)
|
|
|
|
skb_set_owner_r(newnp->pktoptions, newsk);
|
|
|
|
}
|
|
|
|
newnp->opt = NULL;
|
2005-08-12 06:19:38 -06:00
|
|
|
newnp->mcast_oif = inet6_iif(skb);
|
2007-04-25 18:54:47 -06:00
|
|
|
newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
|
2013-12-08 07:46:57 -07:00
|
|
|
newnp->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(skb));
|
2014-01-17 09:15:03 -07:00
|
|
|
if (np->repflow)
|
|
|
|
newnp->flow_label = ip6_flowlabel(ipv6_hdr(skb));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Clone native IPv6 options from listening socket (if any)
|
|
|
|
|
|
|
|
Yes, keeping reference count would be much more clever,
|
|
|
|
but we make one more one thing there: reattach optmem
|
|
|
|
to newsk.
|
|
|
|
*/
|
2012-07-01 11:18:59 -06:00
|
|
|
if (np->opt)
|
|
|
|
newnp->opt = ipv6_dup_options(newsk, np->opt);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-12-14 00:26:10 -07:00
|
|
|
inet_csk(newsk)->icsk_ext_hdr_len = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (newnp->opt)
|
2005-12-14 00:26:10 -07:00
|
|
|
inet_csk(newsk)->icsk_ext_hdr_len = (newnp->opt->opt_nflen +
|
|
|
|
newnp->opt->opt_flen);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
tcp_sync_mss(newsk, dst_mtu(dst));
|
2010-12-13 13:52:14 -07:00
|
|
|
newtp->advmss = dst_metric_advmss(dst);
|
2012-04-22 03:45:47 -06:00
|
|
|
if (tcp_sk(sk)->rx_opt.user_mss &&
|
|
|
|
tcp_sk(sk)->rx_opt.user_mss < newtp->advmss)
|
|
|
|
newtp->advmss = tcp_sk(sk)->rx_opt.user_mss;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
tcp_initialize_rcv_mss(newsk);
|
|
|
|
|
2009-10-15 00:30:45 -06:00
|
|
|
newinet->inet_daddr = newinet->inet_saddr = LOOPBACK4_IPV6;
|
|
|
|
newinet->inet_rcv_saddr = LOOPBACK4_IPV6;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-11-14 20:07:45 -07:00
|
|
|
#ifdef CONFIG_TCP_MD5SIG
|
|
|
|
/* Copy over the MD5 key from the original socket */
|
2014-03-28 19:27:29 -06:00
|
|
|
key = tcp_v6_md5_do_lookup(sk, &newsk->sk_v6_daddr);
|
|
|
|
if (key != NULL) {
|
2006-11-14 20:07:45 -07:00
|
|
|
/* We're using one, so create a matching key
|
|
|
|
* on the newsk structure. If we fail to get
|
|
|
|
* memory, then we end up not copying the key
|
|
|
|
* across. Shucks.
|
|
|
|
*/
|
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-03 16:42:29 -06:00
|
|
|
tcp_md5_do_add(newsk, (union tcp_md5_addr *)&newsk->sk_v6_daddr,
|
2012-07-31 17:44:14 -06:00
|
|
|
AF_INET6, key->key, key->keylen,
|
|
|
|
sk_gfp_atomic(sk, GFP_ATOMIC));
|
2006-11-14 20:07:45 -07:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-10-21 05:06:43 -06:00
|
|
|
if (__inet_inherit_port(sk, newsk) < 0) {
|
inet: Fix kmemleak in tcp_v4/6_syn_recv_sock and dccp_v4/6_request_recv_sock
If in either of the above functions inet_csk_route_child_sock() or
__inet_inherit_port() fails, the newsk will not be freed:
unreferenced object 0xffff88022e8a92c0 (size 1592):
comm "softirq", pid 0, jiffies 4294946244 (age 726.160s)
hex dump (first 32 bytes):
0a 01 01 01 0a 01 01 02 00 00 00 00 a7 cc 16 00 ................
02 00 03 01 00 00 00 00 00 00 00 00 00 00 00 00 ................
backtrace:
[<ffffffff8153d190>] kmemleak_alloc+0x21/0x3e
[<ffffffff810ab3e7>] kmem_cache_alloc+0xb5/0xc5
[<ffffffff8149b65b>] sk_prot_alloc.isra.53+0x2b/0xcd
[<ffffffff8149b784>] sk_clone_lock+0x16/0x21e
[<ffffffff814d711a>] inet_csk_clone_lock+0x10/0x7b
[<ffffffff814ebbc3>] tcp_create_openreq_child+0x21/0x481
[<ffffffff814e8fa5>] tcp_v4_syn_recv_sock+0x3a/0x23b
[<ffffffff814ec5ba>] tcp_check_req+0x29f/0x416
[<ffffffff814e8e10>] tcp_v4_do_rcv+0x161/0x2bc
[<ffffffff814eb917>] tcp_v4_rcv+0x6c9/0x701
[<ffffffff814cea9f>] ip_local_deliver_finish+0x70/0xc4
[<ffffffff814cec20>] ip_local_deliver+0x4e/0x7f
[<ffffffff814ce9f8>] ip_rcv_finish+0x1fc/0x233
[<ffffffff814cee68>] ip_rcv+0x217/0x267
[<ffffffff814a7bbe>] __netif_receive_skb+0x49e/0x553
[<ffffffff814a7cc3>] netif_receive_skb+0x50/0x82
This happens, because sk_clone_lock initializes sk_refcnt to 2, and thus
a single sock_put() is not enough to free the memory. Additionally, things
like xfrm, memcg, cookie_values,... may have been initialized.
We have to free them properly.
This is fixed by forcing a call to tcp_done(), ending up in
inet_csk_destroy_sock, doing the final sock_put(). tcp_done() is necessary,
because it ends up doing all the cleanup on xfrm, memcg, cookie_values,
xfrm,...
Before calling tcp_done, we have to set the socket to SOCK_DEAD, to
force it entering inet_csk_destroy_sock. To avoid the warning in
inet_csk_destroy_sock, inet_num has to be set to 0.
As inet_csk_destroy_sock does a dec on orphan_count, we first have to
increase it.
Calling tcp_done() allows us to remove the calls to
tcp_clear_xmit_timer() and tcp_cleanup_congestion_control().
A similar approach is taken for dccp by calling dccp_done().
This is in the kernel since 093d282321 (tproxy: fix hash locking issue
when using port redirection in __inet_inherit_port()), thus since
version >= 2.6.37.
Signed-off-by: Christoph Paasch <christoph.paasch@uclouvain.be>
Signed-off-by: David S. Miller <davem@davemloft.net>
2012-12-13 21:07:58 -07:00
|
|
|
inet_csk_prepare_forced_close(newsk);
|
|
|
|
tcp_done(newsk);
|
2010-10-21 05:06:43 -06:00
|
|
|
goto out;
|
|
|
|
}
|
2009-12-03 20:46:54 -07:00
|
|
|
__inet6_hash(newsk, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return newsk;
|
|
|
|
|
|
|
|
out_overflow:
|
2008-07-16 21:31:16 -06:00
|
|
|
NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
|
2010-10-21 05:06:43 -06:00
|
|
|
out_nonewsk:
|
2005-04-16 16:20:36 -06:00
|
|
|
dst_release(dst);
|
2010-10-21 05:06:43 -06:00
|
|
|
out:
|
|
|
|
NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
|
2005-04-16 16:20:36 -06:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The socket must have it's spinlock held when we get
|
|
|
|
* here.
|
|
|
|
*
|
|
|
|
* We have a potential double-lock case here, so even when
|
|
|
|
* doing backlog processing we use the BH locking scheme.
|
|
|
|
* This is because we cannot sleep with the original spinlock
|
|
|
|
* held.
|
|
|
|
*/
|
|
|
|
static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct ipv6_pinfo *np = inet6_sk(sk);
|
|
|
|
struct tcp_sock *tp;
|
|
|
|
struct sk_buff *opt_skb = NULL;
|
|
|
|
|
|
|
|
/* Imagine: socket is IPv6. IPv4 packet arrives,
|
|
|
|
goes to IPv4 receive handler and backlogged.
|
|
|
|
From backlog it always goes here. Kerboom...
|
|
|
|
Fortunately, tcp_rcv_established and rcv_established
|
|
|
|
handle them correctly, but it is not case with
|
|
|
|
tcp_v6_hnd_req and tcp_v6_send_reset(). --ANK
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (skb->protocol == htons(ETH_P_IP))
|
|
|
|
return tcp_v4_do_rcv(sk, skb);
|
|
|
|
|
2006-11-14 20:07:45 -07:00
|
|
|
#ifdef CONFIG_TCP_MD5SIG
|
2014-03-28 19:27:29 -06:00
|
|
|
if (tcp_v6_inbound_md5_hash(sk, skb))
|
2006-11-14 20:07:45 -07:00
|
|
|
goto discard;
|
|
|
|
#endif
|
|
|
|
|
2006-08-31 16:28:39 -06:00
|
|
|
if (sk_filter(sk, skb))
|
2005-04-16 16:20:36 -06:00
|
|
|
goto discard;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* socket locking is here for SMP purposes as backlog rcv
|
|
|
|
* is currently called with bh processing disabled.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Do Stevens' IPV6_PKTOPTIONS.
|
|
|
|
|
|
|
|
Yes, guys, it is the only place in our code, where we
|
|
|
|
may make it not affecting IPv4.
|
|
|
|
The rest of code is protocol independent,
|
|
|
|
and I do not like idea to uglify IPv4.
|
|
|
|
|
|
|
|
Actually, all the idea behind IPV6_PKTOPTIONS
|
|
|
|
looks not very well thought. For now we latch
|
|
|
|
options, received in the last packet, enqueued
|
|
|
|
by tcp. Feel free to propose better solution.
|
2007-02-09 07:24:49 -07:00
|
|
|
--ANK (980728)
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
if (np->rxopt.all)
|
2012-07-31 17:44:14 -06:00
|
|
|
opt_skb = skb_clone(skb, sk_gfp_atomic(sk, GFP_ATOMIC));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
|
2012-08-05 23:09:33 -06:00
|
|
|
struct dst_entry *dst = sk->sk_rx_dst;
|
|
|
|
|
2011-08-14 13:45:55 -06:00
|
|
|
sock_rps_save_rxhash(sk, skb);
|
2012-08-05 23:09:33 -06:00
|
|
|
if (dst) {
|
|
|
|
if (inet_sk(sk)->rx_dst_ifindex != skb->skb_iif ||
|
|
|
|
dst->ops->check(dst, np->rx_dst_cookie) == NULL) {
|
|
|
|
dst_release(dst);
|
|
|
|
sk->sk_rx_dst = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-09-03 13:23:22 -06:00
|
|
|
tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (opt_skb)
|
|
|
|
goto ipv6_pktoptions;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-03-18 18:43:48 -06:00
|
|
|
if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
|
2005-04-16 16:20:36 -06:00
|
|
|
goto csum_err;
|
|
|
|
|
2007-02-09 07:24:49 -07:00
|
|
|
if (sk->sk_state == TCP_LISTEN) {
|
2005-04-16 16:20:36 -06:00
|
|
|
struct sock *nsk = tcp_v6_hnd_req(sk, skb);
|
|
|
|
if (!nsk)
|
|
|
|
goto discard;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Queue it on the new socket if the new socket is active,
|
|
|
|
* otherwise we just shortcircuit this and continue with
|
|
|
|
* the new socket..
|
|
|
|
*/
|
2013-12-19 03:44:34 -07:00
|
|
|
if (nsk != sk) {
|
2011-08-14 13:45:55 -06:00
|
|
|
sock_rps_save_rxhash(nsk, skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (tcp_child_process(sk, nsk, skb))
|
|
|
|
goto reset;
|
|
|
|
if (opt_skb)
|
|
|
|
__kfree_skb(opt_skb);
|
|
|
|
return 0;
|
|
|
|
}
|
2011-04-06 14:07:09 -06:00
|
|
|
} else
|
2011-08-14 13:45:55 -06:00
|
|
|
sock_rps_save_rxhash(sk, skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-04-10 22:04:22 -06:00
|
|
|
if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len))
|
2005-04-16 16:20:36 -06:00
|
|
|
goto reset;
|
|
|
|
if (opt_skb)
|
|
|
|
goto ipv6_pktoptions;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
reset:
|
2006-11-14 20:07:45 -07:00
|
|
|
tcp_v6_send_reset(sk, skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
discard:
|
|
|
|
if (opt_skb)
|
|
|
|
__kfree_skb(opt_skb);
|
|
|
|
kfree_skb(skb);
|
|
|
|
return 0;
|
|
|
|
csum_err:
|
2013-04-29 02:39:56 -06:00
|
|
|
TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_CSUMERRORS);
|
2008-07-16 21:22:25 -06:00
|
|
|
TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto discard;
|
|
|
|
|
|
|
|
|
|
|
|
ipv6_pktoptions:
|
|
|
|
/* Do you ask, what is it?
|
|
|
|
|
|
|
|
1. skb was enqueued by tcp.
|
|
|
|
2. skb is added to tail of read queue, rather than out of order.
|
|
|
|
3. socket is not in passive state.
|
|
|
|
4. Finally, it really contains options, which user wants to receive.
|
|
|
|
*/
|
|
|
|
tp = tcp_sk(sk);
|
|
|
|
if (TCP_SKB_CB(opt_skb)->end_seq == tp->rcv_nxt &&
|
|
|
|
!((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) {
|
[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-07 18:59:17 -06:00
|
|
|
if (np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo)
|
2005-08-12 06:19:38 -06:00
|
|
|
np->mcast_oif = inet6_iif(opt_skb);
|
[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-07 18:59:17 -06:00
|
|
|
if (np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim)
|
2007-04-25 18:54:47 -06:00
|
|
|
np->mcast_hops = ipv6_hdr(opt_skb)->hop_limit;
|
2013-12-08 07:46:59 -07:00
|
|
|
if (np->rxopt.bits.rxflow || np->rxopt.bits.rxtclass)
|
2013-12-08 07:46:57 -07:00
|
|
|
np->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(opt_skb));
|
2014-01-17 09:15:03 -07:00
|
|
|
if (np->repflow)
|
|
|
|
np->flow_label = ip6_flowlabel(ipv6_hdr(opt_skb));
|
2005-04-16 16:20:36 -06:00
|
|
|
if (ipv6_opt_accepted(sk, opt_skb)) {
|
|
|
|
skb_set_owner_r(opt_skb, sk);
|
|
|
|
opt_skb = xchg(&np->pktoptions, opt_skb);
|
|
|
|
} else {
|
|
|
|
__kfree_skb(opt_skb);
|
|
|
|
opt_skb = xchg(&np->pktoptions, NULL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-02-23 14:45:33 -07:00
|
|
|
kfree_skb(opt_skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-10-15 13:50:28 -06:00
|
|
|
static int tcp_v6_rcv(struct sk_buff *skb)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-10-21 03:22:42 -06:00
|
|
|
const struct tcphdr *th;
|
2011-04-21 22:53:02 -06:00
|
|
|
const struct ipv6hdr *hdr;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct sock *sk;
|
|
|
|
int ret;
|
2008-07-16 21:20:58 -06:00
|
|
|
struct net *net = dev_net(skb->dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (skb->pkt_type != PACKET_HOST)
|
|
|
|
goto discard_it;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Count it even if it's bad.
|
|
|
|
*/
|
2008-07-16 21:22:25 -06:00
|
|
|
TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
|
|
|
|
goto discard_it;
|
|
|
|
|
2007-04-10 22:04:22 -06:00
|
|
|
th = tcp_hdr(skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (th->doff < sizeof(struct tcphdr)/4)
|
|
|
|
goto bad_packet;
|
|
|
|
if (!pskb_may_pull(skb, th->doff*4))
|
|
|
|
goto discard_it;
|
|
|
|
|
2014-05-02 17:29:51 -06:00
|
|
|
if (skb_checksum_init(skb, IPPROTO_TCP, ip6_compute_pseudo))
|
2013-04-29 02:39:56 -06:00
|
|
|
goto csum_error;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-04-10 22:04:22 -06:00
|
|
|
th = tcp_hdr(skb);
|
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-22 16:24:53 -06:00
|
|
|
hdr = ipv6_hdr(skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
TCP_SKB_CB(skb)->seq = ntohl(th->seq);
|
|
|
|
TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
|
|
|
|
skb->len - th->doff*4);
|
|
|
|
TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
|
|
|
|
TCP_SKB_CB(skb)->when = 0;
|
2011-09-27 00:20:08 -06:00
|
|
|
TCP_SKB_CB(skb)->ip_dsfield = ipv6_get_dsfield(hdr);
|
2005-04-16 16:20:36 -06:00
|
|
|
TCP_SKB_CB(skb)->sacked = 0;
|
|
|
|
|
2008-10-07 12:41:57 -06:00
|
|
|
sk = __inet6_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!sk)
|
|
|
|
goto no_tcp_socket;
|
|
|
|
|
|
|
|
process:
|
|
|
|
if (sk->sk_state == TCP_TIME_WAIT)
|
|
|
|
goto do_time_wait;
|
|
|
|
|
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-22 16:24:53 -06:00
|
|
|
if (hdr->hop_limit < inet6_sk(sk)->min_hopcount) {
|
|
|
|
NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
|
|
|
|
goto discard_and_relse;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
|
|
|
|
goto discard_and_relse;
|
|
|
|
|
2006-08-31 16:28:39 -06:00
|
|
|
if (sk_filter(sk, skb))
|
2005-04-16 16:20:36 -06:00
|
|
|
goto discard_and_relse;
|
|
|
|
|
2013-07-10 08:13:26 -06:00
|
|
|
sk_mark_napi_id(sk, skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
skb->dev = NULL;
|
|
|
|
|
2006-09-25 23:28:47 -06:00
|
|
|
bh_lock_sock_nested(sk);
|
2005-04-16 16:20:36 -06:00
|
|
|
ret = 0;
|
|
|
|
if (!sock_owned_by_user(sk)) {
|
2006-05-23 19:05:53 -06:00
|
|
|
#ifdef CONFIG_NET_DMA
|
2007-02-09 07:24:49 -07:00
|
|
|
struct tcp_sock *tp = tcp_sk(sk);
|
2007-10-26 05:20:13 -06:00
|
|
|
if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
|
2012-04-04 17:10:46 -06:00
|
|
|
tp->ucopy.dma_chan = net_dma_find_channel();
|
2007-02-09 07:24:49 -07:00
|
|
|
if (tp->ucopy.dma_chan)
|
|
|
|
ret = tcp_v6_do_rcv(sk, skb);
|
|
|
|
else
|
2006-05-23 19:05:53 -06:00
|
|
|
#endif
|
|
|
|
{
|
|
|
|
if (!tcp_prequeue(sk, skb))
|
|
|
|
ret = tcp_v6_do_rcv(sk, skb);
|
|
|
|
}
|
2012-04-22 17:38:54 -06:00
|
|
|
} else if (unlikely(sk_add_backlog(sk, skb,
|
|
|
|
sk->sk_rcvbuf + sk->sk_sndbuf))) {
|
2010-03-04 11:01:41 -07:00
|
|
|
bh_unlock_sock(sk);
|
2010-03-07 16:21:57 -07:00
|
|
|
NET_INC_STATS_BH(net, LINUX_MIB_TCPBACKLOGDROP);
|
2010-03-04 11:01:41 -07:00
|
|
|
goto discard_and_relse;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
bh_unlock_sock(sk);
|
|
|
|
|
|
|
|
sock_put(sk);
|
|
|
|
return ret ? -1 : 0;
|
|
|
|
|
|
|
|
no_tcp_socket:
|
|
|
|
if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
|
|
|
|
goto discard_it;
|
|
|
|
|
|
|
|
if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
|
2013-04-29 02:39:56 -06:00
|
|
|
csum_error:
|
|
|
|
TCP_INC_STATS_BH(net, TCP_MIB_CSUMERRORS);
|
2005-04-16 16:20:36 -06:00
|
|
|
bad_packet:
|
2008-07-16 21:22:25 -06:00
|
|
|
TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2006-11-14 20:07:45 -07:00
|
|
|
tcp_v6_send_reset(NULL, skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
discard_it:
|
|
|
|
kfree_skb(skb);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
discard_and_relse:
|
|
|
|
sock_put(sk);
|
|
|
|
goto discard_it;
|
|
|
|
|
|
|
|
do_time_wait:
|
|
|
|
if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
|
2006-10-10 20:41:46 -06:00
|
|
|
inet_twsk_put(inet_twsk(sk));
|
2005-04-16 16:20:36 -06:00
|
|
|
goto discard_it;
|
|
|
|
}
|
|
|
|
|
2013-04-29 02:39:56 -06:00
|
|
|
if (skb->len < (th->doff<<2)) {
|
2006-10-10 20:41:46 -06:00
|
|
|
inet_twsk_put(inet_twsk(sk));
|
2013-04-29 02:39:56 -06:00
|
|
|
goto bad_packet;
|
|
|
|
}
|
|
|
|
if (tcp_checksum_complete(skb)) {
|
|
|
|
inet_twsk_put(inet_twsk(sk));
|
|
|
|
goto csum_error;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-10-10 20:41:46 -06:00
|
|
|
switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
case TCP_TW_SYN:
|
|
|
|
{
|
|
|
|
struct sock *sk2;
|
|
|
|
|
2008-03-25 06:47:49 -06:00
|
|
|
sk2 = inet6_lookup_listener(dev_net(skb->dev), &tcp_hashinfo,
|
2013-01-22 02:50:39 -07:00
|
|
|
&ipv6_hdr(skb)->saddr, th->source,
|
2007-04-25 18:54:47 -06:00
|
|
|
&ipv6_hdr(skb)->daddr,
|
2005-08-12 06:19:38 -06:00
|
|
|
ntohs(th->dest), inet6_iif(skb));
|
2005-04-16 16:20:36 -06:00
|
|
|
if (sk2 != NULL) {
|
2005-08-09 21:44:40 -06:00
|
|
|
struct inet_timewait_sock *tw = inet_twsk(sk);
|
|
|
|
inet_twsk_deschedule(tw, &tcp_death_row);
|
|
|
|
inet_twsk_put(tw);
|
2005-04-16 16:20:36 -06:00
|
|
|
sk = sk2;
|
|
|
|
goto process;
|
|
|
|
}
|
|
|
|
/* Fall through to ACK */
|
|
|
|
}
|
|
|
|
case TCP_TW_ACK:
|
|
|
|
tcp_v6_timewait_ack(sk, skb);
|
|
|
|
break;
|
|
|
|
case TCP_TW_RST:
|
|
|
|
goto no_tcp_socket;
|
2014-03-28 19:27:29 -06:00
|
|
|
case TCP_TW_SUCCESS:
|
|
|
|
;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
goto discard_it;
|
|
|
|
}
|
|
|
|
|
2012-07-26 06:18:11 -06:00
|
|
|
static void tcp_v6_early_demux(struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
const struct ipv6hdr *hdr;
|
|
|
|
const struct tcphdr *th;
|
|
|
|
struct sock *sk;
|
|
|
|
|
|
|
|
if (skb->pkt_type != PACKET_HOST)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!pskb_may_pull(skb, skb_transport_offset(skb) + sizeof(struct tcphdr)))
|
|
|
|
return;
|
|
|
|
|
|
|
|
hdr = ipv6_hdr(skb);
|
|
|
|
th = tcp_hdr(skb);
|
|
|
|
|
|
|
|
if (th->doff < sizeof(struct tcphdr) / 4)
|
|
|
|
return;
|
|
|
|
|
|
|
|
sk = __inet6_lookup_established(dev_net(skb->dev), &tcp_hashinfo,
|
|
|
|
&hdr->saddr, th->source,
|
|
|
|
&hdr->daddr, ntohs(th->dest),
|
|
|
|
inet6_iif(skb));
|
|
|
|
if (sk) {
|
|
|
|
skb->sk = sk;
|
|
|
|
skb->destructor = sock_edemux;
|
|
|
|
if (sk->sk_state != TCP_TIME_WAIT) {
|
|
|
|
struct dst_entry *dst = sk->sk_rx_dst;
|
2012-10-22 15:41:48 -06:00
|
|
|
|
2012-07-26 06:18:11 -06:00
|
|
|
if (dst)
|
2012-08-05 23:09:33 -06:00
|
|
|
dst = dst_check(dst, inet6_sk(sk)->rx_dst_cookie);
|
2012-07-26 06:18:11 -06:00
|
|
|
if (dst &&
|
2012-10-22 15:41:48 -06:00
|
|
|
inet_sk(sk)->rx_dst_ifindex == skb->skb_iif)
|
2012-07-26 06:18:11 -06:00
|
|
|
skb_dst_set_noref(skb, dst);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-12-01 19:09:13 -07:00
|
|
|
static struct timewait_sock_ops tcp6_timewait_sock_ops = {
|
|
|
|
.twsk_obj_size = sizeof(struct tcp6_timewait_sock),
|
|
|
|
.twsk_unique = tcp_twsk_unique,
|
2014-03-28 19:27:29 -06:00
|
|
|
.twsk_destructor = tcp_twsk_destructor,
|
2010-12-01 19:09:13 -07:00
|
|
|
};
|
|
|
|
|
2009-09-01 13:25:04 -06:00
|
|
|
static const struct inet_connection_sock_af_ops ipv6_specific = {
|
2006-03-20 23:48:35 -07:00
|
|
|
.queue_xmit = inet6_csk_xmit,
|
|
|
|
.send_check = tcp_v6_send_check,
|
|
|
|
.rebuild_header = inet6_sk_rebuild_header,
|
2012-08-05 23:09:33 -06:00
|
|
|
.sk_rx_dst_set = inet6_sk_rx_dst_set,
|
2006-03-20 23:48:35 -07:00
|
|
|
.conn_request = tcp_v6_conn_request,
|
|
|
|
.syn_recv_sock = tcp_v6_syn_recv_sock,
|
|
|
|
.net_header_len = sizeof(struct ipv6hdr),
|
ipv6: RTAX_FEATURE_ALLFRAG causes inefficient TCP segment sizing
Quoting Tore Anderson from :
https://bugzilla.kernel.org/show_bug.cgi?id=42572
When RTAX_FEATURE_ALLFRAG is set on a route, the effective TCP segment
size does not take into account the size of the IPv6 Fragmentation
header that needs to be included in outbound packets, causing every
transmitted TCP segment to be fragmented across two IPv6 packets, the
latter of which will only contain 8 bytes of actual payload.
RTAX_FEATURE_ALLFRAG is typically set on a route in response to
receving a ICMPv6 Packet Too Big message indicating a Path MTU of less
than 1280 bytes. 1280 bytes is the minimum IPv6 MTU, however ICMPv6
PTBs with MTU < 1280 are still valid, in particular when an IPv6
packet is sent to an IPv4 destination through a stateless translator.
Any ICMPv4 Need To Fragment packets originated from the IPv4 part of
the path will be translated to ICMPv6 PTB which may then indicate an
MTU of less than 1280.
The Linux kernel refuses to reduce the effective MTU to anything below
1280 bytes, instead it sets it to exactly 1280 bytes, and
RTAX_FEATURE_ALLFRAG is also set. However, the TCP segment size appears
to be set to 1240 bytes (1280 Path MTU - 40 bytes of IPv6 header),
instead of 1232 (additionally taking into account the 8 bytes required
by the IPv6 Fragmentation extension header).
This in turn results in rather inefficient transmission, as every
transmitted TCP segment now is split in two fragments containing
1232+8 bytes of payload.
After this patch, all the outgoing packets that includes a
Fragmentation header all are "atomic" or "non-fragmented" fragments,
i.e., they both have Offset=0 and More Fragments=0.
With help from David S. Miller
Reported-by: Tore Anderson <tore@fud.no>
Signed-off-by: Eric Dumazet <edumazet@google.com>
Cc: Maciej Żenczykowski <maze@google.com>
Cc: Tom Herbert <therbert@google.com>
Tested-by: Tore Anderson <tore@fud.no>
Signed-off-by: David S. Miller <davem@davemloft.net>
2012-04-24 01:37:38 -06:00
|
|
|
.net_frag_header_len = sizeof(struct frag_hdr),
|
2006-03-20 23:48:35 -07:00
|
|
|
.setsockopt = ipv6_setsockopt,
|
|
|
|
.getsockopt = ipv6_getsockopt,
|
|
|
|
.addr2sockaddr = inet6_csk_addr2sockaddr,
|
|
|
|
.sockaddr_len = sizeof(struct sockaddr_in6),
|
[SOCK] proto: Add hashinfo member to struct proto
This way we can remove TCP and DCCP specific versions of
sk->sk_prot->get_port: both v4 and v6 use inet_csk_get_port
sk->sk_prot->hash: inet_hash is directly used, only v6 need
a specific version to deal with mapped sockets
sk->sk_prot->unhash: both v4 and v6 use inet_hash directly
struct inet_connection_sock_af_ops also gets a new member, bind_conflict, so
that inet_csk_get_port can find the per family routine.
Now only the lookup routines receive as a parameter a struct inet_hashtable.
With this we further reuse code, reducing the difference among INET transport
protocols.
Eventually work has to be done on UDP and SCTP to make them share this
infrastructure and get as a bonus inet_diag interfaces so that iproute can be
used with these protocols.
net-2.6/net/ipv4/inet_hashtables.c:
struct proto | +8
struct inet_connection_sock_af_ops | +8
2 structs changed
__inet_hash_nolisten | +18
__inet_hash | -210
inet_put_port | +8
inet_bind_bucket_create | +1
__inet_hash_connect | -8
5 functions changed, 27 bytes added, 218 bytes removed, diff: -191
net-2.6/net/core/sock.c:
proto_seq_show | +3
1 function changed, 3 bytes added, diff: +3
net-2.6/net/ipv4/inet_connection_sock.c:
inet_csk_get_port | +15
1 function changed, 15 bytes added, diff: +15
net-2.6/net/ipv4/tcp.c:
tcp_set_state | -7
1 function changed, 7 bytes removed, diff: -7
net-2.6/net/ipv4/tcp_ipv4.c:
tcp_v4_get_port | -31
tcp_v4_hash | -48
tcp_v4_destroy_sock | -7
tcp_v4_syn_recv_sock | -2
tcp_unhash | -179
5 functions changed, 267 bytes removed, diff: -267
net-2.6/net/ipv6/inet6_hashtables.c:
__inet6_hash | +8
1 function changed, 8 bytes added, diff: +8
net-2.6/net/ipv4/inet_hashtables.c:
inet_unhash | +190
inet_hash | +242
2 functions changed, 432 bytes added, diff: +432
vmlinux:
16 functions changed, 485 bytes added, 492 bytes removed, diff: -7
/home/acme/git/net-2.6/net/ipv6/tcp_ipv6.c:
tcp_v6_get_port | -31
tcp_v6_hash | -7
tcp_v6_syn_recv_sock | -9
3 functions changed, 47 bytes removed, diff: -47
/home/acme/git/net-2.6/net/dccp/proto.c:
dccp_destroy_sock | -7
dccp_unhash | -179
dccp_hash | -49
dccp_set_state | -7
dccp_done | +1
5 functions changed, 1 bytes added, 242 bytes removed, diff: -241
/home/acme/git/net-2.6/net/dccp/ipv4.c:
dccp_v4_get_port | -31
dccp_v4_request_recv_sock | -2
2 functions changed, 33 bytes removed, diff: -33
/home/acme/git/net-2.6/net/dccp/ipv6.c:
dccp_v6_get_port | -31
dccp_v6_hash | -7
dccp_v6_request_recv_sock | +5
3 functions changed, 5 bytes added, 38 bytes removed, diff: -33
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-02-03 05:06:04 -07:00
|
|
|
.bind_conflict = inet6_csk_bind_conflict,
|
2006-03-20 23:45:21 -07:00
|
|
|
#ifdef CONFIG_COMPAT
|
2006-03-20 23:48:35 -07:00
|
|
|
.compat_setsockopt = compat_ipv6_setsockopt,
|
|
|
|
.compat_getsockopt = compat_ipv6_getsockopt,
|
2006-03-20 23:45:21 -07:00
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2006-11-14 20:07:45 -07:00
|
|
|
#ifdef CONFIG_TCP_MD5SIG
|
2009-09-01 13:25:03 -06:00
|
|
|
static const struct tcp_sock_af_ops tcp_sock_ipv6_specific = {
|
2006-11-14 20:07:45 -07:00
|
|
|
.md5_lookup = tcp_v6_md5_lookup,
|
2008-07-19 01:01:42 -06:00
|
|
|
.calc_md5_hash = tcp_v6_md5_hash_skb,
|
2006-11-14 20:07:45 -07:00
|
|
|
.md5_parse = tcp_v6_parse_md5_keys,
|
|
|
|
};
|
2006-11-14 20:53:22 -07:00
|
|
|
#endif
|
2006-11-14 20:07:45 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* TCP over IPv4 via INET6 API
|
|
|
|
*/
|
2009-09-01 13:25:04 -06:00
|
|
|
static const struct inet_connection_sock_af_ops ipv6_mapped = {
|
2006-03-20 23:48:35 -07:00
|
|
|
.queue_xmit = ip_queue_xmit,
|
|
|
|
.send_check = tcp_v4_send_check,
|
|
|
|
.rebuild_header = inet_sk_rebuild_header,
|
2012-08-09 08:11:00 -06:00
|
|
|
.sk_rx_dst_set = inet_sk_rx_dst_set,
|
2006-03-20 23:48:35 -07:00
|
|
|
.conn_request = tcp_v6_conn_request,
|
|
|
|
.syn_recv_sock = tcp_v6_syn_recv_sock,
|
|
|
|
.net_header_len = sizeof(struct iphdr),
|
|
|
|
.setsockopt = ipv6_setsockopt,
|
|
|
|
.getsockopt = ipv6_getsockopt,
|
|
|
|
.addr2sockaddr = inet6_csk_addr2sockaddr,
|
|
|
|
.sockaddr_len = sizeof(struct sockaddr_in6),
|
[SOCK] proto: Add hashinfo member to struct proto
This way we can remove TCP and DCCP specific versions of
sk->sk_prot->get_port: both v4 and v6 use inet_csk_get_port
sk->sk_prot->hash: inet_hash is directly used, only v6 need
a specific version to deal with mapped sockets
sk->sk_prot->unhash: both v4 and v6 use inet_hash directly
struct inet_connection_sock_af_ops also gets a new member, bind_conflict, so
that inet_csk_get_port can find the per family routine.
Now only the lookup routines receive as a parameter a struct inet_hashtable.
With this we further reuse code, reducing the difference among INET transport
protocols.
Eventually work has to be done on UDP and SCTP to make them share this
infrastructure and get as a bonus inet_diag interfaces so that iproute can be
used with these protocols.
net-2.6/net/ipv4/inet_hashtables.c:
struct proto | +8
struct inet_connection_sock_af_ops | +8
2 structs changed
__inet_hash_nolisten | +18
__inet_hash | -210
inet_put_port | +8
inet_bind_bucket_create | +1
__inet_hash_connect | -8
5 functions changed, 27 bytes added, 218 bytes removed, diff: -191
net-2.6/net/core/sock.c:
proto_seq_show | +3
1 function changed, 3 bytes added, diff: +3
net-2.6/net/ipv4/inet_connection_sock.c:
inet_csk_get_port | +15
1 function changed, 15 bytes added, diff: +15
net-2.6/net/ipv4/tcp.c:
tcp_set_state | -7
1 function changed, 7 bytes removed, diff: -7
net-2.6/net/ipv4/tcp_ipv4.c:
tcp_v4_get_port | -31
tcp_v4_hash | -48
tcp_v4_destroy_sock | -7
tcp_v4_syn_recv_sock | -2
tcp_unhash | -179
5 functions changed, 267 bytes removed, diff: -267
net-2.6/net/ipv6/inet6_hashtables.c:
__inet6_hash | +8
1 function changed, 8 bytes added, diff: +8
net-2.6/net/ipv4/inet_hashtables.c:
inet_unhash | +190
inet_hash | +242
2 functions changed, 432 bytes added, diff: +432
vmlinux:
16 functions changed, 485 bytes added, 492 bytes removed, diff: -7
/home/acme/git/net-2.6/net/ipv6/tcp_ipv6.c:
tcp_v6_get_port | -31
tcp_v6_hash | -7
tcp_v6_syn_recv_sock | -9
3 functions changed, 47 bytes removed, diff: -47
/home/acme/git/net-2.6/net/dccp/proto.c:
dccp_destroy_sock | -7
dccp_unhash | -179
dccp_hash | -49
dccp_set_state | -7
dccp_done | +1
5 functions changed, 1 bytes added, 242 bytes removed, diff: -241
/home/acme/git/net-2.6/net/dccp/ipv4.c:
dccp_v4_get_port | -31
dccp_v4_request_recv_sock | -2
2 functions changed, 33 bytes removed, diff: -33
/home/acme/git/net-2.6/net/dccp/ipv6.c:
dccp_v6_get_port | -31
dccp_v6_hash | -7
dccp_v6_request_recv_sock | +5
3 functions changed, 5 bytes added, 38 bytes removed, diff: -33
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-02-03 05:06:04 -07:00
|
|
|
.bind_conflict = inet6_csk_bind_conflict,
|
2006-03-20 23:45:21 -07:00
|
|
|
#ifdef CONFIG_COMPAT
|
2006-03-20 23:48:35 -07:00
|
|
|
.compat_setsockopt = compat_ipv6_setsockopt,
|
|
|
|
.compat_getsockopt = compat_ipv6_getsockopt,
|
2006-03-20 23:45:21 -07:00
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2006-11-14 20:07:45 -07:00
|
|
|
#ifdef CONFIG_TCP_MD5SIG
|
2009-09-01 13:25:03 -06:00
|
|
|
static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific = {
|
2006-11-14 20:07:45 -07:00
|
|
|
.md5_lookup = tcp_v4_md5_lookup,
|
2008-07-19 01:01:42 -06:00
|
|
|
.calc_md5_hash = tcp_v4_md5_hash_skb,
|
2006-11-14 20:07:45 -07:00
|
|
|
.md5_parse = tcp_v6_parse_md5_keys,
|
|
|
|
};
|
2006-11-14 20:53:22 -07:00
|
|
|
#endif
|
2006-11-14 20:07:45 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* NOTE: A lot of things set to zero explicitly by call to
|
|
|
|
* sk_alloc() so need not be done here.
|
|
|
|
*/
|
|
|
|
static int tcp_v6_init_sock(struct sock *sk)
|
|
|
|
{
|
2005-08-10 01:03:31 -06:00
|
|
|
struct inet_connection_sock *icsk = inet_csk(sk);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-04-19 03:55:21 -06:00
|
|
|
tcp_init_sock(sk);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-12-14 00:15:52 -07:00
|
|
|
icsk->icsk_af_ops = &ipv6_specific;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-11-14 20:07:45 -07:00
|
|
|
#ifdef CONFIG_TCP_MD5SIG
|
2012-04-23 01:21:58 -06:00
|
|
|
tcp_sk(sk)->af_specific = &tcp_sock_ipv6_specific;
|
2006-11-14 20:07:45 -07:00
|
|
|
#endif
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-06-14 18:04:49 -06:00
|
|
|
static void tcp_v6_destroy_sock(struct sock *sk)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
tcp_v4_destroy_sock(sk);
|
2008-06-14 18:04:49 -06:00
|
|
|
inet6_destroy_sock(sk);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-04-21 05:13:44 -06:00
|
|
|
#ifdef CONFIG_PROC_FS
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Proc filesystem TCPv6 sock list dumping. */
|
2007-02-09 07:24:49 -07:00
|
|
|
static void get_openreq6(struct seq_file *seq,
|
2012-05-24 01:10:10 -06:00
|
|
|
const struct sock *sk, struct request_sock *req, int i, kuid_t uid)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int ttd = req->expires - jiffies;
|
2013-10-09 16:21:29 -06:00
|
|
|
const struct in6_addr *src = &inet_rsk(req)->ir_v6_loc_addr;
|
|
|
|
const struct in6_addr *dest = &inet_rsk(req)->ir_v6_rmt_addr;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (ttd < 0)
|
|
|
|
ttd = 0;
|
|
|
|
|
|
|
|
seq_printf(seq,
|
|
|
|
"%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
|
2013-08-15 05:42:14 -06:00
|
|
|
"%02X %08X:%08X %02X:%08lX %08X %5u %8d %d %d %pK\n",
|
2005-04-16 16:20:36 -06:00
|
|
|
i,
|
|
|
|
src->s6_addr32[0], src->s6_addr32[1],
|
|
|
|
src->s6_addr32[2], src->s6_addr32[3],
|
2013-10-10 01:04:37 -06:00
|
|
|
inet_rsk(req)->ir_num,
|
2005-04-16 16:20:36 -06:00
|
|
|
dest->s6_addr32[0], dest->s6_addr32[1],
|
|
|
|
dest->s6_addr32[2], dest->s6_addr32[3],
|
2013-10-09 16:21:29 -06:00
|
|
|
ntohs(inet_rsk(req)->ir_rmt_port),
|
2005-04-16 16:20:36 -06:00
|
|
|
TCP_SYN_RECV,
|
2013-12-19 03:44:34 -07:00
|
|
|
0, 0, /* could print option size, but that is af dependent. */
|
2007-02-09 07:24:49 -07:00
|
|
|
1, /* timers active (only the expire timer) */
|
|
|
|
jiffies_to_clock_t(ttd),
|
2012-10-27 17:16:46 -06:00
|
|
|
req->num_timeout,
|
2012-05-24 01:10:10 -06:00
|
|
|
from_kuid_munged(seq_user_ns(seq), uid),
|
2007-02-09 07:24:49 -07:00
|
|
|
0, /* non standard timer */
|
2005-04-16 16:20:36 -06:00
|
|
|
0, /* open_requests have no inode */
|
|
|
|
0, req);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i)
|
|
|
|
{
|
2011-04-21 22:53:02 -06:00
|
|
|
const struct in6_addr *dest, *src;
|
2005-04-16 16:20:36 -06:00
|
|
|
__u16 destp, srcp;
|
|
|
|
int timer_active;
|
|
|
|
unsigned long timer_expires;
|
2011-10-21 03:22:42 -06:00
|
|
|
const struct inet_sock *inet = inet_sk(sp);
|
|
|
|
const struct tcp_sock *tp = tcp_sk(sp);
|
2005-08-09 21:10:42 -06:00
|
|
|
const struct inet_connection_sock *icsk = inet_csk(sp);
|
2014-05-11 21:22:12 -06:00
|
|
|
struct fastopen_queue *fastopenq = icsk->icsk_accept_queue.fastopenq;
|
2005-04-16 16:20:36 -06: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-03 16:42:29 -06:00
|
|
|
dest = &sp->sk_v6_daddr;
|
|
|
|
src = &sp->sk_v6_rcv_saddr;
|
2009-10-15 00:30:45 -06:00
|
|
|
destp = ntohs(inet->inet_dport);
|
|
|
|
srcp = ntohs(inet->inet_sport);
|
2005-08-09 21:10:42 -06:00
|
|
|
|
|
|
|
if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
|
2005-04-16 16:20:36 -06:00
|
|
|
timer_active = 1;
|
2005-08-09 21:10:42 -06:00
|
|
|
timer_expires = icsk->icsk_timeout;
|
|
|
|
} else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
|
2005-04-16 16:20:36 -06:00
|
|
|
timer_active = 4;
|
2005-08-09 21:10:42 -06:00
|
|
|
timer_expires = icsk->icsk_timeout;
|
2005-04-16 16:20:36 -06:00
|
|
|
} else if (timer_pending(&sp->sk_timer)) {
|
|
|
|
timer_active = 2;
|
|
|
|
timer_expires = sp->sk_timer.expires;
|
|
|
|
} else {
|
|
|
|
timer_active = 0;
|
|
|
|
timer_expires = jiffies;
|
|
|
|
}
|
|
|
|
|
|
|
|
seq_printf(seq,
|
|
|
|
"%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
|
2013-08-15 05:42:14 -06:00
|
|
|
"%02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %lu %lu %u %u %d\n",
|
2005-04-16 16:20:36 -06:00
|
|
|
i,
|
|
|
|
src->s6_addr32[0], src->s6_addr32[1],
|
|
|
|
src->s6_addr32[2], src->s6_addr32[3], srcp,
|
|
|
|
dest->s6_addr32[0], dest->s6_addr32[1],
|
|
|
|
dest->s6_addr32[2], dest->s6_addr32[3], destp,
|
2007-02-09 07:24:49 -07:00
|
|
|
sp->sk_state,
|
2006-06-27 14:29:00 -06:00
|
|
|
tp->write_seq-tp->snd_una,
|
|
|
|
(sp->sk_state == TCP_LISTEN) ? sp->sk_ack_backlog : (tp->rcv_nxt - tp->copied_seq),
|
2005-04-16 16:20:36 -06:00
|
|
|
timer_active,
|
2012-08-08 15:13:53 -06:00
|
|
|
jiffies_delta_to_clock_t(timer_expires - jiffies),
|
2005-08-09 21:10:42 -06:00
|
|
|
icsk->icsk_retransmits,
|
2012-05-24 01:10:10 -06:00
|
|
|
from_kuid_munged(seq_user_ns(seq), sock_i_uid(sp)),
|
2005-08-10 01:03:31 -06:00
|
|
|
icsk->icsk_probes_out,
|
2005-04-16 16:20:36 -06:00
|
|
|
sock_i_ino(sp),
|
|
|
|
atomic_read(&sp->sk_refcnt), sp,
|
2008-06-27 21:00:19 -06:00
|
|
|
jiffies_to_clock_t(icsk->icsk_rto),
|
|
|
|
jiffies_to_clock_t(icsk->icsk_ack.ato),
|
2013-12-19 03:44:34 -07:00
|
|
|
(icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
|
2009-09-15 02:30:10 -06:00
|
|
|
tp->snd_cwnd,
|
2014-05-11 21:22:12 -06:00
|
|
|
sp->sk_state == TCP_LISTEN ?
|
|
|
|
(fastopenq ? fastopenq->max_qlen : 0) :
|
|
|
|
(tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh)
|
2005-04-16 16:20:36 -06:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2007-02-09 07:24:49 -07:00
|
|
|
static void get_timewait6_sock(struct seq_file *seq,
|
2005-08-09 21:09:30 -06:00
|
|
|
struct inet_timewait_sock *tw, int i)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-04-21 22:53:02 -06:00
|
|
|
const struct in6_addr *dest, *src;
|
2005-04-16 16:20:36 -06:00
|
|
|
__u16 destp, srcp;
|
2013-10-03 15:27:25 -06:00
|
|
|
s32 delta = tw->tw_ttd - inet_tw_time_stamp();
|
2005-04-16 16:20:36 -06: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-03 16:42:29 -06:00
|
|
|
dest = &tw->tw_v6_daddr;
|
|
|
|
src = &tw->tw_v6_rcv_saddr;
|
2005-04-16 16:20:36 -06:00
|
|
|
destp = ntohs(tw->tw_dport);
|
|
|
|
srcp = ntohs(tw->tw_sport);
|
|
|
|
|
|
|
|
seq_printf(seq,
|
|
|
|
"%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
|
net: convert %p usage to %pK
The %pK format specifier is designed to hide exposed kernel pointers,
specifically via /proc interfaces. Exposing these pointers provides an
easy target for kernel write vulnerabilities, since they reveal the
locations of writable structures containing easily triggerable function
pointers. The behavior of %pK depends on the kptr_restrict sysctl.
If kptr_restrict is set to 0, no deviation from the standard %p behavior
occurs. If kptr_restrict is set to 1, the default, if the current user
(intended to be a reader via seq_printf(), etc.) does not have CAP_SYSLOG
(currently in the LSM tree), kernel pointers using %pK are printed as 0's.
If kptr_restrict is set to 2, kernel pointers using %pK are printed as
0's regardless of privileges. Replacing with 0's was chosen over the
default "(null)", which cannot be parsed by userland %p, which expects
"(nil)".
The supporting code for kptr_restrict and %pK are currently in the -mm
tree. This patch converts users of %p in net/ to %pK. Cases of printing
pointers to the syslog are not covered, since this would eliminate useful
information for postmortem debugging and the reading of the syslog is
already optionally protected by the dmesg_restrict sysctl.
Signed-off-by: Dan Rosenberg <drosenberg@vsecurity.com>
Cc: James Morris <jmorris@namei.org>
Cc: Eric Dumazet <eric.dumazet@gmail.com>
Cc: Thomas Graf <tgraf@infradead.org>
Cc: Eugene Teo <eugeneteo@kernel.org>
Cc: Kees Cook <kees.cook@canonical.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David S. Miller <davem@davemloft.net>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Eric Paris <eparis@parisplace.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2011-05-23 06:17:35 -06:00
|
|
|
"%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK\n",
|
2005-04-16 16:20:36 -06:00
|
|
|
i,
|
|
|
|
src->s6_addr32[0], src->s6_addr32[1],
|
|
|
|
src->s6_addr32[2], src->s6_addr32[3], srcp,
|
|
|
|
dest->s6_addr32[0], dest->s6_addr32[1],
|
|
|
|
dest->s6_addr32[2], dest->s6_addr32[3], destp,
|
|
|
|
tw->tw_substate, 0, 0,
|
2012-08-08 15:13:53 -06:00
|
|
|
3, jiffies_delta_to_clock_t(delta), 0, 0, 0, 0,
|
2005-04-16 16:20:36 -06:00
|
|
|
atomic_read(&tw->tw_refcnt), tw);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int tcp6_seq_show(struct seq_file *seq, void *v)
|
|
|
|
{
|
|
|
|
struct tcp_iter_state *st;
|
tcp/dccp: remove twchain
TCP listener refactoring, part 3 :
Our goal is to hash SYN_RECV sockets into main ehash for fast lookup,
and parallel SYN processing.
Current inet_ehash_bucket contains two chains, one for ESTABLISH (and
friend states) sockets, another for TIME_WAIT sockets only.
As the hash table is sized to get at most one socket per bucket, it
makes little sense to have separate twchain, as it makes the lookup
slightly more complicated, and doubles hash table memory usage.
If we make sure all socket types have the lookup keys at the same
offsets, we can use a generic and faster lookup. It turns out TIME_WAIT
and ESTABLISHED sockets already have common lookup fields for IPv4.
[ INET_TW_MATCH() is no longer needed ]
I'll provide a follow-up to factorize IPv6 lookup as well, to remove
INET6_TW_MATCH()
This way, SYN_RECV pseudo sockets will be supported the same.
A new sock_gen_put() helper is added, doing either a sock_put() or
inet_twsk_put() [ and will support SYN_RECV later ].
Note this helper should only be called in real slow path, when rcu
lookup found a socket that was moved to another identity (freed/reused
immediately), but could eventually be used in other contexts, like
sock_edemux()
Before patch :
dmesg | grep "TCP established"
TCP established hash table entries: 524288 (order: 11, 8388608 bytes)
After patch :
TCP established hash table entries: 524288 (order: 10, 4194304 bytes)
Signed-off-by: Eric Dumazet <edumazet@google.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-10-03 01:22:02 -06:00
|
|
|
struct sock *sk = v;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (v == SEQ_START_TOKEN) {
|
|
|
|
seq_puts(seq,
|
|
|
|
" sl "
|
|
|
|
"local_address "
|
|
|
|
"remote_address "
|
|
|
|
"st tx_queue rx_queue tr tm->when retrnsmt"
|
|
|
|
" uid timeout inode\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
st = seq->private;
|
|
|
|
|
|
|
|
switch (st->state) {
|
|
|
|
case TCP_SEQ_STATE_LISTENING:
|
|
|
|
case TCP_SEQ_STATE_ESTABLISHED:
|
tcp/dccp: remove twchain
TCP listener refactoring, part 3 :
Our goal is to hash SYN_RECV sockets into main ehash for fast lookup,
and parallel SYN processing.
Current inet_ehash_bucket contains two chains, one for ESTABLISH (and
friend states) sockets, another for TIME_WAIT sockets only.
As the hash table is sized to get at most one socket per bucket, it
makes little sense to have separate twchain, as it makes the lookup
slightly more complicated, and doubles hash table memory usage.
If we make sure all socket types have the lookup keys at the same
offsets, we can use a generic and faster lookup. It turns out TIME_WAIT
and ESTABLISHED sockets already have common lookup fields for IPv4.
[ INET_TW_MATCH() is no longer needed ]
I'll provide a follow-up to factorize IPv6 lookup as well, to remove
INET6_TW_MATCH()
This way, SYN_RECV pseudo sockets will be supported the same.
A new sock_gen_put() helper is added, doing either a sock_put() or
inet_twsk_put() [ and will support SYN_RECV later ].
Note this helper should only be called in real slow path, when rcu
lookup found a socket that was moved to another identity (freed/reused
immediately), but could eventually be used in other contexts, like
sock_edemux()
Before patch :
dmesg | grep "TCP established"
TCP established hash table entries: 524288 (order: 11, 8388608 bytes)
After patch :
TCP established hash table entries: 524288 (order: 10, 4194304 bytes)
Signed-off-by: Eric Dumazet <edumazet@google.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-10-03 01:22:02 -06:00
|
|
|
if (sk->sk_state == TCP_TIME_WAIT)
|
|
|
|
get_timewait6_sock(seq, v, st->num);
|
|
|
|
else
|
|
|
|
get_tcp6_sock(seq, v, st->num);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case TCP_SEQ_STATE_OPENREQ:
|
|
|
|
get_openreq6(seq, st->syn_wait_sk, v, st->num, st->uid);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-10-30 00:46:30 -06:00
|
|
|
static const struct file_operations tcp6_afinfo_seq_fops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = tcp_seq_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = seq_release_net
|
|
|
|
};
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static struct tcp_seq_afinfo tcp6_seq_afinfo = {
|
|
|
|
.name = "tcp6",
|
|
|
|
.family = AF_INET6,
|
2011-10-30 00:46:30 -06:00
|
|
|
.seq_fops = &tcp6_afinfo_seq_fops,
|
2008-04-13 23:12:13 -06:00
|
|
|
.seq_ops = {
|
|
|
|
.show = tcp6_seq_show,
|
|
|
|
},
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2010-01-16 20:35:32 -07:00
|
|
|
int __net_init tcp6_proc_init(struct net *net)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-03-21 05:14:45 -06:00
|
|
|
return tcp_proc_register(net, &tcp6_seq_afinfo);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-03-21 05:14:45 -06:00
|
|
|
void tcp6_proc_exit(struct net *net)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-03-21 05:14:45 -06:00
|
|
|
tcp_proc_unregister(net, &tcp6_seq_afinfo);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2013-05-09 04:28:16 -06:00
|
|
|
static void tcp_v6_clear_sk(struct sock *sk, int size)
|
|
|
|
{
|
|
|
|
struct inet_sock *inet = inet_sk(sk);
|
|
|
|
|
|
|
|
/* we do not want to clear pinet6 field, because of RCU lookups */
|
|
|
|
sk_prot_clear_nulls(sk, offsetof(struct inet_sock, pinet6));
|
|
|
|
|
|
|
|
size -= offsetof(struct inet_sock, pinet6) + sizeof(inet->pinet6);
|
|
|
|
memset(&inet->pinet6 + 1, 0, size);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
struct proto tcpv6_prot = {
|
|
|
|
.name = "TCPv6",
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.close = tcp_close,
|
|
|
|
.connect = tcp_v6_connect,
|
|
|
|
.disconnect = tcp_disconnect,
|
2005-08-09 21:10:42 -06:00
|
|
|
.accept = inet_csk_accept,
|
2005-04-16 16:20:36 -06:00
|
|
|
.ioctl = tcp_ioctl,
|
|
|
|
.init = tcp_v6_init_sock,
|
|
|
|
.destroy = tcp_v6_destroy_sock,
|
|
|
|
.shutdown = tcp_shutdown,
|
|
|
|
.setsockopt = tcp_setsockopt,
|
|
|
|
.getsockopt = tcp_getsockopt,
|
|
|
|
.recvmsg = tcp_recvmsg,
|
2010-07-10 14:41:55 -06:00
|
|
|
.sendmsg = tcp_sendmsg,
|
|
|
|
.sendpage = tcp_sendpage,
|
2005-04-16 16:20:36 -06:00
|
|
|
.backlog_rcv = tcp_v6_do_rcv,
|
tcp: TCP Small Queues
This introduce TSQ (TCP Small Queues)
TSQ goal is to reduce number of TCP packets in xmit queues (qdisc &
device queues), to reduce RTT and cwnd bias, part of the bufferbloat
problem.
sk->sk_wmem_alloc not allowed to grow above a given limit,
allowing no more than ~128KB [1] per tcp socket in qdisc/dev layers at a
given time.
TSO packets are sized/capped to half the limit, so that we have two
TSO packets in flight, allowing better bandwidth use.
As a side effect, setting the limit to 40000 automatically reduces the
standard gso max limit (65536) to 40000/2 : It can help to reduce
latencies of high prio packets, having smaller TSO packets.
This means we divert sock_wfree() to a tcp_wfree() handler, to
queue/send following frames when skb_orphan() [2] is called for the
already queued skbs.
Results on my dev machines (tg3/ixgbe nics) are really impressive,
using standard pfifo_fast, and with or without TSO/GSO.
Without reduction of nominal bandwidth, we have reduction of buffering
per bulk sender :
< 1ms on Gbit (instead of 50ms with TSO)
< 8ms on 100Mbit (instead of 132 ms)
I no longer have 4 MBytes backlogged in qdisc by a single netperf
session, and both side socket autotuning no longer use 4 Mbytes.
As skb destructor cannot restart xmit itself ( as qdisc lock might be
taken at this point ), we delegate the work to a tasklet. We use one
tasklest per cpu for performance reasons.
If tasklet finds a socket owned by the user, it sets TSQ_OWNED flag.
This flag is tested in a new protocol method called from release_sock(),
to eventually send new segments.
[1] New /proc/sys/net/ipv4/tcp_limit_output_bytes tunable
[2] skb_orphan() is usually called at TX completion time,
but some drivers call it in their start_xmit() handler.
These drivers should at least use BQL, or else a single TCP
session can still fill the whole NIC TX ring, since TSQ will
have no effect.
Signed-off-by: Eric Dumazet <edumazet@google.com>
Cc: Dave Taht <dave.taht@bufferbloat.net>
Cc: Tom Herbert <therbert@google.com>
Cc: Matt Mathis <mattmathis@google.com>
Cc: Yuchung Cheng <ycheng@google.com>
Cc: Nandita Dukkipati <nanditad@google.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2012-07-10 23:50:31 -06:00
|
|
|
.release_cb = tcp_release_cb,
|
2012-07-23 01:48:52 -06:00
|
|
|
.mtu_reduced = tcp_v6_mtu_reduced,
|
2005-04-16 16:20:36 -06:00
|
|
|
.hash = tcp_v6_hash,
|
[SOCK] proto: Add hashinfo member to struct proto
This way we can remove TCP and DCCP specific versions of
sk->sk_prot->get_port: both v4 and v6 use inet_csk_get_port
sk->sk_prot->hash: inet_hash is directly used, only v6 need
a specific version to deal with mapped sockets
sk->sk_prot->unhash: both v4 and v6 use inet_hash directly
struct inet_connection_sock_af_ops also gets a new member, bind_conflict, so
that inet_csk_get_port can find the per family routine.
Now only the lookup routines receive as a parameter a struct inet_hashtable.
With this we further reuse code, reducing the difference among INET transport
protocols.
Eventually work has to be done on UDP and SCTP to make them share this
infrastructure and get as a bonus inet_diag interfaces so that iproute can be
used with these protocols.
net-2.6/net/ipv4/inet_hashtables.c:
struct proto | +8
struct inet_connection_sock_af_ops | +8
2 structs changed
__inet_hash_nolisten | +18
__inet_hash | -210
inet_put_port | +8
inet_bind_bucket_create | +1
__inet_hash_connect | -8
5 functions changed, 27 bytes added, 218 bytes removed, diff: -191
net-2.6/net/core/sock.c:
proto_seq_show | +3
1 function changed, 3 bytes added, diff: +3
net-2.6/net/ipv4/inet_connection_sock.c:
inet_csk_get_port | +15
1 function changed, 15 bytes added, diff: +15
net-2.6/net/ipv4/tcp.c:
tcp_set_state | -7
1 function changed, 7 bytes removed, diff: -7
net-2.6/net/ipv4/tcp_ipv4.c:
tcp_v4_get_port | -31
tcp_v4_hash | -48
tcp_v4_destroy_sock | -7
tcp_v4_syn_recv_sock | -2
tcp_unhash | -179
5 functions changed, 267 bytes removed, diff: -267
net-2.6/net/ipv6/inet6_hashtables.c:
__inet6_hash | +8
1 function changed, 8 bytes added, diff: +8
net-2.6/net/ipv4/inet_hashtables.c:
inet_unhash | +190
inet_hash | +242
2 functions changed, 432 bytes added, diff: +432
vmlinux:
16 functions changed, 485 bytes added, 492 bytes removed, diff: -7
/home/acme/git/net-2.6/net/ipv6/tcp_ipv6.c:
tcp_v6_get_port | -31
tcp_v6_hash | -7
tcp_v6_syn_recv_sock | -9
3 functions changed, 47 bytes removed, diff: -47
/home/acme/git/net-2.6/net/dccp/proto.c:
dccp_destroy_sock | -7
dccp_unhash | -179
dccp_hash | -49
dccp_set_state | -7
dccp_done | +1
5 functions changed, 1 bytes added, 242 bytes removed, diff: -241
/home/acme/git/net-2.6/net/dccp/ipv4.c:
dccp_v4_get_port | -31
dccp_v4_request_recv_sock | -2
2 functions changed, 33 bytes removed, diff: -33
/home/acme/git/net-2.6/net/dccp/ipv6.c:
dccp_v6_get_port | -31
dccp_v6_hash | -7
dccp_v6_request_recv_sock | +5
3 functions changed, 5 bytes added, 38 bytes removed, diff: -33
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-02-03 05:06:04 -07:00
|
|
|
.unhash = inet_unhash,
|
|
|
|
.get_port = inet_csk_get_port,
|
2005-04-16 16:20:36 -06:00
|
|
|
.enter_memory_pressure = tcp_enter_memory_pressure,
|
tcp: TCP_NOTSENT_LOWAT socket option
Idea of this patch is to add optional limitation of number of
unsent bytes in TCP sockets, to reduce usage of kernel memory.
TCP receiver might announce a big window, and TCP sender autotuning
might allow a large amount of bytes in write queue, but this has little
performance impact if a large part of this buffering is wasted :
Write queue needs to be large only to deal with large BDP, not
necessarily to cope with scheduling delays (incoming ACKS make room
for the application to queue more bytes)
For most workloads, using a value of 128 KB or less is OK to give
applications enough time to react to POLLOUT events in time
(or being awaken in a blocking sendmsg())
This patch adds two ways to set the limit :
1) Per socket option TCP_NOTSENT_LOWAT
2) A sysctl (/proc/sys/net/ipv4/tcp_notsent_lowat) for sockets
not using TCP_NOTSENT_LOWAT socket option (or setting a zero value)
Default value being UINT_MAX (0xFFFFFFFF), meaning this has no effect.
This changes poll()/select()/epoll() to report POLLOUT
only if number of unsent bytes is below tp->nosent_lowat
Note this might increase number of sendmsg()/sendfile() calls
when using non blocking sockets,
and increase number of context switches for blocking sockets.
Note this is not related to SO_SNDLOWAT (as SO_SNDLOWAT is
defined as :
Specify the minimum number of bytes in the buffer until
the socket layer will pass the data to the protocol)
Tested:
netperf sessions, and watching /proc/net/protocols "memory" column for TCP
With 200 concurrent netperf -t TCP_STREAM sessions, amount of kernel memory
used by TCP buffers shrinks by ~55 % (20567 pages instead of 45458)
lpq83:~# echo -1 >/proc/sys/net/ipv4/tcp_notsent_lowat
lpq83:~# (super_netperf 200 -t TCP_STREAM -H remote -l 90 &); sleep 60 ; grep TCP /proc/net/protocols
TCPv6 1880 2 45458 no 208 yes ipv6 y y y y y y y y y y y y y n y y y y y
TCP 1696 508 45458 no 208 yes kernel y y y y y y y y y y y y y n y y y y y
lpq83:~# echo 131072 >/proc/sys/net/ipv4/tcp_notsent_lowat
lpq83:~# (super_netperf 200 -t TCP_STREAM -H remote -l 90 &); sleep 60 ; grep TCP /proc/net/protocols
TCPv6 1880 2 20567 no 208 yes ipv6 y y y y y y y y y y y y y n y y y y y
TCP 1696 508 20567 no 208 yes kernel y y y y y y y y y y y y y n y y y y y
Using 128KB has no bad effect on the throughput or cpu usage
of a single flow, although there is an increase of context switches.
A bonus is that we hold socket lock for a shorter amount
of time and should improve latencies of ACK processing.
lpq83:~# echo -1 >/proc/sys/net/ipv4/tcp_notsent_lowat
lpq83:~# perf stat -e context-switches ./netperf -H 7.7.7.84 -t omni -l 20 -c -i10,3
OMNI Send TEST from 0.0.0.0 (0.0.0.0) port 0 AF_INET to 7.7.7.84 () port 0 AF_INET : +/-2.500% @ 99% conf.
Local Remote Local Elapsed Throughput Throughput Local Local Remote Remote Local Remote Service
Send Socket Recv Socket Send Time Units CPU CPU CPU CPU Service Service Demand
Size Size Size (sec) Util Util Util Util Demand Demand Units
Final Final % Method % Method
1651584 6291456 16384 20.00 17447.90 10^6bits/s 3.13 S -1.00 U 0.353 -1.000 usec/KB
Performance counter stats for './netperf -H 7.7.7.84 -t omni -l 20 -c -i10,3':
412,514 context-switches
200.034645535 seconds time elapsed
lpq83:~# echo 131072 >/proc/sys/net/ipv4/tcp_notsent_lowat
lpq83:~# perf stat -e context-switches ./netperf -H 7.7.7.84 -t omni -l 20 -c -i10,3
OMNI Send TEST from 0.0.0.0 (0.0.0.0) port 0 AF_INET to 7.7.7.84 () port 0 AF_INET : +/-2.500% @ 99% conf.
Local Remote Local Elapsed Throughput Throughput Local Local Remote Remote Local Remote Service
Send Socket Recv Socket Send Time Units CPU CPU CPU CPU Service Service Demand
Size Size Size (sec) Util Util Util Util Demand Demand Units
Final Final % Method % Method
1593240 6291456 16384 20.00 17321.16 10^6bits/s 3.35 S -1.00 U 0.381 -1.000 usec/KB
Performance counter stats for './netperf -H 7.7.7.84 -t omni -l 20 -c -i10,3':
2,675,818 context-switches
200.029651391 seconds time elapsed
Signed-off-by: Eric Dumazet <edumazet@google.com>
Cc: Neal Cardwell <ncardwell@google.com>
Cc: Yuchung Cheng <ycheng@google.com>
Acked-By: Yuchung Cheng <ycheng@google.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-07-22 21:27:07 -06:00
|
|
|
.stream_memory_free = tcp_stream_memory_free,
|
2005-04-16 16:20:36 -06:00
|
|
|
.sockets_allocated = &tcp_sockets_allocated,
|
|
|
|
.memory_allocated = &tcp_memory_allocated,
|
|
|
|
.memory_pressure = &tcp_memory_pressure,
|
2005-08-09 21:11:41 -06:00
|
|
|
.orphan_count = &tcp_orphan_count,
|
2013-10-19 17:25:36 -06:00
|
|
|
.sysctl_mem = sysctl_tcp_mem,
|
2005-04-16 16:20:36 -06:00
|
|
|
.sysctl_wmem = sysctl_tcp_wmem,
|
|
|
|
.sysctl_rmem = sysctl_tcp_rmem,
|
|
|
|
.max_header = MAX_TCP_HEADER,
|
|
|
|
.obj_size = sizeof(struct tcp6_sock),
|
2008-11-16 20:40:17 -07:00
|
|
|
.slab_flags = SLAB_DESTROY_BY_RCU,
|
2005-12-14 00:25:19 -07:00
|
|
|
.twsk_prot = &tcp6_timewait_sock_ops,
|
2005-06-18 23:47:21 -06:00
|
|
|
.rsk_prot = &tcp6_request_sock_ops,
|
2008-03-22 17:50:58 -06:00
|
|
|
.h.hashinfo = &tcp_hashinfo,
|
2010-07-10 14:41:55 -06:00
|
|
|
.no_autobind = true,
|
2006-03-20 23:48:35 -07:00
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
.compat_setsockopt = compat_tcp_setsockopt,
|
|
|
|
.compat_getsockopt = compat_tcp_getsockopt,
|
|
|
|
#endif
|
2012-07-31 17:43:02 -06:00
|
|
|
#ifdef CONFIG_MEMCG_KMEM
|
2011-12-11 14:47:04 -07:00
|
|
|
.proto_cgroup = tcp_proto_cgroup,
|
|
|
|
#endif
|
2013-05-09 04:28:16 -06:00
|
|
|
.clear_sk = tcp_v6_clear_sk,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2009-09-14 06:22:28 -06:00
|
|
|
static const struct inet6_protocol tcpv6_protocol = {
|
2012-07-26 06:18:11 -06:00
|
|
|
.early_demux = tcp_v6_early_demux,
|
2005-04-16 16:20:36 -06:00
|
|
|
.handler = tcp_v6_rcv,
|
|
|
|
.err_handler = tcp_v6_err,
|
|
|
|
.flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct inet_protosw tcpv6_protosw = {
|
|
|
|
.type = SOCK_STREAM,
|
|
|
|
.protocol = IPPROTO_TCP,
|
|
|
|
.prot = &tcpv6_prot,
|
|
|
|
.ops = &inet6_stream_ops,
|
2005-12-14 00:26:10 -07:00
|
|
|
.flags = INET_PROTOSW_PERMANENT |
|
|
|
|
INET_PROTOSW_ICSK,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2010-01-16 20:35:32 -07:00
|
|
|
static int __net_init tcpv6_net_init(struct net *net)
|
2008-03-07 12:16:02 -07:00
|
|
|
{
|
2008-04-03 15:28:30 -06:00
|
|
|
return inet_ctl_sock_create(&net->ipv6.tcp_sk, PF_INET6,
|
|
|
|
SOCK_RAW, IPPROTO_TCP, net);
|
2008-03-07 12:16:02 -07:00
|
|
|
}
|
|
|
|
|
2010-01-16 20:35:32 -07:00
|
|
|
static void __net_exit tcpv6_net_exit(struct net *net)
|
2008-03-07 12:16:02 -07:00
|
|
|
{
|
2008-04-03 15:28:30 -06:00
|
|
|
inet_ctl_sock_destroy(net->ipv6.tcp_sk);
|
2009-12-02 19:29:09 -07:00
|
|
|
}
|
|
|
|
|
2010-01-16 20:35:32 -07:00
|
|
|
static void __net_exit tcpv6_net_exit_batch(struct list_head *net_exit_list)
|
2009-12-02 19:29:09 -07:00
|
|
|
{
|
|
|
|
inet_twsk_purge(&tcp_hashinfo, &tcp_death_row, AF_INET6);
|
2008-03-07 12:16:02 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct pernet_operations tcpv6_net_ops = {
|
2009-12-02 19:29:09 -07:00
|
|
|
.init = tcpv6_net_init,
|
|
|
|
.exit = tcpv6_net_exit,
|
|
|
|
.exit_batch = tcpv6_net_exit_batch,
|
2008-03-07 12:16:02 -07:00
|
|
|
};
|
|
|
|
|
2007-12-11 03:25:35 -07:00
|
|
|
int __init tcpv6_init(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-12-11 03:25:35 -07:00
|
|
|
int ret;
|
|
|
|
|
2012-11-15 01:49:15 -07:00
|
|
|
ret = inet6_add_protocol(&tcpv6_protocol, IPPROTO_TCP);
|
|
|
|
if (ret)
|
2012-11-15 01:49:22 -07:00
|
|
|
goto out;
|
2012-11-15 01:49:15 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* register inet6 protocol */
|
2007-12-11 03:25:35 -07:00
|
|
|
ret = inet6_register_protosw(&tcpv6_protosw);
|
|
|
|
if (ret)
|
|
|
|
goto out_tcpv6_protocol;
|
|
|
|
|
2008-03-07 12:16:02 -07:00
|
|
|
ret = register_pernet_subsys(&tcpv6_net_ops);
|
2007-12-11 03:25:35 -07:00
|
|
|
if (ret)
|
|
|
|
goto out_tcpv6_protosw;
|
|
|
|
out:
|
|
|
|
return ret;
|
2006-01-11 16:53:04 -07:00
|
|
|
|
2007-12-11 03:25:35 -07:00
|
|
|
out_tcpv6_protosw:
|
|
|
|
inet6_unregister_protosw(&tcpv6_protosw);
|
2012-11-15 01:49:15 -07:00
|
|
|
out_tcpv6_protocol:
|
|
|
|
inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
|
2007-12-11 03:25:35 -07:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2007-12-13 06:34:58 -07:00
|
|
|
void tcpv6_exit(void)
|
2007-12-11 03:25:35 -07:00
|
|
|
{
|
2008-03-07 12:16:02 -07:00
|
|
|
unregister_pernet_subsys(&tcpv6_net_ops);
|
2007-12-11 03:25:35 -07:00
|
|
|
inet6_unregister_protosw(&tcpv6_protosw);
|
|
|
|
inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|