blob: 9c16565b70cc56b9b796f1b98ab8399831f65a42 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * TCP over IPv6
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09003 * Linux INET6 implementation
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
5 * Authors:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09006 * Pedro Roque <roque@di.fc.ul.pt>
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 *
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09008 * Based on:
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 * linux/net/ipv4/tcp.c
10 * linux/net/ipv4/tcp_input.c
11 * linux/net/ipv4/tcp_output.c
12 *
13 * Fixes:
14 * Hideaki YOSHIFUJI : sin6_scope_id support
15 * YOSHIFUJI Hideaki @USAGI and: Support IPV6_V6ONLY socket option, which
16 * Alexey Kuznetsov allow both IPv4 and IPv6 sockets to bind
17 * a single port at the same time.
18 * YOSHIFUJI Hideaki @USAGI: convert /proc/net/tcp6 to seq_file.
19 *
20 * This program is free software; you can redistribute it and/or
21 * modify it under the terms of the GNU General Public License
22 * as published by the Free Software Foundation; either version
23 * 2 of the License, or (at your option) any later version.
24 */
25
Herbert Xueb4dea52008-12-29 23:04:08 -080026#include <linux/bottom_half.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/errno.h>
29#include <linux/types.h>
30#include <linux/socket.h>
31#include <linux/sockios.h>
32#include <linux/net.h>
33#include <linux/jiffies.h>
34#include <linux/in.h>
35#include <linux/in6.h>
36#include <linux/netdevice.h>
37#include <linux/init.h>
38#include <linux/jhash.h>
39#include <linux/ipsec.h>
40#include <linux/times.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090041#include <linux/slab.h>
Wang Yufen4aa956d2014-03-29 09:27:29 +080042#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include <linux/ipv6.h>
44#include <linux/icmpv6.h>
45#include <linux/random.h>
46
47#include <net/tcp.h>
48#include <net/ndisc.h>
Arnaldo Carvalho de Melo5324a042005-08-12 09:26:18 -030049#include <net/inet6_hashtables.h>
Arnaldo Carvalho de Melo81297652005-12-13 23:15:24 -080050#include <net/inet6_connection_sock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#include <net/ipv6.h>
52#include <net/transp_v6.h>
53#include <net/addrconf.h>
54#include <net/ip6_route.h>
55#include <net/ip6_checksum.h>
56#include <net/inet_ecn.h>
57#include <net/protocol.h>
58#include <net/xfrm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070059#include <net/snmp.h>
60#include <net/dsfield.h>
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -080061#include <net/timewait_sock.h>
Denis V. Lunev3d58b5f2008-04-03 14:22:32 -070062#include <net/inet_common.h>
David S. Miller6e5714e2011-08-03 20:50:44 -070063#include <net/secure_seq.h>
Eliezer Tamir076bb0c2013-07-10 17:13:17 +030064#include <net/busy_poll.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
Linus Torvalds1da177e2005-04-16 15:20:36 -070066#include <linux/proc_fs.h>
67#include <linux/seq_file.h>
68
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080069#include <linux/crypto.h>
70#include <linux/scatterlist.h>
71
Eric Dumazeta00e7442015-09-29 07:42:39 -070072static void tcp_v6_send_reset(const struct sock *sk, struct sk_buff *skb);
73static void tcp_v6_reqsk_send_ack(const struct sock *sk, struct sk_buff *skb,
Gui Jianfeng6edafaa2008-08-06 23:50:04 -070074 struct request_sock *req);
Linus Torvalds1da177e2005-04-16 15:20:36 -070075
76static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
Stephen Hemminger3b401a82009-09-01 19:25:04 +000078static const struct inet_connection_sock_af_ops ipv6_mapped;
79static const struct inet_connection_sock_af_ops ipv6_specific;
David S. Millera9286302006-11-14 19:53:22 -080080#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +000081static const struct tcp_sock_af_ops tcp_sock_ipv6_specific;
82static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific;
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +090083#else
Eric Dumazet51723932015-09-29 21:24:05 -070084static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(const struct sock *sk,
Eric Dumazetb71d1d42011-04-22 04:53:02 +000085 const struct in6_addr *addr)
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +090086{
87 return NULL;
88}
David S. Millera9286302006-11-14 19:53:22 -080089#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070090
Neal Cardwellfae6ef82012-08-19 03:30:38 +000091static void inet6_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb)
92{
93 struct dst_entry *dst = skb_dst(skb);
Neal Cardwellfae6ef82012-08-19 03:30:38 +000094
Eric Dumazet5037e9e2015-12-14 14:08:53 -080095 if (dst && dst_hold_safe(dst)) {
Eric Dumazetca777ef2014-09-08 08:06:07 -070096 const struct rt6_info *rt = (const struct rt6_info *)dst;
97
Eric Dumazetca777ef2014-09-08 08:06:07 -070098 sk->sk_rx_dst = dst;
99 inet_sk(sk)->rx_dst_ifindex = skb->skb_iif;
Martin KaFai Laub197df42015-05-22 20:56:01 -0700100 inet6_sk(sk)->rx_dst_cookie = rt6_get_cookie(rt);
Eric Dumazetca777ef2014-09-08 08:06:07 -0700101 }
Neal Cardwellfae6ef82012-08-19 03:30:38 +0000102}
103
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400104static __u32 tcp_v6_init_sequence(const struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105{
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700106 return secure_tcpv6_sequence_number(ipv6_hdr(skb)->daddr.s6_addr32,
107 ipv6_hdr(skb)->saddr.s6_addr32,
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700108 tcp_hdr(skb)->dest,
109 tcp_hdr(skb)->source);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110}
111
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900112static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 int addr_len)
114{
115 struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900116 struct inet_sock *inet = inet_sk(sk);
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800117 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118 struct ipv6_pinfo *np = inet6_sk(sk);
119 struct tcp_sock *tp = tcp_sk(sk);
Arnaud Ebalard20c59de2010-06-01 21:35:01 +0000120 struct in6_addr *saddr = NULL, *final_p, final;
Eric Dumazet45f6fad2015-11-29 19:37:57 -0800121 struct ipv6_txoptions *opt;
David S. Miller4c9483b2011-03-12 16:22:43 -0500122 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 struct dst_entry *dst;
124 int addr_type;
125 int err;
126
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900127 if (addr_len < SIN6_LEN_RFC2133)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 return -EINVAL;
129
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900130 if (usin->sin6_family != AF_INET6)
Eric Dumazeta02cec22010-09-22 20:43:57 +0000131 return -EAFNOSUPPORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132
David S. Miller4c9483b2011-03-12 16:22:43 -0500133 memset(&fl6, 0, sizeof(fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134
135 if (np->sndflow) {
David S. Miller4c9483b2011-03-12 16:22:43 -0500136 fl6.flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK;
137 IP6_ECN_flow_init(fl6.flowlabel);
138 if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 struct ip6_flowlabel *flowlabel;
David S. Miller4c9483b2011-03-12 16:22:43 -0500140 flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
Ian Morris63159f22015-03-29 14:00:04 +0100141 if (!flowlabel)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 fl6_sock_release(flowlabel);
144 }
145 }
146
147 /*
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900148 * connect() to INADDR_ANY means loopback (BSD'ism).
149 */
150
Weilong Chen4c99aa42013-12-19 18:44:34 +0800151 if (ipv6_addr_any(&usin->sin6_addr))
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900152 usin->sin6_addr.s6_addr[15] = 0x1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153
154 addr_type = ipv6_addr_type(&usin->sin6_addr);
155
Weilong Chen4c99aa42013-12-19 18:44:34 +0800156 if (addr_type & IPV6_ADDR_MULTICAST)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 return -ENETUNREACH;
158
159 if (addr_type&IPV6_ADDR_LINKLOCAL) {
160 if (addr_len >= sizeof(struct sockaddr_in6) &&
161 usin->sin6_scope_id) {
162 /* If interface is set while binding, indices
163 * must coincide.
164 */
165 if (sk->sk_bound_dev_if &&
166 sk->sk_bound_dev_if != usin->sin6_scope_id)
167 return -EINVAL;
168
169 sk->sk_bound_dev_if = usin->sin6_scope_id;
170 }
171
172 /* Connect to link-local address requires an interface */
173 if (!sk->sk_bound_dev_if)
174 return -EINVAL;
175 }
176
177 if (tp->rx_opt.ts_recent_stamp &&
Eric Dumazetefe42082013-10-03 15:42:29 -0700178 !ipv6_addr_equal(&sk->sk_v6_daddr, &usin->sin6_addr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 tp->rx_opt.ts_recent = 0;
180 tp->rx_opt.ts_recent_stamp = 0;
181 tp->write_seq = 0;
182 }
183
Eric Dumazetefe42082013-10-03 15:42:29 -0700184 sk->sk_v6_daddr = usin->sin6_addr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500185 np->flow_label = fl6.flowlabel;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186
187 /*
188 * TCP over IPv4
189 */
190
191 if (addr_type == IPV6_ADDR_MAPPED) {
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800192 u32 exthdrlen = icsk->icsk_ext_hdr_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 struct sockaddr_in sin;
194
195 SOCK_DEBUG(sk, "connect: ipv4 mapped\n");
196
197 if (__ipv6_only_sock(sk))
198 return -ENETUNREACH;
199
200 sin.sin_family = AF_INET;
201 sin.sin_port = usin->sin6_port;
202 sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
203
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800204 icsk->icsk_af_ops = &ipv6_mapped;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 sk->sk_backlog_rcv = tcp_v4_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800206#ifdef CONFIG_TCP_MD5SIG
207 tp->af_specific = &tcp_sock_ipv6_mapped_specific;
208#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209
210 err = tcp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
211
212 if (err) {
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800213 icsk->icsk_ext_hdr_len = exthdrlen;
214 icsk->icsk_af_ops = &ipv6_specific;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 sk->sk_backlog_rcv = tcp_v6_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800216#ifdef CONFIG_TCP_MD5SIG
217 tp->af_specific = &tcp_sock_ipv6_specific;
218#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 goto failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 }
Eric Dumazetd1e559d2015-03-18 14:05:35 -0700221 np->saddr = sk->sk_v6_rcv_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222
223 return err;
224 }
225
Eric Dumazetefe42082013-10-03 15:42:29 -0700226 if (!ipv6_addr_any(&sk->sk_v6_rcv_saddr))
227 saddr = &sk->sk_v6_rcv_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228
David S. Miller4c9483b2011-03-12 16:22:43 -0500229 fl6.flowi6_proto = IPPROTO_TCP;
Eric Dumazetefe42082013-10-03 15:42:29 -0700230 fl6.daddr = sk->sk_v6_daddr;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000231 fl6.saddr = saddr ? *saddr : np->saddr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500232 fl6.flowi6_oif = sk->sk_bound_dev_if;
233 fl6.flowi6_mark = sk->sk_mark;
David S. Miller1958b852011-03-12 16:36:19 -0500234 fl6.fl6_dport = usin->sin6_port;
235 fl6.fl6_sport = inet->inet_sport;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236
Eric Dumazet45f6fad2015-11-29 19:37:57 -0800237 opt = rcu_dereference_protected(np->opt, sock_owned_by_user(sk));
238 final_p = fl6_update_dst(&fl6, opt, &final);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239
David S. Miller4c9483b2011-03-12 16:22:43 -0500240 security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -0700241
Steffen Klassert0e0d44a2013-08-28 08:04:14 +0200242 dst = ip6_dst_lookup_flow(sk, &fl6, final_p);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800243 if (IS_ERR(dst)) {
244 err = PTR_ERR(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 goto failure;
David S. Miller14e50e52007-05-24 18:17:54 -0700246 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247
Ian Morris63159f22015-03-29 14:00:04 +0100248 if (!saddr) {
David S. Miller4c9483b2011-03-12 16:22:43 -0500249 saddr = &fl6.saddr;
Eric Dumazetefe42082013-10-03 15:42:29 -0700250 sk->sk_v6_rcv_saddr = *saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 }
252
253 /* set the source address */
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000254 np->saddr = *saddr;
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000255 inet->inet_rcv_saddr = LOOPBACK4_IPV6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
Herbert Xuf83ef8c2006-06-30 13:37:03 -0700257 sk->sk_gso_type = SKB_GSO_TCPV6;
Eric Dumazet6bd4f352015-12-02 21:53:57 -0800258 ip6_dst_store(sk, dst, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
David S. Miller493f3772010-12-02 12:14:29 -0800260 if (tcp_death_row.sysctl_tw_recycle &&
261 !tp->rx_opt.ts_recent_stamp &&
Martin KaFai Laufd0273d2015-05-22 20:55:57 -0700262 ipv6_addr_equal(&fl6.daddr, &sk->sk_v6_daddr))
David S. Miller81166dd2012-07-10 03:14:24 -0700263 tcp_fetch_timewait_stamp(sk, dst);
David S. Miller493f3772010-12-02 12:14:29 -0800264
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800265 icsk->icsk_ext_hdr_len = 0;
Eric Dumazet45f6fad2015-11-29 19:37:57 -0800266 if (opt)
267 icsk->icsk_ext_hdr_len = opt->opt_flen +
268 opt->opt_nflen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269
270 tp->rx_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
271
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000272 inet->inet_dport = usin->sin6_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273
274 tcp_set_state(sk, TCP_SYN_SENT);
Arnaldo Carvalho de Melod8313f52005-12-13 23:25:44 -0800275 err = inet6_hash_connect(&tcp_death_row, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 if (err)
277 goto late_failure;
278
Tom Herbert877d1f62015-07-28 16:02:05 -0700279 sk_set_txhash(sk);
Sathya Perla9e7ceb02014-10-22 21:42:01 +0530280
Andrey Vagin2b916472012-11-22 01:13:58 +0000281 if (!tp->write_seq && likely(!tp->repair))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 tp->write_seq = secure_tcpv6_sequence_number(np->saddr.s6_addr32,
Eric Dumazetefe42082013-10-03 15:42:29 -0700283 sk->sk_v6_daddr.s6_addr32,
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000284 inet->inet_sport,
285 inet->inet_dport);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286
287 err = tcp_connect(sk);
288 if (err)
289 goto late_failure;
290
291 return 0;
292
293late_failure:
294 tcp_set_state(sk, TCP_CLOSE);
295 __sk_dst_reset(sk);
296failure:
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000297 inet->inet_dport = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 sk->sk_route_caps = 0;
299 return err;
300}
301
Eric Dumazet563d34d2012-07-23 09:48:52 +0200302static void tcp_v6_mtu_reduced(struct sock *sk)
303{
304 struct dst_entry *dst;
305
306 if ((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE))
307 return;
308
309 dst = inet6_csk_update_pmtu(sk, tcp_sk(sk)->mtu_info);
310 if (!dst)
311 return;
312
313 if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst)) {
314 tcp_sync_mss(sk, dst_mtu(dst));
315 tcp_simple_retransmit(sk);
316 }
317}
318
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700320 u8 type, u8 code, int offset, __be32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321{
Weilong Chen4c99aa42013-12-19 18:44:34 +0800322 const struct ipv6hdr *hdr = (const struct ipv6hdr *)skb->data;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -0300323 const struct tcphdr *th = (struct tcphdr *)(skb->data+offset);
Eric Dumazet22150892015-03-22 10:22:23 -0700324 struct net *net = dev_net(skb->dev);
325 struct request_sock *fastopen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 struct ipv6_pinfo *np;
Eric Dumazet22150892015-03-22 10:22:23 -0700327 struct tcp_sock *tp;
328 __u32 seq, snd_una;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 struct sock *sk;
Eric Dumazet9cf74902016-02-02 19:31:12 -0800330 bool fatal;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332
Eric Dumazet22150892015-03-22 10:22:23 -0700333 sk = __inet6_lookup_established(net, &tcp_hashinfo,
334 &hdr->daddr, th->dest,
335 &hdr->saddr, ntohs(th->source),
336 skb->dev->ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337
Eric Dumazet22150892015-03-22 10:22:23 -0700338 if (!sk) {
Denis V. Luneve41b5362008-10-08 10:33:26 -0700339 ICMP6_INC_STATS_BH(net, __in6_dev_get(skb->dev),
340 ICMP6_MIB_INERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 return;
342 }
343
344 if (sk->sk_state == TCP_TIME_WAIT) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -0700345 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 return;
347 }
Eric Dumazet22150892015-03-22 10:22:23 -0700348 seq = ntohl(th->seq);
Eric Dumazet9cf74902016-02-02 19:31:12 -0800349 fatal = icmpv6_err_convert(type, code, &err);
Eric Dumazet22150892015-03-22 10:22:23 -0700350 if (sk->sk_state == TCP_NEW_SYN_RECV)
Eric Dumazet9cf74902016-02-02 19:31:12 -0800351 return tcp_req_err(sk, seq, fatal);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352
353 bh_lock_sock(sk);
Eric Dumazet563d34d2012-07-23 09:48:52 +0200354 if (sock_owned_by_user(sk) && type != ICMPV6_PKT_TOOBIG)
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700355 NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356
357 if (sk->sk_state == TCP_CLOSE)
358 goto out;
359
Stephen Hemmingere802af92010-04-22 15:24:53 -0700360 if (ipv6_hdr(skb)->hop_limit < inet6_sk(sk)->min_hopcount) {
361 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
362 goto out;
363 }
364
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 tp = tcp_sk(sk);
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700366 /* XXX (TFO) - tp->snd_una should be ISN (tcp_create_openreq_child() */
367 fastopen = tp->fastopen_rsk;
368 snd_una = fastopen ? tcp_rsk(fastopen)->snt_isn : tp->snd_una;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 if (sk->sk_state != TCP_LISTEN &&
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700370 !between(seq, snd_una, tp->snd_nxt)) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700371 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 goto out;
373 }
374
375 np = inet6_sk(sk);
376
David S. Millerec18d9a2012-07-12 00:25:15 -0700377 if (type == NDISC_REDIRECT) {
378 struct dst_entry *dst = __sk_dst_check(sk, np->dst_cookie);
379
David S. Miller1ed5c482012-07-12 00:41:25 -0700380 if (dst)
David S. Miller6700c272012-07-17 03:29:28 -0700381 dst->ops->redirect(dst, sk, skb);
Christoph Paasch50a75a82013-04-07 04:53:15 +0000382 goto out;
David S. Millerec18d9a2012-07-12 00:25:15 -0700383 }
384
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 if (type == ICMPV6_PKT_TOOBIG) {
Eric Dumazet0d4f0602013-03-18 07:01:28 +0000386 /* We are not interested in TCP_LISTEN and open_requests
387 * (SYN-ACKs send out by Linux are always <576bytes so
388 * they should go through unfragmented).
389 */
390 if (sk->sk_state == TCP_LISTEN)
391 goto out;
392
Hannes Frederic Sowa93b36cf2013-12-15 03:41:14 +0100393 if (!ip6_sk_accept_pmtu(sk))
394 goto out;
395
Eric Dumazet563d34d2012-07-23 09:48:52 +0200396 tp->mtu_info = ntohl(info);
397 if (!sock_owned_by_user(sk))
398 tcp_v6_mtu_reduced(sk);
Julian Anastasovd013ef2a2012-09-05 10:53:18 +0000399 else if (!test_and_set_bit(TCP_MTU_REDUCED_DEFERRED,
400 &tp->tsq_flags))
401 sock_hold(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 goto out;
403 }
404
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700406 /* Might be for an request_sock */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 switch (sk->sk_state) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 case TCP_SYN_SENT:
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700409 case TCP_SYN_RECV:
410 /* Only in fast or simultaneous open. If a fast open socket is
411 * is already accepted it is treated as a connected one below.
412 */
Ian Morris63159f22015-03-29 14:00:04 +0100413 if (fastopen && !fastopen->sk)
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700414 break;
415
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 if (!sock_owned_by_user(sk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 sk->sk_err = err;
418 sk->sk_error_report(sk); /* Wake people up to see the error (see connect in sock.c) */
419
420 tcp_done(sk);
421 } else
422 sk->sk_err_soft = err;
423 goto out;
424 }
425
426 if (!sock_owned_by_user(sk) && np->recverr) {
427 sk->sk_err = err;
428 sk->sk_error_report(sk);
429 } else
430 sk->sk_err_soft = err;
431
432out:
433 bh_unlock_sock(sk);
434 sock_put(sk);
435}
436
437
Eric Dumazet0f935dbe2015-09-25 07:39:21 -0700438static int tcp_v6_send_synack(const struct sock *sk, struct dst_entry *dst,
Octavian Purdilad6274bd2014-06-25 17:09:58 +0300439 struct flowi *fl,
Neal Cardwell3840a062012-06-28 12:34:19 +0000440 struct request_sock *req,
Eric Dumazetca6fb062015-10-02 11:43:35 -0700441 struct tcp_fastopen_cookie *foc,
442 bool attach_req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443{
Eric Dumazet634fb9792013-10-09 15:21:29 -0700444 struct inet_request_sock *ireq = inet_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 struct ipv6_pinfo *np = inet6_sk(sk);
Octavian Purdilad6274bd2014-06-25 17:09:58 +0300446 struct flowi6 *fl6 = &fl->u.ip6;
Weilong Chen4c99aa42013-12-19 18:44:34 +0800447 struct sk_buff *skb;
Neal Cardwell94942182012-06-28 12:34:20 +0000448 int err = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449
Neal Cardwell9f10d3f2012-06-28 12:34:21 +0000450 /* First, grab a route. */
Eric Dumazetf76b33c2015-09-29 07:42:42 -0700451 if (!dst && (dst = inet6_csk_route_req(sk, fl6, req,
452 IPPROTO_TCP)) == NULL)
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800453 goto done;
Neal Cardwell94942182012-06-28 12:34:20 +0000454
Eric Dumazetca6fb062015-10-02 11:43:35 -0700455 skb = tcp_make_synack(sk, dst, req, foc, attach_req);
Neal Cardwell94942182012-06-28 12:34:20 +0000456
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 if (skb) {
Eric Dumazet634fb9792013-10-09 15:21:29 -0700458 __tcp_v6_send_check(skb, &ireq->ir_v6_loc_addr,
459 &ireq->ir_v6_rmt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460
Eric Dumazet634fb9792013-10-09 15:21:29 -0700461 fl6->daddr = ireq->ir_v6_rmt_addr;
Ian Morris53b24b82015-03-29 14:00:05 +0100462 if (np->repflow && ireq->pktopts)
Florent Fourcotdf3687f2014-01-17 17:15:03 +0100463 fl6->flowlabel = ip6_flowlabel(ipv6_hdr(ireq->pktopts));
464
Eric Dumazet3e4006f2016-01-08 09:35:51 -0800465 rcu_read_lock();
Eric Dumazet45f6fad2015-11-29 19:37:57 -0800466 err = ip6_xmit(sk, skb, fl6, rcu_dereference(np->opt),
467 np->tclass);
Eric Dumazet3e4006f2016-01-08 09:35:51 -0800468 rcu_read_unlock();
Gerrit Renkerb9df3cb2006-11-14 11:21:36 -0200469 err = net_xmit_eval(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 }
471
472done:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 return err;
474}
475
Octavian Purdila72659ec2010-01-17 19:09:39 -0800476
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700477static void tcp_v6_reqsk_destructor(struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478{
Eric Dumazet634fb9792013-10-09 15:21:29 -0700479 kfree_skb(inet_rsk(req)->pktopts);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480}
481
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800482#ifdef CONFIG_TCP_MD5SIG
Eric Dumazetb83e3de2015-09-25 07:39:15 -0700483static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(const struct sock *sk,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000484 const struct in6_addr *addr)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800485{
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000486 return tcp_md5_do_lookup(sk, (union tcp_md5_addr *)addr, AF_INET6);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800487}
488
Eric Dumazetb83e3de2015-09-25 07:39:15 -0700489static struct tcp_md5sig_key *tcp_v6_md5_lookup(const struct sock *sk,
Eric Dumazetfd3a1542015-03-24 15:58:56 -0700490 const struct sock *addr_sk)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800491{
Eric Dumazetefe42082013-10-03 15:42:29 -0700492 return tcp_v6_md5_do_lookup(sk, &addr_sk->sk_v6_daddr);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800493}
494
Wang Yufen4aa956d2014-03-29 09:27:29 +0800495static int tcp_v6_parse_md5_keys(struct sock *sk, char __user *optval,
496 int optlen)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800497{
498 struct tcp_md5sig cmd;
499 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&cmd.tcpm_addr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800500
501 if (optlen < sizeof(cmd))
502 return -EINVAL;
503
504 if (copy_from_user(&cmd, optval, sizeof(cmd)))
505 return -EFAULT;
506
507 if (sin6->sin6_family != AF_INET6)
508 return -EINVAL;
509
510 if (!cmd.tcpm_keylen) {
Brian Haleye773e4f2007-08-24 23:16:08 -0700511 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000512 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3],
513 AF_INET);
514 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr,
515 AF_INET6);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800516 }
517
518 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
519 return -EINVAL;
520
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000521 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
522 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3],
523 AF_INET, cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800524
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000525 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr,
526 AF_INET6, cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800527}
528
Adam Langley49a72df2008-07-19 00:01:42 -0700529static int tcp_v6_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000530 const struct in6_addr *daddr,
531 const struct in6_addr *saddr, int nbytes)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800532{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800533 struct tcp6_pseudohdr *bp;
Adam Langley49a72df2008-07-19 00:01:42 -0700534 struct scatterlist sg;
YOSHIFUJI Hideaki8d26d762008-04-17 13:19:16 +0900535
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800536 bp = &hp->md5_blk.ip6;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800537 /* 1. TCP pseudo-header (RFC2460) */
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000538 bp->saddr = *saddr;
539 bp->daddr = *daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700540 bp->protocol = cpu_to_be32(IPPROTO_TCP);
Adam Langley00b13042008-07-31 21:36:07 -0700541 bp->len = cpu_to_be32(nbytes);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800542
Adam Langley49a72df2008-07-19 00:01:42 -0700543 sg_init_one(&sg, bp, sizeof(*bp));
544 return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
545}
David S. Millerc7da57a2007-10-26 00:41:21 -0700546
Adam Langley49a72df2008-07-19 00:01:42 -0700547static int tcp_v6_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000548 const struct in6_addr *daddr, struct in6_addr *saddr,
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400549 const struct tcphdr *th)
Adam Langley49a72df2008-07-19 00:01:42 -0700550{
551 struct tcp_md5sig_pool *hp;
552 struct hash_desc *desc;
553
554 hp = tcp_get_md5sig_pool();
555 if (!hp)
556 goto clear_hash_noput;
557 desc = &hp->md5_desc;
558
559 if (crypto_hash_init(desc))
560 goto clear_hash;
561 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
562 goto clear_hash;
563 if (tcp_md5_hash_header(hp, th))
564 goto clear_hash;
565 if (tcp_md5_hash_key(hp, key))
566 goto clear_hash;
567 if (crypto_hash_final(desc, md5_hash))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800568 goto clear_hash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800569
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800570 tcp_put_md5sig_pool();
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800571 return 0;
Adam Langley49a72df2008-07-19 00:01:42 -0700572
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800573clear_hash:
574 tcp_put_md5sig_pool();
575clear_hash_noput:
576 memset(md5_hash, 0, 16);
Adam Langley49a72df2008-07-19 00:01:42 -0700577 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800578}
579
Eric Dumazet39f8e582015-03-24 15:58:55 -0700580static int tcp_v6_md5_hash_skb(char *md5_hash,
581 const struct tcp_md5sig_key *key,
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400582 const struct sock *sk,
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400583 const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800584{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000585 const struct in6_addr *saddr, *daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700586 struct tcp_md5sig_pool *hp;
587 struct hash_desc *desc;
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400588 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800589
Eric Dumazet39f8e582015-03-24 15:58:55 -0700590 if (sk) { /* valid for establish/request sockets */
591 saddr = &sk->sk_v6_rcv_saddr;
Eric Dumazetefe42082013-10-03 15:42:29 -0700592 daddr = &sk->sk_v6_daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700593 } else {
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000594 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
Adam Langley49a72df2008-07-19 00:01:42 -0700595 saddr = &ip6h->saddr;
596 daddr = &ip6h->daddr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800597 }
Adam Langley49a72df2008-07-19 00:01:42 -0700598
599 hp = tcp_get_md5sig_pool();
600 if (!hp)
601 goto clear_hash_noput;
602 desc = &hp->md5_desc;
603
604 if (crypto_hash_init(desc))
605 goto clear_hash;
606
607 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
608 goto clear_hash;
609 if (tcp_md5_hash_header(hp, th))
610 goto clear_hash;
611 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
612 goto clear_hash;
613 if (tcp_md5_hash_key(hp, key))
614 goto clear_hash;
615 if (crypto_hash_final(desc, md5_hash))
616 goto clear_hash;
617
618 tcp_put_md5sig_pool();
619 return 0;
620
621clear_hash:
622 tcp_put_md5sig_pool();
623clear_hash_noput:
624 memset(md5_hash, 0, 16);
625 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800626}
627
Eric Dumazetba8e2752015-10-02 11:43:28 -0700628#endif
629
630static bool tcp_v6_inbound_md5_hash(const struct sock *sk,
631 const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800632{
Eric Dumazetba8e2752015-10-02 11:43:28 -0700633#ifdef CONFIG_TCP_MD5SIG
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400634 const __u8 *hash_location = NULL;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800635 struct tcp_md5sig_key *hash_expected;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000636 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400637 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800638 int genhash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800639 u8 newhash[16];
640
641 hash_expected = tcp_v6_md5_do_lookup(sk, &ip6h->saddr);
YOSHIFUJI Hideaki7d5d5522008-04-17 12:29:53 +0900642 hash_location = tcp_parse_md5sig_option(th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800643
David S. Miller785957d2008-07-30 03:03:15 -0700644 /* We've parsed the options - do we have a hash? */
645 if (!hash_expected && !hash_location)
Eric Dumazetff74e232015-03-24 15:58:54 -0700646 return false;
David S. Miller785957d2008-07-30 03:03:15 -0700647
648 if (hash_expected && !hash_location) {
649 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
Eric Dumazetff74e232015-03-24 15:58:54 -0700650 return true;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800651 }
652
David S. Miller785957d2008-07-30 03:03:15 -0700653 if (!hash_expected && hash_location) {
654 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
Eric Dumazetff74e232015-03-24 15:58:54 -0700655 return true;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800656 }
657
658 /* check the signature */
Adam Langley49a72df2008-07-19 00:01:42 -0700659 genhash = tcp_v6_md5_hash_skb(newhash,
660 hash_expected,
Eric Dumazet39f8e582015-03-24 15:58:55 -0700661 NULL, skb);
Adam Langley49a72df2008-07-19 00:01:42 -0700662
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800663 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
Joe Perchese87cc472012-05-13 21:56:26 +0000664 net_info_ratelimited("MD5 Hash %s for [%pI6c]:%u->[%pI6c]:%u\n",
665 genhash ? "failed" : "mismatch",
666 &ip6h->saddr, ntohs(th->source),
667 &ip6h->daddr, ntohs(th->dest));
Eric Dumazetff74e232015-03-24 15:58:54 -0700668 return true;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800669 }
Eric Dumazetba8e2752015-10-02 11:43:28 -0700670#endif
Eric Dumazetff74e232015-03-24 15:58:54 -0700671 return false;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800672}
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800673
Eric Dumazetb40cf182015-09-25 07:39:08 -0700674static void tcp_v6_init_req(struct request_sock *req,
675 const struct sock *sk_listener,
Octavian Purdila16bea702014-06-25 17:09:53 +0300676 struct sk_buff *skb)
677{
678 struct inet_request_sock *ireq = inet_rsk(req);
Eric Dumazetb40cf182015-09-25 07:39:08 -0700679 const struct ipv6_pinfo *np = inet6_sk(sk_listener);
Octavian Purdila16bea702014-06-25 17:09:53 +0300680
681 ireq->ir_v6_rmt_addr = ipv6_hdr(skb)->saddr;
682 ireq->ir_v6_loc_addr = ipv6_hdr(skb)->daddr;
683
Octavian Purdila16bea702014-06-25 17:09:53 +0300684 /* So that link locals have meaning */
Eric Dumazetb40cf182015-09-25 07:39:08 -0700685 if (!sk_listener->sk_bound_dev_if &&
Octavian Purdila16bea702014-06-25 17:09:53 +0300686 ipv6_addr_type(&ireq->ir_v6_rmt_addr) & IPV6_ADDR_LINKLOCAL)
Eric Dumazet870c3152014-10-17 09:17:20 -0700687 ireq->ir_iif = tcp_v6_iif(skb);
Octavian Purdila16bea702014-06-25 17:09:53 +0300688
Eric Dumazet04317da2014-09-05 15:33:32 -0700689 if (!TCP_SKB_CB(skb)->tcp_tw_isn &&
Eric Dumazetb40cf182015-09-25 07:39:08 -0700690 (ipv6_opt_accepted(sk_listener, skb, &TCP_SKB_CB(skb)->header.h6) ||
Eric Dumazeta2247722014-09-27 09:50:56 -0700691 np->rxopt.bits.rxinfo ||
Octavian Purdila16bea702014-06-25 17:09:53 +0300692 np->rxopt.bits.rxoinfo || np->rxopt.bits.rxhlim ||
693 np->rxopt.bits.rxohlim || np->repflow)) {
694 atomic_inc(&skb->users);
695 ireq->pktopts = skb;
696 }
697}
698
Eric Dumazetf9646292015-09-29 07:42:50 -0700699static struct dst_entry *tcp_v6_route_req(const struct sock *sk,
700 struct flowi *fl,
Octavian Purdilad94e0412014-06-25 17:09:55 +0300701 const struct request_sock *req,
702 bool *strict)
703{
704 if (strict)
705 *strict = true;
Eric Dumazetf76b33c2015-09-29 07:42:42 -0700706 return inet6_csk_route_req(sk, &fl->u.ip6, req, IPPROTO_TCP);
Octavian Purdilad94e0412014-06-25 17:09:55 +0300707}
708
Glenn Griffinc6aefaf2008-02-07 21:49:26 -0800709struct request_sock_ops tcp6_request_sock_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 .family = AF_INET6,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700711 .obj_size = sizeof(struct tcp6_request_sock),
Octavian Purdila5db92c92014-06-25 17:09:59 +0300712 .rtx_syn_ack = tcp_rtx_synack,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700713 .send_ack = tcp_v6_reqsk_send_ack,
714 .destructor = tcp_v6_reqsk_destructor,
Octavian Purdila72659ec2010-01-17 19:09:39 -0800715 .send_reset = tcp_v6_send_reset,
Wang Yufen4aa956d2014-03-29 09:27:29 +0800716 .syn_ack_timeout = tcp_syn_ack_timeout,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717};
718
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +0000719static const struct tcp_request_sock_ops tcp_request_sock_ipv6_ops = {
Octavian Purdila2aec4a22014-06-25 17:10:00 +0300720 .mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) -
721 sizeof(struct ipv6hdr),
Octavian Purdila16bea702014-06-25 17:09:53 +0300722#ifdef CONFIG_TCP_MD5SIG
Eric Dumazetfd3a1542015-03-24 15:58:56 -0700723 .req_md5_lookup = tcp_v6_md5_lookup,
John Dykstrae3afe7b2009-07-16 05:04:51 +0000724 .calc_md5_hash = tcp_v6_md5_hash_skb,
Andrew Mortonb6332e62006-11-30 19:16:28 -0800725#endif
Octavian Purdila16bea702014-06-25 17:09:53 +0300726 .init_req = tcp_v6_init_req,
Octavian Purdilafb7b37a2014-06-25 17:09:54 +0300727#ifdef CONFIG_SYN_COOKIES
728 .cookie_init_seq = cookie_v6_init_sequence,
729#endif
Octavian Purdilad94e0412014-06-25 17:09:55 +0300730 .route_req = tcp_v6_route_req,
Octavian Purdila936b8bd2014-06-25 17:09:57 +0300731 .init_seq = tcp_v6_init_sequence,
Octavian Purdilad6274bd2014-06-25 17:09:58 +0300732 .send_synack = tcp_v6_send_synack,
Octavian Purdila16bea702014-06-25 17:09:53 +0300733};
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800734
Eric Dumazeta00e7442015-09-29 07:42:39 -0700735static void tcp_v6_send_response(const struct sock *sk, struct sk_buff *skb, u32 seq,
Eric Dumazet0f85fea2014-12-09 09:56:08 -0800736 u32 ack, u32 win, u32 tsval, u32 tsecr,
737 int oif, struct tcp_md5sig_key *key, int rst,
738 u8 tclass, u32 label)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400740 const struct tcphdr *th = tcp_hdr(skb);
741 struct tcphdr *t1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 struct sk_buff *buff;
David S. Miller4c9483b2011-03-12 16:22:43 -0500743 struct flowi6 fl6;
Eric Dumazet0f85fea2014-12-09 09:56:08 -0800744 struct net *net = sk ? sock_net(sk) : dev_net(skb_dst(skb)->dev);
Daniel Lezcanoe5047992008-03-07 11:16:26 -0800745 struct sock *ctl_sk = net->ipv6.tcp_sk;
YOSHIFUJI Hideaki9cb57342008-01-12 02:16:03 -0800746 unsigned int tot_len = sizeof(struct tcphdr);
Eric Dumazetadf30902009-06-02 05:19:30 +0000747 struct dst_entry *dst;
Al Viroe69a4adc2006-11-14 20:56:00 -0800748 __be32 *topt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749
Andrey Vaginee684b62013-02-11 05:50:19 +0000750 if (tsecr)
YOSHIFUJI Hideaki4244f8a2006-10-10 19:40:50 -0700751 tot_len += TCPOLEN_TSTAMP_ALIGNED;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800752#ifdef CONFIG_TCP_MD5SIG
753 if (key)
754 tot_len += TCPOLEN_MD5SIG_ALIGNED;
755#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756
757 buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
758 GFP_ATOMIC);
Ian Morris63159f22015-03-29 14:00:04 +0100759 if (!buff)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 return;
761
762 skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
763
Ilpo Järvinen77c676d2008-10-09 14:41:38 -0700764 t1 = (struct tcphdr *) skb_push(buff, tot_len);
Herbert Xu6651ffc2010-04-21 00:47:15 -0700765 skb_reset_transport_header(buff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766
767 /* Swap the send and the receive. */
768 memset(t1, 0, sizeof(*t1));
769 t1->dest = th->source;
770 t1->source = th->dest;
Ilpo Järvinen77c676d2008-10-09 14:41:38 -0700771 t1->doff = tot_len / 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 t1->seq = htonl(seq);
773 t1->ack_seq = htonl(ack);
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700774 t1->ack = !rst || !th->ack;
775 t1->rst = rst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 t1->window = htons(win);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800777
Al Viroe69a4adc2006-11-14 20:56:00 -0800778 topt = (__be32 *)(t1 + 1);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900779
Andrey Vaginee684b62013-02-11 05:50:19 +0000780 if (tsecr) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800781 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
782 (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
Andrey Vaginee684b62013-02-11 05:50:19 +0000783 *topt++ = htonl(tsval);
784 *topt++ = htonl(tsecr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 }
786
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800787#ifdef CONFIG_TCP_MD5SIG
788 if (key) {
789 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
790 (TCPOPT_MD5SIG << 8) | TCPOLEN_MD5SIG);
Adam Langley49a72df2008-07-19 00:01:42 -0700791 tcp_v6_md5_hash_hdr((__u8 *)topt, key,
Adam Langley90b7e112008-07-31 20:49:48 -0700792 &ipv6_hdr(skb)->saddr,
793 &ipv6_hdr(skb)->daddr, t1);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800794 }
795#endif
796
David S. Miller4c9483b2011-03-12 16:22:43 -0500797 memset(&fl6, 0, sizeof(fl6));
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000798 fl6.daddr = ipv6_hdr(skb)->saddr;
799 fl6.saddr = ipv6_hdr(skb)->daddr;
Florent Fourcot1d13a962014-01-16 17:21:22 +0100800 fl6.flowlabel = label;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801
David S. Millere5700af2010-04-21 14:59:20 -0700802 buff->ip_summed = CHECKSUM_PARTIAL;
803 buff->csum = 0;
804
David S. Miller4c9483b2011-03-12 16:22:43 -0500805 __tcp_v6_send_check(buff, &fl6.saddr, &fl6.daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806
David S. Miller4c9483b2011-03-12 16:22:43 -0500807 fl6.flowi6_proto = IPPROTO_TCP;
Lorenzo Colittia36dbdb2014-04-11 13:19:12 +0900808 if (rt6_need_strict(&fl6.daddr) && !oif)
Eric Dumazet870c3152014-10-17 09:17:20 -0700809 fl6.flowi6_oif = tcp_v6_iif(skb);
Wang Yufen9c76a112014-03-29 09:27:31 +0800810 else
811 fl6.flowi6_oif = oif;
Lorenzo Colittie1108612014-05-13 10:17:33 -0700812 fl6.flowi6_mark = IP6_REPLY_MARK(net, skb->mark);
David S. Miller1958b852011-03-12 16:36:19 -0500813 fl6.fl6_dport = t1->dest;
814 fl6.fl6_sport = t1->source;
David S. Miller4c9483b2011-03-12 16:22:43 -0500815 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700817 /* Pass a socket to ip6_dst_lookup either it is for RST
818 * Underlying function will use this to retrieve the network
819 * namespace
820 */
Steffen Klassert0e0d44a2013-08-28 08:04:14 +0200821 dst = ip6_dst_lookup_flow(ctl_sk, &fl6, NULL);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800822 if (!IS_ERR(dst)) {
823 skb_dst_set(buff, dst);
Eric Dumazetb903d322011-10-27 00:44:35 -0400824 ip6_xmit(ctl_sk, buff, &fl6, NULL, tclass);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800825 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
826 if (rst)
827 TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
828 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 }
830
831 kfree_skb(buff);
832}
833
Eric Dumazeta00e7442015-09-29 07:42:39 -0700834static void tcp_v6_send_reset(const struct sock *sk, struct sk_buff *skb)
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700835{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400836 const struct tcphdr *th = tcp_hdr(skb);
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700837 u32 seq = 0, ack_seq = 0;
Guo-Fu Tsengfa3e5b42008-10-09 21:11:56 -0700838 struct tcp_md5sig_key *key = NULL;
Shawn Lu658ddaa2012-01-31 22:35:48 +0000839#ifdef CONFIG_TCP_MD5SIG
840 const __u8 *hash_location = NULL;
841 struct ipv6hdr *ipv6h = ipv6_hdr(skb);
842 unsigned char newhash[16];
843 int genhash;
844 struct sock *sk1 = NULL;
845#endif
Wang Yufen9c76a112014-03-29 09:27:31 +0800846 int oif;
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700847
848 if (th->rst)
849 return;
850
Eric Dumazetc3658e82014-11-25 07:40:04 -0800851 /* If sk not NULL, it means we did a successful lookup and incoming
852 * route had to be correct. prequeue might have dropped our dst.
853 */
854 if (!sk && !ipv6_unicast_destination(skb))
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700855 return;
856
857#ifdef CONFIG_TCP_MD5SIG
Shawn Lu658ddaa2012-01-31 22:35:48 +0000858 hash_location = tcp_parse_md5sig_option(th);
Florian Westphal271c3b92015-12-21 21:29:26 +0100859 if (sk && sk_fullsock(sk)) {
Florian Westphale46787f2015-12-21 21:29:25 +0100860 key = tcp_v6_md5_do_lookup(sk, &ipv6h->saddr);
861 } else if (hash_location) {
Shawn Lu658ddaa2012-01-31 22:35:48 +0000862 /*
863 * active side is lost. Try to find listening socket through
864 * source port, and then find md5 key through listening socket.
865 * we are not loose security here:
866 * Incoming packet is checked with md5 hash with finding key,
867 * no RST generated if md5 hash doesn't match.
868 */
869 sk1 = inet6_lookup_listener(dev_net(skb_dst(skb)->dev),
Craig Galleka5836362016-02-10 11:50:38 -0500870 &tcp_hashinfo, NULL, 0,
871 &ipv6h->saddr,
Tom Herbert5ba24952013-01-22 09:50:39 +0000872 th->source, &ipv6h->daddr,
Eric Dumazet870c3152014-10-17 09:17:20 -0700873 ntohs(th->source), tcp_v6_iif(skb));
Shawn Lu658ddaa2012-01-31 22:35:48 +0000874 if (!sk1)
875 return;
876
877 rcu_read_lock();
878 key = tcp_v6_md5_do_lookup(sk1, &ipv6h->saddr);
879 if (!key)
880 goto release_sk1;
881
Eric Dumazet39f8e582015-03-24 15:58:55 -0700882 genhash = tcp_v6_md5_hash_skb(newhash, key, NULL, skb);
Shawn Lu658ddaa2012-01-31 22:35:48 +0000883 if (genhash || memcmp(hash_location, newhash, 16) != 0)
884 goto release_sk1;
Shawn Lu658ddaa2012-01-31 22:35:48 +0000885 }
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700886#endif
887
888 if (th->ack)
889 seq = ntohl(th->ack_seq);
890 else
891 ack_seq = ntohl(th->seq) + th->syn + th->fin + skb->len -
892 (th->doff << 2);
893
Wang Yufen9c76a112014-03-29 09:27:31 +0800894 oif = sk ? sk->sk_bound_dev_if : 0;
Eric Dumazet0f85fea2014-12-09 09:56:08 -0800895 tcp_v6_send_response(sk, skb, seq, ack_seq, 0, 0, 0, oif, key, 1, 0, 0);
Shawn Lu658ddaa2012-01-31 22:35:48 +0000896
897#ifdef CONFIG_TCP_MD5SIG
898release_sk1:
899 if (sk1) {
900 rcu_read_unlock();
901 sock_put(sk1);
902 }
903#endif
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700904}
905
Eric Dumazeta00e7442015-09-29 07:42:39 -0700906static void tcp_v6_send_ack(const struct sock *sk, struct sk_buff *skb, u32 seq,
Eric Dumazet0f85fea2014-12-09 09:56:08 -0800907 u32 ack, u32 win, u32 tsval, u32 tsecr, int oif,
Florent Fourcot1d13a962014-01-16 17:21:22 +0100908 struct tcp_md5sig_key *key, u8 tclass,
909 u32 label)
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700910{
Eric Dumazet0f85fea2014-12-09 09:56:08 -0800911 tcp_v6_send_response(sk, skb, seq, ack, win, tsval, tsecr, oif, key, 0,
912 tclass, label);
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700913}
914
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
916{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700917 struct inet_timewait_sock *tw = inet_twsk(sk);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800918 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919
Eric Dumazet0f85fea2014-12-09 09:56:08 -0800920 tcp_v6_send_ack(sk, skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700921 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
Andrey Vaginee684b62013-02-11 05:50:19 +0000922 tcp_time_stamp + tcptw->tw_ts_offset,
Wang Yufen9c76a112014-03-29 09:27:31 +0800923 tcptw->tw_ts_recent, tw->tw_bound_dev_if, tcp_twsk_md5_key(tcptw),
Florent Fourcot21858cd2015-05-16 00:24:59 +0200924 tw->tw_tclass, cpu_to_be32(tw->tw_flowlabel));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700926 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927}
928
Eric Dumazeta00e7442015-09-29 07:42:39 -0700929static void tcp_v6_reqsk_send_ack(const struct sock *sk, struct sk_buff *skb,
Gui Jianfeng6edafaa2008-08-06 23:50:04 -0700930 struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931{
Daniel Lee3a19ce02014-05-11 20:22:13 -0700932 /* sk->sk_state == TCP_LISTEN -> for regular TCP_SYN_RECV
933 * sk->sk_state == TCP_SYN_RECV -> for Fast Open.
934 */
Eric Dumazet0f85fea2014-12-09 09:56:08 -0800935 tcp_v6_send_ack(sk, skb, (sk->sk_state == TCP_LISTEN) ?
Daniel Lee3a19ce02014-05-11 20:22:13 -0700936 tcp_rsk(req)->snt_isn + 1 : tcp_sk(sk)->snd_nxt,
Eric Dumazeted53d0a2015-10-08 19:33:23 -0700937 tcp_rsk(req)->rcv_nxt, req->rsk_rcv_wnd,
Eric Dumazet0f85fea2014-12-09 09:56:08 -0800938 tcp_time_stamp, req->ts_recent, sk->sk_bound_dev_if,
Florent Fourcot1d13a962014-01-16 17:21:22 +0100939 tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr),
940 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941}
942
943
Eric Dumazet079096f2015-10-02 11:43:32 -0700944static struct sock *tcp_v6_cookie_check(struct sock *sk, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945{
Glenn Griffinc6aefaf2008-02-07 21:49:26 -0800946#ifdef CONFIG_SYN_COOKIES
Eric Dumazet079096f2015-10-02 11:43:32 -0700947 const struct tcphdr *th = tcp_hdr(skb);
948
Florian Westphalaf9b4732010-06-03 00:43:44 +0000949 if (!th->syn)
Glenn Griffinc6aefaf2008-02-07 21:49:26 -0800950 sk = cookie_v6_check(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951#endif
952 return sk;
953}
954
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
956{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957 if (skb->protocol == htons(ETH_P_IP))
958 return tcp_v4_conn_request(sk, skb);
959
960 if (!ipv6_unicast_destination(skb))
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900961 goto drop;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962
Octavian Purdila1fb6f152014-06-25 17:10:02 +0300963 return tcp_conn_request(&tcp6_request_sock_ops,
964 &tcp_request_sock_ipv6_ops, sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966drop:
Vijay Subramanian5f1e9422013-01-31 08:24:19 +0000967 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 return 0; /* don't send reset */
969}
970
Eric Dumazet0c271712015-09-29 07:42:48 -0700971static struct sock *tcp_v6_syn_recv_sock(const struct sock *sk, struct sk_buff *skb,
Weilong Chen4c99aa42013-12-19 18:44:34 +0800972 struct request_sock *req,
Eric Dumazet5e0724d2015-10-22 08:20:46 -0700973 struct dst_entry *dst,
974 struct request_sock *req_unhash,
975 bool *own_req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976{
Eric Dumazet634fb9792013-10-09 15:21:29 -0700977 struct inet_request_sock *ireq;
Eric Dumazet0c271712015-09-29 07:42:48 -0700978 struct ipv6_pinfo *newnp;
979 const struct ipv6_pinfo *np = inet6_sk(sk);
Eric Dumazet45f6fad2015-11-29 19:37:57 -0800980 struct ipv6_txoptions *opt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 struct tcp6_sock *newtcp6sk;
982 struct inet_sock *newinet;
983 struct tcp_sock *newtp;
984 struct sock *newsk;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800985#ifdef CONFIG_TCP_MD5SIG
986 struct tcp_md5sig_key *key;
987#endif
Neal Cardwell3840a062012-06-28 12:34:19 +0000988 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989
990 if (skb->protocol == htons(ETH_P_IP)) {
991 /*
992 * v6 mapped
993 */
994
Eric Dumazet5e0724d2015-10-22 08:20:46 -0700995 newsk = tcp_v4_syn_recv_sock(sk, skb, req, dst,
996 req_unhash, own_req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997
Ian Morris63159f22015-03-29 14:00:04 +0100998 if (!newsk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 return NULL;
1000
1001 newtcp6sk = (struct tcp6_sock *)newsk;
1002 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1003
1004 newinet = inet_sk(newsk);
1005 newnp = inet6_sk(newsk);
1006 newtp = tcp_sk(newsk);
1007
1008 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1009
Eric Dumazetd1e559d2015-03-18 14:05:35 -07001010 newnp->saddr = newsk->sk_v6_rcv_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001012 inet_csk(newsk)->icsk_af_ops = &ipv6_mapped;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013 newsk->sk_backlog_rcv = tcp_v4_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001014#ifdef CONFIG_TCP_MD5SIG
1015 newtp->af_specific = &tcp_sock_ipv6_mapped_specific;
1016#endif
1017
Yan, Zheng676a1182011-09-25 02:21:30 +00001018 newnp->ipv6_ac_list = NULL;
1019 newnp->ipv6_fl_list = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 newnp->pktoptions = NULL;
1021 newnp->opt = NULL;
Eric Dumazet870c3152014-10-17 09:17:20 -07001022 newnp->mcast_oif = tcp_v6_iif(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001023 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
Florent Fourcot1397ed32013-12-08 15:46:57 +01001024 newnp->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(skb));
Florent Fourcotdf3687f2014-01-17 17:15:03 +01001025 if (np->repflow)
1026 newnp->flow_label = ip6_flowlabel(ipv6_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -07001028 /*
1029 * No need to charge this sock to the relevant IPv6 refcnt debug socks count
1030 * here, tcp_create_openreq_child now does this for us, see the comment in
1031 * that function for the gory details. -acme
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033
1034 /* It is tricky place. Until this moment IPv4 tcp
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001035 worked with IPv6 icsk.icsk_af_ops.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 Sync it now.
1037 */
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001038 tcp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039
1040 return newsk;
1041 }
1042
Eric Dumazet634fb9792013-10-09 15:21:29 -07001043 ireq = inet_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044
1045 if (sk_acceptq_is_full(sk))
1046 goto out_overflow;
1047
David S. Miller493f3772010-12-02 12:14:29 -08001048 if (!dst) {
Eric Dumazetf76b33c2015-09-29 07:42:42 -07001049 dst = inet6_csk_route_req(sk, &fl6, req, IPPROTO_TCP);
David S. Miller493f3772010-12-02 12:14:29 -08001050 if (!dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051 goto out;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001052 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053
1054 newsk = tcp_create_openreq_child(sk, req, skb);
Ian Morris63159f22015-03-29 14:00:04 +01001055 if (!newsk)
Balazs Scheidler093d2822010-10-21 13:06:43 +02001056 goto out_nonewsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -07001058 /*
1059 * No need to charge this sock to the relevant IPv6 refcnt debug socks
1060 * count here, tcp_create_openreq_child now does this for us, see the
1061 * comment in that function for the gory details. -acme
1062 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063
Stephen Hemminger59eed272006-08-25 15:55:43 -07001064 newsk->sk_gso_type = SKB_GSO_TCPV6;
Eric Dumazet6bd4f352015-12-02 21:53:57 -08001065 ip6_dst_store(newsk, dst, NULL, NULL);
Neal Cardwellfae6ef82012-08-19 03:30:38 +00001066 inet6_sk_rx_dst_set(newsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067
1068 newtcp6sk = (struct tcp6_sock *)newsk;
1069 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1070
1071 newtp = tcp_sk(newsk);
1072 newinet = inet_sk(newsk);
1073 newnp = inet6_sk(newsk);
1074
1075 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1076
Eric Dumazet634fb9792013-10-09 15:21:29 -07001077 newsk->sk_v6_daddr = ireq->ir_v6_rmt_addr;
1078 newnp->saddr = ireq->ir_v6_loc_addr;
1079 newsk->sk_v6_rcv_saddr = ireq->ir_v6_loc_addr;
1080 newsk->sk_bound_dev_if = ireq->ir_iif;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001082 /* Now IPv6 options...
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083
1084 First: no IPv4 options.
1085 */
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001086 newinet->inet_opt = NULL;
Yan, Zheng676a1182011-09-25 02:21:30 +00001087 newnp->ipv6_ac_list = NULL;
Masayuki Nakagawad35690b2007-03-16 16:14:03 -07001088 newnp->ipv6_fl_list = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089
1090 /* Clone RX bits */
1091 newnp->rxopt.all = np->rxopt.all;
1092
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093 newnp->pktoptions = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094 newnp->opt = NULL;
Eric Dumazet870c3152014-10-17 09:17:20 -07001095 newnp->mcast_oif = tcp_v6_iif(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001096 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
Florent Fourcot1397ed32013-12-08 15:46:57 +01001097 newnp->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(skb));
Florent Fourcotdf3687f2014-01-17 17:15:03 +01001098 if (np->repflow)
1099 newnp->flow_label = ip6_flowlabel(ipv6_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100
1101 /* Clone native IPv6 options from listening socket (if any)
1102
1103 Yes, keeping reference count would be much more clever,
1104 but we make one more one thing there: reattach optmem
1105 to newsk.
1106 */
Eric Dumazet45f6fad2015-11-29 19:37:57 -08001107 opt = rcu_dereference(np->opt);
1108 if (opt) {
1109 opt = ipv6_dup_options(newsk, opt);
1110 RCU_INIT_POINTER(newnp->opt, opt);
1111 }
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001112 inet_csk(newsk)->icsk_ext_hdr_len = 0;
Eric Dumazet45f6fad2015-11-29 19:37:57 -08001113 if (opt)
1114 inet_csk(newsk)->icsk_ext_hdr_len = opt->opt_nflen +
1115 opt->opt_flen;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116
Daniel Borkmann81164412015-01-05 23:57:48 +01001117 tcp_ca_openreq_child(newsk, dst);
1118
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119 tcp_sync_mss(newsk, dst_mtu(dst));
David S. Miller0dbaee32010-12-13 12:52:14 -08001120 newtp->advmss = dst_metric_advmss(dst);
Neal Cardwelld135c522012-04-22 09:45:47 +00001121 if (tcp_sk(sk)->rx_opt.user_mss &&
1122 tcp_sk(sk)->rx_opt.user_mss < newtp->advmss)
1123 newtp->advmss = tcp_sk(sk)->rx_opt.user_mss;
1124
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 tcp_initialize_rcv_mss(newsk);
1126
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001127 newinet->inet_daddr = newinet->inet_saddr = LOOPBACK4_IPV6;
1128 newinet->inet_rcv_saddr = LOOPBACK4_IPV6;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001130#ifdef CONFIG_TCP_MD5SIG
1131 /* Copy over the MD5 key from the original socket */
Wang Yufen4aa956d2014-03-29 09:27:29 +08001132 key = tcp_v6_md5_do_lookup(sk, &newsk->sk_v6_daddr);
Ian Morris53b24b82015-03-29 14:00:05 +01001133 if (key) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001134 /* We're using one, so create a matching key
1135 * on the newsk structure. If we fail to get
1136 * memory, then we end up not copying the key
1137 * across. Shucks.
1138 */
Eric Dumazetefe42082013-10-03 15:42:29 -07001139 tcp_md5_do_add(newsk, (union tcp_md5_addr *)&newsk->sk_v6_daddr,
Mel Gorman99a1dec2012-07-31 16:44:14 -07001140 AF_INET6, key->key, key->keylen,
Eric Dumazet7450aaf2015-11-30 08:57:28 -08001141 sk_gfp_mask(sk, GFP_ATOMIC));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001142 }
1143#endif
1144
Balazs Scheidler093d2822010-10-21 13:06:43 +02001145 if (__inet_inherit_port(sk, newsk) < 0) {
Christoph Paasche337e242012-12-14 04:07:58 +00001146 inet_csk_prepare_forced_close(newsk);
1147 tcp_done(newsk);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001148 goto out;
1149 }
Eric Dumazet5e0724d2015-10-22 08:20:46 -07001150 *own_req = inet_ehash_nolisten(newsk, req_to_sk(req_unhash));
Eric Dumazet805c4bc2015-11-05 11:07:13 -08001151 if (*own_req) {
Eric Dumazet49a496c2015-11-05 12:50:19 -08001152 tcp_move_syn(newtp, req);
Eric Dumazet805c4bc2015-11-05 11:07:13 -08001153
1154 /* Clone pktoptions received with SYN, if we own the req */
1155 if (ireq->pktopts) {
1156 newnp->pktoptions = skb_clone(ireq->pktopts,
Eric Dumazet7450aaf2015-11-30 08:57:28 -08001157 sk_gfp_mask(sk, GFP_ATOMIC));
Eric Dumazet805c4bc2015-11-05 11:07:13 -08001158 consume_skb(ireq->pktopts);
1159 ireq->pktopts = NULL;
1160 if (newnp->pktoptions)
1161 skb_set_owner_r(newnp->pktoptions, newsk);
1162 }
Eric Dumazetce105002015-10-30 09:46:12 -07001163 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164
1165 return newsk;
1166
1167out_overflow:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001168 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001169out_nonewsk:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170 dst_release(dst);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001171out:
1172 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 return NULL;
1174}
1175
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176/* The socket must have it's spinlock held when we get
Eric Dumazete994b2f2015-10-02 11:43:39 -07001177 * here, unless it is a TCP_LISTEN socket.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178 *
1179 * We have a potential double-lock case here, so even when
1180 * doing backlog processing we use the BH locking scheme.
1181 * This is because we cannot sleep with the original spinlock
1182 * held.
1183 */
1184static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
1185{
1186 struct ipv6_pinfo *np = inet6_sk(sk);
1187 struct tcp_sock *tp;
1188 struct sk_buff *opt_skb = NULL;
1189
1190 /* Imagine: socket is IPv6. IPv4 packet arrives,
1191 goes to IPv4 receive handler and backlogged.
1192 From backlog it always goes here. Kerboom...
1193 Fortunately, tcp_rcv_established and rcv_established
1194 handle them correctly, but it is not case with
1195 tcp_v6_hnd_req and tcp_v6_send_reset(). --ANK
1196 */
1197
1198 if (skb->protocol == htons(ETH_P_IP))
1199 return tcp_v4_do_rcv(sk, skb);
1200
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001201 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 goto discard;
1203
1204 /*
1205 * socket locking is here for SMP purposes as backlog rcv
1206 * is currently called with bh processing disabled.
1207 */
1208
1209 /* Do Stevens' IPV6_PKTOPTIONS.
1210
1211 Yes, guys, it is the only place in our code, where we
1212 may make it not affecting IPv4.
1213 The rest of code is protocol independent,
1214 and I do not like idea to uglify IPv4.
1215
1216 Actually, all the idea behind IPV6_PKTOPTIONS
1217 looks not very well thought. For now we latch
1218 options, received in the last packet, enqueued
1219 by tcp. Feel free to propose better solution.
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001220 --ANK (980728)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 */
1222 if (np->rxopt.all)
Eric Dumazet7450aaf2015-11-30 08:57:28 -08001223 opt_skb = skb_clone(skb, sk_gfp_mask(sk, GFP_ATOMIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224
1225 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
Eric Dumazet5d299f32012-08-06 05:09:33 +00001226 struct dst_entry *dst = sk->sk_rx_dst;
1227
Tom Herbertbdeab992011-08-14 19:45:55 +00001228 sock_rps_save_rxhash(sk, skb);
Eric Dumazet3d973792014-11-11 05:54:27 -08001229 sk_mark_napi_id(sk, skb);
Eric Dumazet5d299f32012-08-06 05:09:33 +00001230 if (dst) {
1231 if (inet_sk(sk)->rx_dst_ifindex != skb->skb_iif ||
1232 dst->ops->check(dst, np->rx_dst_cookie) == NULL) {
1233 dst_release(dst);
1234 sk->sk_rx_dst = NULL;
1235 }
1236 }
1237
Vijay Subramanianc995ae22013-09-03 12:23:22 -07001238 tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239 if (opt_skb)
1240 goto ipv6_pktoptions;
1241 return 0;
1242 }
1243
Eric Dumazet12e25e12015-06-03 23:49:21 -07001244 if (tcp_checksum_complete(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245 goto csum_err;
1246
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001247 if (sk->sk_state == TCP_LISTEN) {
Eric Dumazet079096f2015-10-02 11:43:32 -07001248 struct sock *nsk = tcp_v6_cookie_check(sk, skb);
1249
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250 if (!nsk)
1251 goto discard;
1252
Weilong Chen4c99aa42013-12-19 18:44:34 +08001253 if (nsk != sk) {
Tom Herbertbdeab992011-08-14 19:45:55 +00001254 sock_rps_save_rxhash(nsk, skb);
Eric Dumazet38cb5242015-10-02 11:43:26 -07001255 sk_mark_napi_id(nsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256 if (tcp_child_process(sk, nsk, skb))
1257 goto reset;
1258 if (opt_skb)
1259 __kfree_skb(opt_skb);
1260 return 0;
1261 }
Neil Horman47482f12011-04-06 13:07:09 -07001262 } else
Tom Herbertbdeab992011-08-14 19:45:55 +00001263 sock_rps_save_rxhash(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264
Eric Dumazet72ab4a82015-09-29 07:42:41 -07001265 if (tcp_rcv_state_process(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266 goto reset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 if (opt_skb)
1268 goto ipv6_pktoptions;
1269 return 0;
1270
1271reset:
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001272 tcp_v6_send_reset(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273discard:
1274 if (opt_skb)
1275 __kfree_skb(opt_skb);
1276 kfree_skb(skb);
1277 return 0;
1278csum_err:
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001279 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_CSUMERRORS);
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001280 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 goto discard;
1282
1283
1284ipv6_pktoptions:
1285 /* Do you ask, what is it?
1286
1287 1. skb was enqueued by tcp.
1288 2. skb is added to tail of read queue, rather than out of order.
1289 3. socket is not in passive state.
1290 4. Finally, it really contains options, which user wants to receive.
1291 */
1292 tp = tcp_sk(sk);
1293 if (TCP_SKB_CB(opt_skb)->end_seq == tp->rcv_nxt &&
1294 !((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) {
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +09001295 if (np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo)
Eric Dumazet870c3152014-10-17 09:17:20 -07001296 np->mcast_oif = tcp_v6_iif(opt_skb);
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +09001297 if (np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim)
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001298 np->mcast_hops = ipv6_hdr(opt_skb)->hop_limit;
Florent Fourcot82e9f102013-12-08 15:46:59 +01001299 if (np->rxopt.bits.rxflow || np->rxopt.bits.rxtclass)
Florent Fourcot1397ed32013-12-08 15:46:57 +01001300 np->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(opt_skb));
Florent Fourcotdf3687f2014-01-17 17:15:03 +01001301 if (np->repflow)
1302 np->flow_label = ip6_flowlabel(ipv6_hdr(opt_skb));
Eric Dumazeta2247722014-09-27 09:50:56 -07001303 if (ipv6_opt_accepted(sk, opt_skb, &TCP_SKB_CB(opt_skb)->header.h6)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304 skb_set_owner_r(opt_skb, sk);
1305 opt_skb = xchg(&np->pktoptions, opt_skb);
1306 } else {
1307 __kfree_skb(opt_skb);
1308 opt_skb = xchg(&np->pktoptions, NULL);
1309 }
1310 }
1311
Wei Yongjun800d55f2009-02-23 21:45:33 +00001312 kfree_skb(opt_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 return 0;
1314}
1315
Nicolas Dichtel2dc49d12014-12-22 18:22:48 +01001316static void tcp_v6_fill_cb(struct sk_buff *skb, const struct ipv6hdr *hdr,
1317 const struct tcphdr *th)
1318{
1319 /* This is tricky: we move IP6CB at its correct location into
1320 * TCP_SKB_CB(). It must be done after xfrm6_policy_check(), because
1321 * _decode_session6() uses IP6CB().
1322 * barrier() makes sure compiler won't play aliasing games.
1323 */
1324 memmove(&TCP_SKB_CB(skb)->header.h6, IP6CB(skb),
1325 sizeof(struct inet6_skb_parm));
1326 barrier();
1327
1328 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1329 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1330 skb->len - th->doff*4);
1331 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1332 TCP_SKB_CB(skb)->tcp_flags = tcp_flag_byte(th);
1333 TCP_SKB_CB(skb)->tcp_tw_isn = 0;
1334 TCP_SKB_CB(skb)->ip_dsfield = ipv6_get_dsfield(hdr);
1335 TCP_SKB_CB(skb)->sacked = 0;
1336}
1337
Alexey Kodanev4ad19de2015-03-27 12:24:22 +03001338static void tcp_v6_restore_cb(struct sk_buff *skb)
1339{
1340 /* We need to move header back to the beginning if xfrm6_policy_check()
1341 * and tcp_v6_fill_cb() are going to be called again.
1342 */
1343 memmove(IP6CB(skb), &TCP_SKB_CB(skb)->header.h6,
1344 sizeof(struct inet6_skb_parm));
1345}
1346
Herbert Xue5bbef22007-10-15 12:50:28 -07001347static int tcp_v6_rcv(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348{
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001349 const struct tcphdr *th;
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001350 const struct ipv6hdr *hdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 struct sock *sk;
1352 int ret;
Pavel Emelyanova86b1e32008-07-16 20:20:58 -07001353 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354
1355 if (skb->pkt_type != PACKET_HOST)
1356 goto discard_it;
1357
1358 /*
1359 * Count it even if it's bad.
1360 */
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001361 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362
1363 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1364 goto discard_it;
1365
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001366 th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367
1368 if (th->doff < sizeof(struct tcphdr)/4)
1369 goto bad_packet;
1370 if (!pskb_may_pull(skb, th->doff*4))
1371 goto discard_it;
1372
Tom Herberte4f45b72014-05-02 16:29:51 -07001373 if (skb_checksum_init(skb, IPPROTO_TCP, ip6_compute_pseudo))
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001374 goto csum_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001376 th = tcp_hdr(skb);
Stephen Hemmingere802af92010-04-22 15:24:53 -07001377 hdr = ipv6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378
Eric Dumazet4bdc3d62015-10-13 17:12:54 -07001379lookup:
Craig Galleka5836362016-02-10 11:50:38 -05001380 sk = __inet6_lookup_skb(&tcp_hashinfo, skb, __tcp_hdrlen(th),
1381 th->source, th->dest, inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382 if (!sk)
1383 goto no_tcp_socket;
1384
1385process:
1386 if (sk->sk_state == TCP_TIME_WAIT)
1387 goto do_time_wait;
1388
Eric Dumazet079096f2015-10-02 11:43:32 -07001389 if (sk->sk_state == TCP_NEW_SYN_RECV) {
1390 struct request_sock *req = inet_reqsk(sk);
Eric Dumazet77166822016-02-18 05:39:18 -08001391 struct sock *nsk;
Eric Dumazet079096f2015-10-02 11:43:32 -07001392
1393 sk = req->rsk_listener;
1394 tcp_v6_fill_cb(skb, hdr, th);
1395 if (tcp_v6_inbound_md5_hash(sk, skb)) {
1396 reqsk_put(req);
1397 goto discard_it;
1398 }
Eric Dumazet77166822016-02-18 05:39:18 -08001399 if (unlikely(sk->sk_state != TCP_LISTEN)) {
Eric Dumazetf03f2e12015-10-14 11:16:27 -07001400 inet_csk_reqsk_queue_drop_and_put(sk, req);
Eric Dumazet4bdc3d62015-10-13 17:12:54 -07001401 goto lookup;
1402 }
Eric Dumazet77166822016-02-18 05:39:18 -08001403 sock_hold(sk);
1404 nsk = tcp_check_req(sk, skb, req, false);
Eric Dumazet079096f2015-10-02 11:43:32 -07001405 if (!nsk) {
1406 reqsk_put(req);
Eric Dumazet77166822016-02-18 05:39:18 -08001407 goto discard_and_relse;
Eric Dumazet079096f2015-10-02 11:43:32 -07001408 }
1409 if (nsk == sk) {
Eric Dumazet079096f2015-10-02 11:43:32 -07001410 reqsk_put(req);
1411 tcp_v6_restore_cb(skb);
1412 } else if (tcp_child_process(sk, nsk, skb)) {
1413 tcp_v6_send_reset(nsk, skb);
Eric Dumazet77166822016-02-18 05:39:18 -08001414 goto discard_and_relse;
Eric Dumazet079096f2015-10-02 11:43:32 -07001415 } else {
Eric Dumazet77166822016-02-18 05:39:18 -08001416 sock_put(sk);
Eric Dumazet079096f2015-10-02 11:43:32 -07001417 return 0;
1418 }
1419 }
Stephen Hemmingere802af92010-04-22 15:24:53 -07001420 if (hdr->hop_limit < inet6_sk(sk)->min_hopcount) {
1421 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
1422 goto discard_and_relse;
1423 }
1424
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
1426 goto discard_and_relse;
1427
Nicolas Dichtel2dc49d12014-12-22 18:22:48 +01001428 tcp_v6_fill_cb(skb, hdr, th);
1429
Dmitry Popov9ea88a12014-08-07 02:38:22 +04001430 if (tcp_v6_inbound_md5_hash(sk, skb))
1431 goto discard_and_relse;
Dmitry Popov9ea88a12014-08-07 02:38:22 +04001432
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001433 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434 goto discard_and_relse;
1435
1436 skb->dev = NULL;
1437
Eric Dumazete994b2f2015-10-02 11:43:39 -07001438 if (sk->sk_state == TCP_LISTEN) {
1439 ret = tcp_v6_do_rcv(sk, skb);
1440 goto put_and_return;
1441 }
1442
1443 sk_incoming_cpu_update(sk);
1444
Fabio Olive Leite293b9c42006-09-25 22:28:47 -07001445 bh_lock_sock_nested(sk);
Martin KaFai Laua44d6ea2016-03-14 10:52:15 -07001446 tcp_segs_in(tcp_sk(sk), skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447 ret = 0;
1448 if (!sock_owned_by_user(sk)) {
Dan Williams7bced392013-12-30 12:37:29 -08001449 if (!tcp_prequeue(sk, skb))
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001450 ret = tcp_v6_do_rcv(sk, skb);
Eric Dumazetda882c12012-04-22 23:38:54 +00001451 } else if (unlikely(sk_add_backlog(sk, skb,
1452 sk->sk_rcvbuf + sk->sk_sndbuf))) {
Zhu Yi6b03a532010-03-04 18:01:41 +00001453 bh_unlock_sock(sk);
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001454 NET_INC_STATS_BH(net, LINUX_MIB_TCPBACKLOGDROP);
Zhu Yi6b03a532010-03-04 18:01:41 +00001455 goto discard_and_relse;
1456 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 bh_unlock_sock(sk);
1458
Eric Dumazete994b2f2015-10-02 11:43:39 -07001459put_and_return:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 sock_put(sk);
1461 return ret ? -1 : 0;
1462
1463no_tcp_socket:
1464 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
1465 goto discard_it;
1466
Nicolas Dichtel2dc49d12014-12-22 18:22:48 +01001467 tcp_v6_fill_cb(skb, hdr, th);
1468
Eric Dumazet12e25e12015-06-03 23:49:21 -07001469 if (tcp_checksum_complete(skb)) {
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001470csum_error:
1471 TCP_INC_STATS_BH(net, TCP_MIB_CSUMERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472bad_packet:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001473 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001475 tcp_v6_send_reset(NULL, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476 }
1477
1478discard_it:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479 kfree_skb(skb);
1480 return 0;
1481
1482discard_and_relse:
1483 sock_put(sk);
1484 goto discard_it;
1485
1486do_time_wait:
1487 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001488 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489 goto discard_it;
1490 }
1491
Nicolas Dichtel2dc49d12014-12-22 18:22:48 +01001492 tcp_v6_fill_cb(skb, hdr, th);
1493
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001494 if (tcp_checksum_complete(skb)) {
1495 inet_twsk_put(inet_twsk(sk));
1496 goto csum_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 }
1498
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001499 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500 case TCP_TW_SYN:
1501 {
1502 struct sock *sk2;
1503
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001504 sk2 = inet6_lookup_listener(dev_net(skb->dev), &tcp_hashinfo,
Craig Galleka5836362016-02-10 11:50:38 -05001505 skb, __tcp_hdrlen(th),
Tom Herbert5ba24952013-01-22 09:50:39 +00001506 &ipv6_hdr(skb)->saddr, th->source,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001507 &ipv6_hdr(skb)->daddr,
Eric Dumazet870c3152014-10-17 09:17:20 -07001508 ntohs(th->dest), tcp_v6_iif(skb));
Ian Morris53b24b82015-03-29 14:00:05 +01001509 if (sk2) {
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -07001510 struct inet_timewait_sock *tw = inet_twsk(sk);
Eric Dumazetdbe7faa2015-07-08 14:28:30 -07001511 inet_twsk_deschedule_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512 sk = sk2;
Alexey Kodanev4ad19de2015-03-27 12:24:22 +03001513 tcp_v6_restore_cb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514 goto process;
1515 }
1516 /* Fall through to ACK */
1517 }
1518 case TCP_TW_ACK:
1519 tcp_v6_timewait_ack(sk, skb);
1520 break;
1521 case TCP_TW_RST:
Alexey Kodanev4ad19de2015-03-27 12:24:22 +03001522 tcp_v6_restore_cb(skb);
Florian Westphal271c3b92015-12-21 21:29:26 +01001523 tcp_v6_send_reset(sk, skb);
1524 inet_twsk_deschedule_put(inet_twsk(sk));
1525 goto discard_it;
Wang Yufen4aa956d2014-03-29 09:27:29 +08001526 case TCP_TW_SUCCESS:
1527 ;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528 }
1529 goto discard_it;
1530}
1531
Eric Dumazetc7109982012-07-26 12:18:11 +00001532static void tcp_v6_early_demux(struct sk_buff *skb)
1533{
1534 const struct ipv6hdr *hdr;
1535 const struct tcphdr *th;
1536 struct sock *sk;
1537
1538 if (skb->pkt_type != PACKET_HOST)
1539 return;
1540
1541 if (!pskb_may_pull(skb, skb_transport_offset(skb) + sizeof(struct tcphdr)))
1542 return;
1543
1544 hdr = ipv6_hdr(skb);
1545 th = tcp_hdr(skb);
1546
1547 if (th->doff < sizeof(struct tcphdr) / 4)
1548 return;
1549
Eric Dumazet870c3152014-10-17 09:17:20 -07001550 /* Note : We use inet6_iif() here, not tcp_v6_iif() */
Eric Dumazetc7109982012-07-26 12:18:11 +00001551 sk = __inet6_lookup_established(dev_net(skb->dev), &tcp_hashinfo,
1552 &hdr->saddr, th->source,
1553 &hdr->daddr, ntohs(th->dest),
1554 inet6_iif(skb));
1555 if (sk) {
1556 skb->sk = sk;
1557 skb->destructor = sock_edemux;
Eric Dumazetf7e4eb02015-03-15 21:12:13 -07001558 if (sk_fullsock(sk)) {
Michal Kubečekd0c294c2015-03-23 15:14:00 +01001559 struct dst_entry *dst = READ_ONCE(sk->sk_rx_dst);
Neal Cardwellf3f12132012-10-22 21:41:48 +00001560
Eric Dumazetc7109982012-07-26 12:18:11 +00001561 if (dst)
Eric Dumazet5d299f32012-08-06 05:09:33 +00001562 dst = dst_check(dst, inet6_sk(sk)->rx_dst_cookie);
Eric Dumazetc7109982012-07-26 12:18:11 +00001563 if (dst &&
Neal Cardwellf3f12132012-10-22 21:41:48 +00001564 inet_sk(sk)->rx_dst_ifindex == skb->skb_iif)
Eric Dumazetc7109982012-07-26 12:18:11 +00001565 skb_dst_set_noref(skb, dst);
1566 }
1567 }
1568}
1569
David S. Millerccb7c412010-12-01 18:09:13 -08001570static struct timewait_sock_ops tcp6_timewait_sock_ops = {
1571 .twsk_obj_size = sizeof(struct tcp6_timewait_sock),
1572 .twsk_unique = tcp_twsk_unique,
Wang Yufen4aa956d2014-03-29 09:27:29 +08001573 .twsk_destructor = tcp_twsk_destructor,
David S. Millerccb7c412010-12-01 18:09:13 -08001574};
1575
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001576static const struct inet_connection_sock_af_ops ipv6_specific = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001577 .queue_xmit = inet6_csk_xmit,
1578 .send_check = tcp_v6_send_check,
1579 .rebuild_header = inet6_sk_rebuild_header,
Eric Dumazet5d299f32012-08-06 05:09:33 +00001580 .sk_rx_dst_set = inet6_sk_rx_dst_set,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001581 .conn_request = tcp_v6_conn_request,
1582 .syn_recv_sock = tcp_v6_syn_recv_sock,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001583 .net_header_len = sizeof(struct ipv6hdr),
Eric Dumazet67469602012-04-24 07:37:38 +00001584 .net_frag_header_len = sizeof(struct frag_hdr),
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001585 .setsockopt = ipv6_setsockopt,
1586 .getsockopt = ipv6_getsockopt,
1587 .addr2sockaddr = inet6_csk_addr2sockaddr,
1588 .sockaddr_len = sizeof(struct sockaddr_in6),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001589 .bind_conflict = inet6_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001590#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001591 .compat_setsockopt = compat_ipv6_setsockopt,
1592 .compat_getsockopt = compat_ipv6_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001593#endif
Neal Cardwell4fab9072014-08-14 12:40:05 -04001594 .mtu_reduced = tcp_v6_mtu_reduced,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595};
1596
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001597#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001598static const struct tcp_sock_af_ops tcp_sock_ipv6_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001599 .md5_lookup = tcp_v6_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001600 .calc_md5_hash = tcp_v6_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001601 .md5_parse = tcp_v6_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001602};
David S. Millera9286302006-11-14 19:53:22 -08001603#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001604
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605/*
1606 * TCP over IPv4 via INET6 API
1607 */
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001608static const struct inet_connection_sock_af_ops ipv6_mapped = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001609 .queue_xmit = ip_queue_xmit,
1610 .send_check = tcp_v4_send_check,
1611 .rebuild_header = inet_sk_rebuild_header,
Eric Dumazet63d02d12012-08-09 14:11:00 +00001612 .sk_rx_dst_set = inet_sk_rx_dst_set,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001613 .conn_request = tcp_v6_conn_request,
1614 .syn_recv_sock = tcp_v6_syn_recv_sock,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001615 .net_header_len = sizeof(struct iphdr),
1616 .setsockopt = ipv6_setsockopt,
1617 .getsockopt = ipv6_getsockopt,
1618 .addr2sockaddr = inet6_csk_addr2sockaddr,
1619 .sockaddr_len = sizeof(struct sockaddr_in6),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001620 .bind_conflict = inet6_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001621#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001622 .compat_setsockopt = compat_ipv6_setsockopt,
1623 .compat_getsockopt = compat_ipv6_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001624#endif
Neal Cardwell4fab9072014-08-14 12:40:05 -04001625 .mtu_reduced = tcp_v4_mtu_reduced,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626};
1627
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001628#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001629static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001630 .md5_lookup = tcp_v4_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001631 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001632 .md5_parse = tcp_v6_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001633};
David S. Millera9286302006-11-14 19:53:22 -08001634#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001635
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636/* NOTE: A lot of things set to zero explicitly by call to
1637 * sk_alloc() so need not be done here.
1638 */
1639static int tcp_v6_init_sock(struct sock *sk)
1640{
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001641 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642
Neal Cardwell900f65d2012-04-19 09:55:21 +00001643 tcp_init_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001645 icsk->icsk_af_ops = &ipv6_specific;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001647#ifdef CONFIG_TCP_MD5SIG
David S. Millerac807fa2012-04-23 03:21:58 -04001648 tcp_sk(sk)->af_specific = &tcp_sock_ipv6_specific;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001649#endif
1650
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 return 0;
1652}
1653
Brian Haley7d06b2e2008-06-14 17:04:49 -07001654static void tcp_v6_destroy_sock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 tcp_v4_destroy_sock(sk);
Brian Haley7d06b2e2008-06-14 17:04:49 -07001657 inet6_destroy_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658}
1659
YOSHIFUJI Hideaki952a10b2007-04-21 20:13:44 +09001660#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661/* Proc filesystem TCPv6 sock list dumping. */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001662static void get_openreq6(struct seq_file *seq,
Eric Dumazetaa3a0c82015-10-02 11:43:30 -07001663 const struct request_sock *req, int i)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664{
Eric Dumazetfa76ce732015-03-19 19:04:20 -07001665 long ttd = req->rsk_timer.expires - jiffies;
Eric Dumazet634fb9792013-10-09 15:21:29 -07001666 const struct in6_addr *src = &inet_rsk(req)->ir_v6_loc_addr;
1667 const struct in6_addr *dest = &inet_rsk(req)->ir_v6_rmt_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668
1669 if (ttd < 0)
1670 ttd = 0;
1671
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 seq_printf(seq,
1673 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Francesco Fuscod14c5ab2013-08-15 13:42:14 +02001674 "%02X %08X:%08X %02X:%08lX %08X %5u %8d %d %d %pK\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675 i,
1676 src->s6_addr32[0], src->s6_addr32[1],
1677 src->s6_addr32[2], src->s6_addr32[3],
Eric Dumazetb44084c2013-10-10 00:04:37 -07001678 inet_rsk(req)->ir_num,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679 dest->s6_addr32[0], dest->s6_addr32[1],
1680 dest->s6_addr32[2], dest->s6_addr32[3],
Eric Dumazet634fb9792013-10-09 15:21:29 -07001681 ntohs(inet_rsk(req)->ir_rmt_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682 TCP_SYN_RECV,
Weilong Chen4c99aa42013-12-19 18:44:34 +08001683 0, 0, /* could print option size, but that is af dependent. */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001684 1, /* timers active (only the expire timer) */
1685 jiffies_to_clock_t(ttd),
Eric Dumazete6c022a2012-10-27 23:16:46 +00001686 req->num_timeout,
Eric Dumazetaa3a0c82015-10-02 11:43:30 -07001687 from_kuid_munged(seq_user_ns(seq),
1688 sock_i_uid(req->rsk_listener)),
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001689 0, /* non standard timer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001690 0, /* open_requests have no inode */
1691 0, req);
1692}
1693
1694static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i)
1695{
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001696 const struct in6_addr *dest, *src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697 __u16 destp, srcp;
1698 int timer_active;
1699 unsigned long timer_expires;
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001700 const struct inet_sock *inet = inet_sk(sp);
1701 const struct tcp_sock *tp = tcp_sk(sp);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001702 const struct inet_connection_sock *icsk = inet_csk(sp);
Eric Dumazet0536fcc2015-09-29 07:42:52 -07001703 const struct fastopen_queue *fastopenq = &icsk->icsk_accept_queue.fastopenq;
Eric Dumazet00fd38d2015-11-12 08:43:18 -08001704 int rx_queue;
1705 int state;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001706
Eric Dumazetefe42082013-10-03 15:42:29 -07001707 dest = &sp->sk_v6_daddr;
1708 src = &sp->sk_v6_rcv_saddr;
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001709 destp = ntohs(inet->inet_dport);
1710 srcp = ntohs(inet->inet_sport);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001711
1712 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713 timer_active = 1;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001714 timer_expires = icsk->icsk_timeout;
1715 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716 timer_active = 4;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001717 timer_expires = icsk->icsk_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718 } else if (timer_pending(&sp->sk_timer)) {
1719 timer_active = 2;
1720 timer_expires = sp->sk_timer.expires;
1721 } else {
1722 timer_active = 0;
1723 timer_expires = jiffies;
1724 }
1725
Eric Dumazet00fd38d2015-11-12 08:43:18 -08001726 state = sk_state_load(sp);
1727 if (state == TCP_LISTEN)
1728 rx_queue = sp->sk_ack_backlog;
1729 else
1730 /* Because we don't lock the socket,
1731 * we might find a transient negative value.
1732 */
1733 rx_queue = max_t(int, tp->rcv_nxt - tp->copied_seq, 0);
1734
Linus Torvalds1da177e2005-04-16 15:20:36 -07001735 seq_printf(seq,
1736 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Francesco Fuscod14c5ab2013-08-15 13:42:14 +02001737 "%02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %lu %lu %u %u %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738 i,
1739 src->s6_addr32[0], src->s6_addr32[1],
1740 src->s6_addr32[2], src->s6_addr32[3], srcp,
1741 dest->s6_addr32[0], dest->s6_addr32[1],
1742 dest->s6_addr32[2], dest->s6_addr32[3], destp,
Eric Dumazet00fd38d2015-11-12 08:43:18 -08001743 state,
1744 tp->write_seq - tp->snd_una,
1745 rx_queue,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746 timer_active,
Eric Dumazeta399a802012-08-08 21:13:53 +00001747 jiffies_delta_to_clock_t(timer_expires - jiffies),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001748 icsk->icsk_retransmits,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06001749 from_kuid_munged(seq_user_ns(seq), sock_i_uid(sp)),
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001750 icsk->icsk_probes_out,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001751 sock_i_ino(sp),
1752 atomic_read(&sp->sk_refcnt), sp,
Stephen Hemminger7be87352008-06-27 20:00:19 -07001753 jiffies_to_clock_t(icsk->icsk_rto),
1754 jiffies_to_clock_t(icsk->icsk_ack.ato),
Weilong Chen4c99aa42013-12-19 18:44:34 +08001755 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
Ilpo Järvinen0b6a05c2009-09-15 01:30:10 -07001756 tp->snd_cwnd,
Eric Dumazet00fd38d2015-11-12 08:43:18 -08001757 state == TCP_LISTEN ?
Eric Dumazet0536fcc2015-09-29 07:42:52 -07001758 fastopenq->max_qlen :
Yuchung Cheng0a672f72014-05-11 20:22:12 -07001759 (tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760 );
1761}
1762
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001763static void get_timewait6_sock(struct seq_file *seq,
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001764 struct inet_timewait_sock *tw, int i)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001765{
Eric Dumazet789f5582015-04-12 18:51:09 -07001766 long delta = tw->tw_timer.expires - jiffies;
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001767 const struct in6_addr *dest, *src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768 __u16 destp, srcp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769
Eric Dumazetefe42082013-10-03 15:42:29 -07001770 dest = &tw->tw_v6_daddr;
1771 src = &tw->tw_v6_rcv_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772 destp = ntohs(tw->tw_dport);
1773 srcp = ntohs(tw->tw_sport);
1774
1775 seq_printf(seq,
1776 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Dan Rosenberg71338aa2011-05-23 12:17:35 +00001777 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778 i,
1779 src->s6_addr32[0], src->s6_addr32[1],
1780 src->s6_addr32[2], src->s6_addr32[3], srcp,
1781 dest->s6_addr32[0], dest->s6_addr32[1],
1782 dest->s6_addr32[2], dest->s6_addr32[3], destp,
1783 tw->tw_substate, 0, 0,
Eric Dumazeta399a802012-08-08 21:13:53 +00001784 3, jiffies_delta_to_clock_t(delta), 0, 0, 0, 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785 atomic_read(&tw->tw_refcnt), tw);
1786}
1787
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788static int tcp6_seq_show(struct seq_file *seq, void *v)
1789{
1790 struct tcp_iter_state *st;
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07001791 struct sock *sk = v;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792
1793 if (v == SEQ_START_TOKEN) {
1794 seq_puts(seq,
1795 " sl "
1796 "local_address "
1797 "remote_address "
1798 "st tx_queue rx_queue tr tm->when retrnsmt"
1799 " uid timeout inode\n");
1800 goto out;
1801 }
1802 st = seq->private;
1803
Eric Dumazet079096f2015-10-02 11:43:32 -07001804 if (sk->sk_state == TCP_TIME_WAIT)
1805 get_timewait6_sock(seq, v, st->num);
1806 else if (sk->sk_state == TCP_NEW_SYN_RECV)
Eric Dumazetaa3a0c82015-10-02 11:43:30 -07001807 get_openreq6(seq, v, st->num);
Eric Dumazet079096f2015-10-02 11:43:32 -07001808 else
1809 get_tcp6_sock(seq, v, st->num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810out:
1811 return 0;
1812}
1813
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00001814static const struct file_operations tcp6_afinfo_seq_fops = {
1815 .owner = THIS_MODULE,
1816 .open = tcp_seq_open,
1817 .read = seq_read,
1818 .llseek = seq_lseek,
1819 .release = seq_release_net
1820};
1821
Linus Torvalds1da177e2005-04-16 15:20:36 -07001822static struct tcp_seq_afinfo tcp6_seq_afinfo = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823 .name = "tcp6",
1824 .family = AF_INET6,
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00001825 .seq_fops = &tcp6_afinfo_seq_fops,
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07001826 .seq_ops = {
1827 .show = tcp6_seq_show,
1828 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829};
1830
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001831int __net_init tcp6_proc_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07001833 return tcp_proc_register(net, &tcp6_seq_afinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834}
1835
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07001836void tcp6_proc_exit(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07001838 tcp_proc_unregister(net, &tcp6_seq_afinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839}
1840#endif
1841
Eric Dumazetf77d6022013-05-09 10:28:16 +00001842static void tcp_v6_clear_sk(struct sock *sk, int size)
1843{
1844 struct inet_sock *inet = inet_sk(sk);
1845
1846 /* we do not want to clear pinet6 field, because of RCU lookups */
1847 sk_prot_clear_nulls(sk, offsetof(struct inet_sock, pinet6));
1848
1849 size -= offsetof(struct inet_sock, pinet6) + sizeof(inet->pinet6);
1850 memset(&inet->pinet6 + 1, 0, size);
1851}
1852
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853struct proto tcpv6_prot = {
1854 .name = "TCPv6",
1855 .owner = THIS_MODULE,
1856 .close = tcp_close,
1857 .connect = tcp_v6_connect,
1858 .disconnect = tcp_disconnect,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001859 .accept = inet_csk_accept,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860 .ioctl = tcp_ioctl,
1861 .init = tcp_v6_init_sock,
1862 .destroy = tcp_v6_destroy_sock,
1863 .shutdown = tcp_shutdown,
1864 .setsockopt = tcp_setsockopt,
1865 .getsockopt = tcp_getsockopt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866 .recvmsg = tcp_recvmsg,
Changli Gao7ba42912010-07-10 20:41:55 +00001867 .sendmsg = tcp_sendmsg,
1868 .sendpage = tcp_sendpage,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001869 .backlog_rcv = tcp_v6_do_rcv,
Eric Dumazet46d3cea2012-07-11 05:50:31 +00001870 .release_cb = tcp_release_cb,
Craig Gallek496611d2016-02-10 11:50:36 -05001871 .hash = inet6_hash,
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001872 .unhash = inet_unhash,
1873 .get_port = inet_csk_get_port,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874 .enter_memory_pressure = tcp_enter_memory_pressure,
Eric Dumazetc9bee3b72013-07-22 20:27:07 -07001875 .stream_memory_free = tcp_stream_memory_free,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001876 .sockets_allocated = &tcp_sockets_allocated,
1877 .memory_allocated = &tcp_memory_allocated,
1878 .memory_pressure = &tcp_memory_pressure,
Arnaldo Carvalho de Melo0a5578c2005-08-09 20:11:41 -07001879 .orphan_count = &tcp_orphan_count,
Eric W. Biedermana4fe34b2013-10-19 16:25:36 -07001880 .sysctl_mem = sysctl_tcp_mem,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001881 .sysctl_wmem = sysctl_tcp_wmem,
1882 .sysctl_rmem = sysctl_tcp_rmem,
1883 .max_header = MAX_TCP_HEADER,
1884 .obj_size = sizeof(struct tcp6_sock),
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001885 .slab_flags = SLAB_DESTROY_BY_RCU,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08001886 .twsk_prot = &tcp6_timewait_sock_ops,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001887 .rsk_prot = &tcp6_request_sock_ops,
Pavel Emelyanov39d8cda2008-03-22 16:50:58 -07001888 .h.hashinfo = &tcp_hashinfo,
Changli Gao7ba42912010-07-10 20:41:55 +00001889 .no_autobind = true,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001890#ifdef CONFIG_COMPAT
1891 .compat_setsockopt = compat_tcp_setsockopt,
1892 .compat_getsockopt = compat_tcp_getsockopt,
1893#endif
Eric Dumazetf77d6022013-05-09 10:28:16 +00001894 .clear_sk = tcp_v6_clear_sk,
Lorenzo Colittic1e64e22015-12-16 12:30:05 +09001895 .diag_destroy = tcp_abort,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896};
1897
Alexey Dobriyan41135cc2009-09-14 12:22:28 +00001898static const struct inet6_protocol tcpv6_protocol = {
Eric Dumazetc7109982012-07-26 12:18:11 +00001899 .early_demux = tcp_v6_early_demux,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900 .handler = tcp_v6_rcv,
1901 .err_handler = tcp_v6_err,
1902 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
1903};
1904
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905static struct inet_protosw tcpv6_protosw = {
1906 .type = SOCK_STREAM,
1907 .protocol = IPPROTO_TCP,
1908 .prot = &tcpv6_prot,
1909 .ops = &inet6_stream_ops,
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001910 .flags = INET_PROTOSW_PERMANENT |
1911 INET_PROTOSW_ICSK,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912};
1913
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001914static int __net_init tcpv6_net_init(struct net *net)
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001915{
Denis V. Lunev56772422008-04-03 14:28:30 -07001916 return inet_ctl_sock_create(&net->ipv6.tcp_sk, PF_INET6,
1917 SOCK_RAW, IPPROTO_TCP, net);
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001918}
1919
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001920static void __net_exit tcpv6_net_exit(struct net *net)
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001921{
Denis V. Lunev56772422008-04-03 14:28:30 -07001922 inet_ctl_sock_destroy(net->ipv6.tcp_sk);
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00001923}
1924
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001925static void __net_exit tcpv6_net_exit_batch(struct list_head *net_exit_list)
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00001926{
1927 inet_twsk_purge(&tcp_hashinfo, &tcp_death_row, AF_INET6);
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001928}
1929
1930static struct pernet_operations tcpv6_net_ops = {
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00001931 .init = tcpv6_net_init,
1932 .exit = tcpv6_net_exit,
1933 .exit_batch = tcpv6_net_exit_batch,
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001934};
1935
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001936int __init tcpv6_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937{
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001938 int ret;
David Woodhouseae0f7d52006-01-11 15:53:04 -08001939
Vlad Yasevich33362882012-11-15 08:49:15 +00001940 ret = inet6_add_protocol(&tcpv6_protocol, IPPROTO_TCP);
1941 if (ret)
Vlad Yasevichc6b641a2012-11-15 08:49:22 +00001942 goto out;
Vlad Yasevich33362882012-11-15 08:49:15 +00001943
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001944 /* register inet6 protocol */
1945 ret = inet6_register_protosw(&tcpv6_protosw);
1946 if (ret)
1947 goto out_tcpv6_protocol;
1948
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001949 ret = register_pernet_subsys(&tcpv6_net_ops);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001950 if (ret)
1951 goto out_tcpv6_protosw;
1952out:
1953 return ret;
1954
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001955out_tcpv6_protosw:
1956 inet6_unregister_protosw(&tcpv6_protosw);
Vlad Yasevich33362882012-11-15 08:49:15 +00001957out_tcpv6_protocol:
1958 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001959 goto out;
1960}
1961
Daniel Lezcano09f77092007-12-13 05:34:58 -08001962void tcpv6_exit(void)
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001963{
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001964 unregister_pernet_subsys(&tcpv6_net_ops);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001965 inet6_unregister_protosw(&tcpv6_protosw);
1966 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967}