blob: a004e0b0b3e961b3a5fdcc5babb8d2ea065bf5b9 [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>
Glauber Costad1a4c0b2011-12-11 21:47:04 +000064#include <net/tcp_memcontrol.h>
Eliezer Tamir076bb0c2013-07-10 17:13:17 +030065#include <net/busy_poll.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
Linus Torvalds1da177e2005-04-16 15:20:36 -070067#include <linux/proc_fs.h>
68#include <linux/seq_file.h>
69
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080070#include <linux/crypto.h>
71#include <linux/scatterlist.h>
72
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080073static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb);
Gui Jianfeng6edafaa2008-08-06 23:50:04 -070074static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
75 struct request_sock *req);
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
77static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070078
Stephen Hemminger3b401a82009-09-01 19:25:04 +000079static const struct inet_connection_sock_af_ops ipv6_mapped;
80static const struct inet_connection_sock_af_ops ipv6_specific;
David S. Millera9286302006-11-14 19:53:22 -080081#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +000082static const struct tcp_sock_af_ops tcp_sock_ipv6_specific;
83static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific;
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +090084#else
85static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
Eric Dumazetb71d1d42011-04-22 04:53:02 +000086 const struct in6_addr *addr)
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +090087{
88 return NULL;
89}
David S. Millera9286302006-11-14 19:53:22 -080090#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
Neal Cardwellfae6ef82012-08-19 03:30:38 +000092static void inet6_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb)
93{
94 struct dst_entry *dst = skb_dst(skb);
Neal Cardwellfae6ef82012-08-19 03:30:38 +000095
Eric Dumazetca777ef2014-09-08 08:06:07 -070096 if (dst) {
97 const struct rt6_info *rt = (const struct rt6_info *)dst;
98
99 dst_hold(dst);
100 sk->sk_rx_dst = dst;
101 inet_sk(sk)->rx_dst_ifindex = skb->skb_iif;
Martin KaFai Laub197df42015-05-22 20:56:01 -0700102 inet6_sk(sk)->rx_dst_cookie = rt6_get_cookie(rt);
Eric Dumazetca777ef2014-09-08 08:06:07 -0700103 }
Neal Cardwellfae6ef82012-08-19 03:30:38 +0000104}
105
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400106static __u32 tcp_v6_init_sequence(const struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107{
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700108 return secure_tcpv6_sequence_number(ipv6_hdr(skb)->daddr.s6_addr32,
109 ipv6_hdr(skb)->saddr.s6_addr32,
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700110 tcp_hdr(skb)->dest,
111 tcp_hdr(skb)->source);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112}
113
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900114static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 int addr_len)
116{
117 struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900118 struct inet_sock *inet = inet_sk(sk);
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800119 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 struct ipv6_pinfo *np = inet6_sk(sk);
121 struct tcp_sock *tp = tcp_sk(sk);
Arnaud Ebalard20c59de2010-06-01 21:35:01 +0000122 struct in6_addr *saddr = NULL, *final_p, final;
David S. Miller4c9483b2011-03-12 16:22:43 -0500123 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 struct dst_entry *dst;
125 int addr_type;
126 int err;
127
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900128 if (addr_len < SIN6_LEN_RFC2133)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 return -EINVAL;
130
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900131 if (usin->sin6_family != AF_INET6)
Eric Dumazeta02cec22010-09-22 20:43:57 +0000132 return -EAFNOSUPPORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133
David S. Miller4c9483b2011-03-12 16:22:43 -0500134 memset(&fl6, 0, sizeof(fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135
136 if (np->sndflow) {
David S. Miller4c9483b2011-03-12 16:22:43 -0500137 fl6.flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK;
138 IP6_ECN_flow_init(fl6.flowlabel);
139 if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 struct ip6_flowlabel *flowlabel;
David S. Miller4c9483b2011-03-12 16:22:43 -0500141 flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
Ian Morris63159f22015-03-29 14:00:04 +0100142 if (!flowlabel)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 fl6_sock_release(flowlabel);
145 }
146 }
147
148 /*
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900149 * connect() to INADDR_ANY means loopback (BSD'ism).
150 */
151
Weilong Chen4c99aa42013-12-19 18:44:34 +0800152 if (ipv6_addr_any(&usin->sin6_addr))
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900153 usin->sin6_addr.s6_addr[15] = 0x1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
155 addr_type = ipv6_addr_type(&usin->sin6_addr);
156
Weilong Chen4c99aa42013-12-19 18:44:34 +0800157 if (addr_type & IPV6_ADDR_MULTICAST)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 return -ENETUNREACH;
159
160 if (addr_type&IPV6_ADDR_LINKLOCAL) {
161 if (addr_len >= sizeof(struct sockaddr_in6) &&
162 usin->sin6_scope_id) {
163 /* If interface is set while binding, indices
164 * must coincide.
165 */
166 if (sk->sk_bound_dev_if &&
167 sk->sk_bound_dev_if != usin->sin6_scope_id)
168 return -EINVAL;
169
170 sk->sk_bound_dev_if = usin->sin6_scope_id;
171 }
172
173 /* Connect to link-local address requires an interface */
174 if (!sk->sk_bound_dev_if)
175 return -EINVAL;
176 }
177
178 if (tp->rx_opt.ts_recent_stamp &&
Eric Dumazetefe42082013-10-03 15:42:29 -0700179 !ipv6_addr_equal(&sk->sk_v6_daddr, &usin->sin6_addr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 tp->rx_opt.ts_recent = 0;
181 tp->rx_opt.ts_recent_stamp = 0;
182 tp->write_seq = 0;
183 }
184
Eric Dumazetefe42082013-10-03 15:42:29 -0700185 sk->sk_v6_daddr = usin->sin6_addr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500186 np->flow_label = fl6.flowlabel;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187
188 /*
189 * TCP over IPv4
190 */
191
192 if (addr_type == IPV6_ADDR_MAPPED) {
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800193 u32 exthdrlen = icsk->icsk_ext_hdr_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 struct sockaddr_in sin;
195
196 SOCK_DEBUG(sk, "connect: ipv4 mapped\n");
197
198 if (__ipv6_only_sock(sk))
199 return -ENETUNREACH;
200
201 sin.sin_family = AF_INET;
202 sin.sin_port = usin->sin6_port;
203 sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
204
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800205 icsk->icsk_af_ops = &ipv6_mapped;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 sk->sk_backlog_rcv = tcp_v4_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800207#ifdef CONFIG_TCP_MD5SIG
208 tp->af_specific = &tcp_sock_ipv6_mapped_specific;
209#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210
211 err = tcp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
212
213 if (err) {
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800214 icsk->icsk_ext_hdr_len = exthdrlen;
215 icsk->icsk_af_ops = &ipv6_specific;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 sk->sk_backlog_rcv = tcp_v6_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800217#ifdef CONFIG_TCP_MD5SIG
218 tp->af_specific = &tcp_sock_ipv6_specific;
219#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 goto failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 }
Eric Dumazetd1e559d2015-03-18 14:05:35 -0700222 np->saddr = sk->sk_v6_rcv_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223
224 return err;
225 }
226
Eric Dumazetefe42082013-10-03 15:42:29 -0700227 if (!ipv6_addr_any(&sk->sk_v6_rcv_saddr))
228 saddr = &sk->sk_v6_rcv_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229
David S. Miller4c9483b2011-03-12 16:22:43 -0500230 fl6.flowi6_proto = IPPROTO_TCP;
Eric Dumazetefe42082013-10-03 15:42:29 -0700231 fl6.daddr = sk->sk_v6_daddr;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000232 fl6.saddr = saddr ? *saddr : np->saddr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500233 fl6.flowi6_oif = sk->sk_bound_dev_if;
234 fl6.flowi6_mark = sk->sk_mark;
David S. Miller1958b852011-03-12 16:36:19 -0500235 fl6.fl6_dport = usin->sin6_port;
236 fl6.fl6_sport = inet->inet_sport;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237
David S. Miller4c9483b2011-03-12 16:22:43 -0500238 final_p = fl6_update_dst(&fl6, np->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;
YOSHIFUJI Hideaki8e1ef0a2006-08-29 17:15:09 -0700258 __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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 if (np->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800267 icsk->icsk_ext_hdr_len = (np->opt->opt_flen +
268 np->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;
330 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331
Eric Dumazet22150892015-03-22 10:22:23 -0700332 sk = __inet6_lookup_established(net, &tcp_hashinfo,
333 &hdr->daddr, th->dest,
334 &hdr->saddr, ntohs(th->source),
335 skb->dev->ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336
Eric Dumazet22150892015-03-22 10:22:23 -0700337 if (!sk) {
Denis V. Luneve41b5362008-10-08 10:33:26 -0700338 ICMP6_INC_STATS_BH(net, __in6_dev_get(skb->dev),
339 ICMP6_MIB_INERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 return;
341 }
342
343 if (sk->sk_state == TCP_TIME_WAIT) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -0700344 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 return;
346 }
Eric Dumazet22150892015-03-22 10:22:23 -0700347 seq = ntohl(th->seq);
348 if (sk->sk_state == TCP_NEW_SYN_RECV)
349 return tcp_req_err(sk, seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350
351 bh_lock_sock(sk);
Eric Dumazet563d34d2012-07-23 09:48:52 +0200352 if (sock_owned_by_user(sk) && type != ICMPV6_PKT_TOOBIG)
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700353 NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354
355 if (sk->sk_state == TCP_CLOSE)
356 goto out;
357
Stephen Hemmingere802af92010-04-22 15:24:53 -0700358 if (ipv6_hdr(skb)->hop_limit < inet6_sk(sk)->min_hopcount) {
359 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
360 goto out;
361 }
362
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 tp = tcp_sk(sk);
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700364 /* XXX (TFO) - tp->snd_una should be ISN (tcp_create_openreq_child() */
365 fastopen = tp->fastopen_rsk;
366 snd_una = fastopen ? tcp_rsk(fastopen)->snt_isn : tp->snd_una;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 if (sk->sk_state != TCP_LISTEN &&
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700368 !between(seq, snd_una, tp->snd_nxt)) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700369 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 goto out;
371 }
372
373 np = inet6_sk(sk);
374
David S. Millerec18d9a2012-07-12 00:25:15 -0700375 if (type == NDISC_REDIRECT) {
376 struct dst_entry *dst = __sk_dst_check(sk, np->dst_cookie);
377
David S. Miller1ed5c482012-07-12 00:41:25 -0700378 if (dst)
David S. Miller6700c272012-07-17 03:29:28 -0700379 dst->ops->redirect(dst, sk, skb);
Christoph Paasch50a75a82013-04-07 04:53:15 +0000380 goto out;
David S. Millerec18d9a2012-07-12 00:25:15 -0700381 }
382
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 if (type == ICMPV6_PKT_TOOBIG) {
Eric Dumazet0d4f0602013-03-18 07:01:28 +0000384 /* We are not interested in TCP_LISTEN and open_requests
385 * (SYN-ACKs send out by Linux are always <576bytes so
386 * they should go through unfragmented).
387 */
388 if (sk->sk_state == TCP_LISTEN)
389 goto out;
390
Hannes Frederic Sowa93b36cf2013-12-15 03:41:14 +0100391 if (!ip6_sk_accept_pmtu(sk))
392 goto out;
393
Eric Dumazet563d34d2012-07-23 09:48:52 +0200394 tp->mtu_info = ntohl(info);
395 if (!sock_owned_by_user(sk))
396 tcp_v6_mtu_reduced(sk);
Julian Anastasovd013ef2a2012-09-05 10:53:18 +0000397 else if (!test_and_set_bit(TCP_MTU_REDUCED_DEFERRED,
398 &tp->tsq_flags))
399 sock_hold(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 goto out;
401 }
402
403 icmpv6_err_convert(type, code, &err);
404
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700405 /* Might be for an request_sock */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 switch (sk->sk_state) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 case TCP_SYN_SENT:
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700408 case TCP_SYN_RECV:
409 /* Only in fast or simultaneous open. If a fast open socket is
410 * is already accepted it is treated as a connected one below.
411 */
Ian Morris63159f22015-03-29 14:00:04 +0100412 if (fastopen && !fastopen->sk)
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700413 break;
414
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 if (!sock_owned_by_user(sk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 sk->sk_err = err;
417 sk->sk_error_report(sk); /* Wake people up to see the error (see connect in sock.c) */
418
419 tcp_done(sk);
420 } else
421 sk->sk_err_soft = err;
422 goto out;
423 }
424
425 if (!sock_owned_by_user(sk) && np->recverr) {
426 sk->sk_err = err;
427 sk->sk_error_report(sk);
428 } else
429 sk->sk_err_soft = err;
430
431out:
432 bh_unlock_sock(sk);
433 sock_put(sk);
434}
435
436
Neal Cardwell9f10d3f2012-06-28 12:34:21 +0000437static int tcp_v6_send_synack(struct sock *sk, struct dst_entry *dst,
Octavian Purdilad6274bd2014-06-25 17:09:58 +0300438 struct flowi *fl,
Neal Cardwell3840a062012-06-28 12:34:19 +0000439 struct request_sock *req,
Daniel Lee3a19ce02014-05-11 20:22:13 -0700440 u16 queue_mapping,
441 struct tcp_fastopen_cookie *foc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442{
Eric Dumazet634fb9792013-10-09 15:21:29 -0700443 struct inet_request_sock *ireq = inet_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 struct ipv6_pinfo *np = inet6_sk(sk);
Octavian Purdilad6274bd2014-06-25 17:09:58 +0300445 struct flowi6 *fl6 = &fl->u.ip6;
Weilong Chen4c99aa42013-12-19 18:44:34 +0800446 struct sk_buff *skb;
Neal Cardwell94942182012-06-28 12:34:20 +0000447 int err = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448
Neal Cardwell9f10d3f2012-06-28 12:34:21 +0000449 /* First, grab a route. */
450 if (!dst && (dst = inet6_csk_route_req(sk, fl6, req)) == NULL)
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800451 goto done;
Neal Cardwell94942182012-06-28 12:34:20 +0000452
Daniel Lee3a19ce02014-05-11 20:22:13 -0700453 skb = tcp_make_synack(sk, dst, req, foc);
Neal Cardwell94942182012-06-28 12:34:20 +0000454
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 if (skb) {
Eric Dumazet634fb9792013-10-09 15:21:29 -0700456 __tcp_v6_send_check(skb, &ireq->ir_v6_loc_addr,
457 &ireq->ir_v6_rmt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458
Eric Dumazet634fb9792013-10-09 15:21:29 -0700459 fl6->daddr = ireq->ir_v6_rmt_addr;
Ian Morris53b24b82015-03-29 14:00:05 +0100460 if (np->repflow && ireq->pktopts)
Florent Fourcotdf3687f2014-01-17 17:15:03 +0100461 fl6->flowlabel = ip6_flowlabel(ipv6_hdr(ireq->pktopts));
462
Eric Dumazetfff32692012-06-01 01:47:50 +0000463 skb_set_queue_mapping(skb, queue_mapping);
RongQing.Li43264e02012-07-01 17:18:59 +0000464 err = ip6_xmit(sk, skb, fl6, np->opt, np->tclass);
Gerrit Renkerb9df3cb2006-11-14 11:21:36 -0200465 err = net_xmit_eval(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 }
467
468done:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 return err;
470}
471
Octavian Purdila72659ec2010-01-17 19:09:39 -0800472
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700473static void tcp_v6_reqsk_destructor(struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474{
Eric Dumazet634fb9792013-10-09 15:21:29 -0700475 kfree_skb(inet_rsk(req)->pktopts);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476}
477
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800478#ifdef CONFIG_TCP_MD5SIG
479static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000480 const struct in6_addr *addr)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800481{
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000482 return tcp_md5_do_lookup(sk, (union tcp_md5_addr *)addr, AF_INET6);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800483}
484
485static struct tcp_md5sig_key *tcp_v6_md5_lookup(struct sock *sk,
Eric Dumazetfd3a1542015-03-24 15:58:56 -0700486 const struct sock *addr_sk)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800487{
Eric Dumazetefe42082013-10-03 15:42:29 -0700488 return tcp_v6_md5_do_lookup(sk, &addr_sk->sk_v6_daddr);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800489}
490
Wang Yufen4aa956d2014-03-29 09:27:29 +0800491static int tcp_v6_parse_md5_keys(struct sock *sk, char __user *optval,
492 int optlen)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800493{
494 struct tcp_md5sig cmd;
495 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&cmd.tcpm_addr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800496
497 if (optlen < sizeof(cmd))
498 return -EINVAL;
499
500 if (copy_from_user(&cmd, optval, sizeof(cmd)))
501 return -EFAULT;
502
503 if (sin6->sin6_family != AF_INET6)
504 return -EINVAL;
505
506 if (!cmd.tcpm_keylen) {
Brian Haleye773e4f2007-08-24 23:16:08 -0700507 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000508 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3],
509 AF_INET);
510 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr,
511 AF_INET6);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800512 }
513
514 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
515 return -EINVAL;
516
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000517 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
518 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3],
519 AF_INET, cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800520
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000521 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr,
522 AF_INET6, cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800523}
524
Adam Langley49a72df2008-07-19 00:01:42 -0700525static int tcp_v6_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000526 const struct in6_addr *daddr,
527 const struct in6_addr *saddr, int nbytes)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800528{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800529 struct tcp6_pseudohdr *bp;
Adam Langley49a72df2008-07-19 00:01:42 -0700530 struct scatterlist sg;
YOSHIFUJI Hideaki8d26d762008-04-17 13:19:16 +0900531
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800532 bp = &hp->md5_blk.ip6;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800533 /* 1. TCP pseudo-header (RFC2460) */
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000534 bp->saddr = *saddr;
535 bp->daddr = *daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700536 bp->protocol = cpu_to_be32(IPPROTO_TCP);
Adam Langley00b13042008-07-31 21:36:07 -0700537 bp->len = cpu_to_be32(nbytes);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800538
Adam Langley49a72df2008-07-19 00:01:42 -0700539 sg_init_one(&sg, bp, sizeof(*bp));
540 return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
541}
David S. Millerc7da57a2007-10-26 00:41:21 -0700542
Adam Langley49a72df2008-07-19 00:01:42 -0700543static int tcp_v6_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000544 const struct in6_addr *daddr, struct in6_addr *saddr,
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400545 const struct tcphdr *th)
Adam Langley49a72df2008-07-19 00:01:42 -0700546{
547 struct tcp_md5sig_pool *hp;
548 struct hash_desc *desc;
549
550 hp = tcp_get_md5sig_pool();
551 if (!hp)
552 goto clear_hash_noput;
553 desc = &hp->md5_desc;
554
555 if (crypto_hash_init(desc))
556 goto clear_hash;
557 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
558 goto clear_hash;
559 if (tcp_md5_hash_header(hp, th))
560 goto clear_hash;
561 if (tcp_md5_hash_key(hp, key))
562 goto clear_hash;
563 if (crypto_hash_final(desc, md5_hash))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800564 goto clear_hash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800565
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800566 tcp_put_md5sig_pool();
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800567 return 0;
Adam Langley49a72df2008-07-19 00:01:42 -0700568
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800569clear_hash:
570 tcp_put_md5sig_pool();
571clear_hash_noput:
572 memset(md5_hash, 0, 16);
Adam Langley49a72df2008-07-19 00:01:42 -0700573 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800574}
575
Eric Dumazet39f8e582015-03-24 15:58:55 -0700576static int tcp_v6_md5_hash_skb(char *md5_hash,
577 const struct tcp_md5sig_key *key,
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400578 const struct sock *sk,
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400579 const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800580{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000581 const struct in6_addr *saddr, *daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700582 struct tcp_md5sig_pool *hp;
583 struct hash_desc *desc;
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400584 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800585
Eric Dumazet39f8e582015-03-24 15:58:55 -0700586 if (sk) { /* valid for establish/request sockets */
587 saddr = &sk->sk_v6_rcv_saddr;
Eric Dumazetefe42082013-10-03 15:42:29 -0700588 daddr = &sk->sk_v6_daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700589 } else {
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000590 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
Adam Langley49a72df2008-07-19 00:01:42 -0700591 saddr = &ip6h->saddr;
592 daddr = &ip6h->daddr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800593 }
Adam Langley49a72df2008-07-19 00:01:42 -0700594
595 hp = tcp_get_md5sig_pool();
596 if (!hp)
597 goto clear_hash_noput;
598 desc = &hp->md5_desc;
599
600 if (crypto_hash_init(desc))
601 goto clear_hash;
602
603 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
604 goto clear_hash;
605 if (tcp_md5_hash_header(hp, th))
606 goto clear_hash;
607 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
608 goto clear_hash;
609 if (tcp_md5_hash_key(hp, key))
610 goto clear_hash;
611 if (crypto_hash_final(desc, md5_hash))
612 goto clear_hash;
613
614 tcp_put_md5sig_pool();
615 return 0;
616
617clear_hash:
618 tcp_put_md5sig_pool();
619clear_hash_noput:
620 memset(md5_hash, 0, 16);
621 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800622}
623
Eric Dumazetff74e232015-03-24 15:58:54 -0700624static bool tcp_v6_inbound_md5_hash(struct sock *sk, const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800625{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400626 const __u8 *hash_location = NULL;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800627 struct tcp_md5sig_key *hash_expected;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000628 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400629 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800630 int genhash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800631 u8 newhash[16];
632
633 hash_expected = tcp_v6_md5_do_lookup(sk, &ip6h->saddr);
YOSHIFUJI Hideaki7d5d5522008-04-17 12:29:53 +0900634 hash_location = tcp_parse_md5sig_option(th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800635
David S. Miller785957d2008-07-30 03:03:15 -0700636 /* We've parsed the options - do we have a hash? */
637 if (!hash_expected && !hash_location)
Eric Dumazetff74e232015-03-24 15:58:54 -0700638 return false;
David S. Miller785957d2008-07-30 03:03:15 -0700639
640 if (hash_expected && !hash_location) {
641 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
Eric Dumazetff74e232015-03-24 15:58:54 -0700642 return true;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800643 }
644
David S. Miller785957d2008-07-30 03:03:15 -0700645 if (!hash_expected && hash_location) {
646 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
Eric Dumazetff74e232015-03-24 15:58:54 -0700647 return true;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800648 }
649
650 /* check the signature */
Adam Langley49a72df2008-07-19 00:01:42 -0700651 genhash = tcp_v6_md5_hash_skb(newhash,
652 hash_expected,
Eric Dumazet39f8e582015-03-24 15:58:55 -0700653 NULL, skb);
Adam Langley49a72df2008-07-19 00:01:42 -0700654
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800655 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
Joe Perchese87cc472012-05-13 21:56:26 +0000656 net_info_ratelimited("MD5 Hash %s for [%pI6c]:%u->[%pI6c]:%u\n",
657 genhash ? "failed" : "mismatch",
658 &ip6h->saddr, ntohs(th->source),
659 &ip6h->daddr, ntohs(th->dest));
Eric Dumazetff74e232015-03-24 15:58:54 -0700660 return true;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800661 }
Eric Dumazetff74e232015-03-24 15:58:54 -0700662 return false;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800663}
664#endif
665
Octavian Purdila16bea702014-06-25 17:09:53 +0300666static void tcp_v6_init_req(struct request_sock *req, struct sock *sk,
667 struct sk_buff *skb)
668{
669 struct inet_request_sock *ireq = inet_rsk(req);
670 struct ipv6_pinfo *np = inet6_sk(sk);
671
672 ireq->ir_v6_rmt_addr = ipv6_hdr(skb)->saddr;
673 ireq->ir_v6_loc_addr = ipv6_hdr(skb)->daddr;
674
Octavian Purdila16bea702014-06-25 17:09:53 +0300675 /* So that link locals have meaning */
676 if (!sk->sk_bound_dev_if &&
677 ipv6_addr_type(&ireq->ir_v6_rmt_addr) & IPV6_ADDR_LINKLOCAL)
Eric Dumazet870c3152014-10-17 09:17:20 -0700678 ireq->ir_iif = tcp_v6_iif(skb);
Octavian Purdila16bea702014-06-25 17:09:53 +0300679
Eric Dumazet04317da2014-09-05 15:33:32 -0700680 if (!TCP_SKB_CB(skb)->tcp_tw_isn &&
Eric Dumazeta2247722014-09-27 09:50:56 -0700681 (ipv6_opt_accepted(sk, skb, &TCP_SKB_CB(skb)->header.h6) ||
682 np->rxopt.bits.rxinfo ||
Octavian Purdila16bea702014-06-25 17:09:53 +0300683 np->rxopt.bits.rxoinfo || np->rxopt.bits.rxhlim ||
684 np->rxopt.bits.rxohlim || np->repflow)) {
685 atomic_inc(&skb->users);
686 ireq->pktopts = skb;
687 }
688}
689
Octavian Purdilad94e0412014-06-25 17:09:55 +0300690static struct dst_entry *tcp_v6_route_req(struct sock *sk, struct flowi *fl,
691 const struct request_sock *req,
692 bool *strict)
693{
694 if (strict)
695 *strict = true;
696 return inet6_csk_route_req(sk, &fl->u.ip6, req);
697}
698
Glenn Griffinc6aefaf2008-02-07 21:49:26 -0800699struct request_sock_ops tcp6_request_sock_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 .family = AF_INET6,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700701 .obj_size = sizeof(struct tcp6_request_sock),
Octavian Purdila5db92c92014-06-25 17:09:59 +0300702 .rtx_syn_ack = tcp_rtx_synack,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700703 .send_ack = tcp_v6_reqsk_send_ack,
704 .destructor = tcp_v6_reqsk_destructor,
Octavian Purdila72659ec2010-01-17 19:09:39 -0800705 .send_reset = tcp_v6_send_reset,
Wang Yufen4aa956d2014-03-29 09:27:29 +0800706 .syn_ack_timeout = tcp_syn_ack_timeout,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707};
708
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +0000709static const struct tcp_request_sock_ops tcp_request_sock_ipv6_ops = {
Octavian Purdila2aec4a22014-06-25 17:10:00 +0300710 .mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) -
711 sizeof(struct ipv6hdr),
Octavian Purdila16bea702014-06-25 17:09:53 +0300712#ifdef CONFIG_TCP_MD5SIG
Eric Dumazetfd3a1542015-03-24 15:58:56 -0700713 .req_md5_lookup = tcp_v6_md5_lookup,
John Dykstrae3afe7b2009-07-16 05:04:51 +0000714 .calc_md5_hash = tcp_v6_md5_hash_skb,
Andrew Mortonb6332e62006-11-30 19:16:28 -0800715#endif
Octavian Purdila16bea702014-06-25 17:09:53 +0300716 .init_req = tcp_v6_init_req,
Octavian Purdilafb7b37a2014-06-25 17:09:54 +0300717#ifdef CONFIG_SYN_COOKIES
718 .cookie_init_seq = cookie_v6_init_sequence,
719#endif
Octavian Purdilad94e0412014-06-25 17:09:55 +0300720 .route_req = tcp_v6_route_req,
Octavian Purdila936b8bd2014-06-25 17:09:57 +0300721 .init_seq = tcp_v6_init_sequence,
Octavian Purdilad6274bd2014-06-25 17:09:58 +0300722 .send_synack = tcp_v6_send_synack,
Octavian Purdila695da142014-06-25 17:10:01 +0300723 .queue_hash_add = inet6_csk_reqsk_queue_hash_add,
Octavian Purdila16bea702014-06-25 17:09:53 +0300724};
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800725
Eric Dumazet0f85fea2014-12-09 09:56:08 -0800726static void tcp_v6_send_response(struct sock *sk, struct sk_buff *skb, u32 seq,
727 u32 ack, u32 win, u32 tsval, u32 tsecr,
728 int oif, struct tcp_md5sig_key *key, int rst,
729 u8 tclass, u32 label)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400731 const struct tcphdr *th = tcp_hdr(skb);
732 struct tcphdr *t1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 struct sk_buff *buff;
David S. Miller4c9483b2011-03-12 16:22:43 -0500734 struct flowi6 fl6;
Eric Dumazet0f85fea2014-12-09 09:56:08 -0800735 struct net *net = sk ? sock_net(sk) : dev_net(skb_dst(skb)->dev);
Daniel Lezcanoe5047992008-03-07 11:16:26 -0800736 struct sock *ctl_sk = net->ipv6.tcp_sk;
YOSHIFUJI Hideaki9cb57342008-01-12 02:16:03 -0800737 unsigned int tot_len = sizeof(struct tcphdr);
Eric Dumazetadf30902009-06-02 05:19:30 +0000738 struct dst_entry *dst;
Al Viroe69a4adc2006-11-14 20:56:00 -0800739 __be32 *topt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740
Andrey Vaginee684b62013-02-11 05:50:19 +0000741 if (tsecr)
YOSHIFUJI Hideaki4244f8a2006-10-10 19:40:50 -0700742 tot_len += TCPOLEN_TSTAMP_ALIGNED;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800743#ifdef CONFIG_TCP_MD5SIG
744 if (key)
745 tot_len += TCPOLEN_MD5SIG_ALIGNED;
746#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747
748 buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
749 GFP_ATOMIC);
Ian Morris63159f22015-03-29 14:00:04 +0100750 if (!buff)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 return;
752
753 skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
754
Ilpo Järvinen77c676d2008-10-09 14:41:38 -0700755 t1 = (struct tcphdr *) skb_push(buff, tot_len);
Herbert Xu6651ffc2010-04-21 00:47:15 -0700756 skb_reset_transport_header(buff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757
758 /* Swap the send and the receive. */
759 memset(t1, 0, sizeof(*t1));
760 t1->dest = th->source;
761 t1->source = th->dest;
Ilpo Järvinen77c676d2008-10-09 14:41:38 -0700762 t1->doff = tot_len / 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 t1->seq = htonl(seq);
764 t1->ack_seq = htonl(ack);
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700765 t1->ack = !rst || !th->ack;
766 t1->rst = rst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767 t1->window = htons(win);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800768
Al Viroe69a4adc2006-11-14 20:56:00 -0800769 topt = (__be32 *)(t1 + 1);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900770
Andrey Vaginee684b62013-02-11 05:50:19 +0000771 if (tsecr) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800772 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
773 (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
Andrey Vaginee684b62013-02-11 05:50:19 +0000774 *topt++ = htonl(tsval);
775 *topt++ = htonl(tsecr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 }
777
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800778#ifdef CONFIG_TCP_MD5SIG
779 if (key) {
780 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
781 (TCPOPT_MD5SIG << 8) | TCPOLEN_MD5SIG);
Adam Langley49a72df2008-07-19 00:01:42 -0700782 tcp_v6_md5_hash_hdr((__u8 *)topt, key,
Adam Langley90b7e112008-07-31 20:49:48 -0700783 &ipv6_hdr(skb)->saddr,
784 &ipv6_hdr(skb)->daddr, t1);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800785 }
786#endif
787
David S. Miller4c9483b2011-03-12 16:22:43 -0500788 memset(&fl6, 0, sizeof(fl6));
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000789 fl6.daddr = ipv6_hdr(skb)->saddr;
790 fl6.saddr = ipv6_hdr(skb)->daddr;
Florent Fourcot1d13a962014-01-16 17:21:22 +0100791 fl6.flowlabel = label;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792
David S. Millere5700af2010-04-21 14:59:20 -0700793 buff->ip_summed = CHECKSUM_PARTIAL;
794 buff->csum = 0;
795
David S. Miller4c9483b2011-03-12 16:22:43 -0500796 __tcp_v6_send_check(buff, &fl6.saddr, &fl6.daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797
David S. Miller4c9483b2011-03-12 16:22:43 -0500798 fl6.flowi6_proto = IPPROTO_TCP;
Lorenzo Colittia36dbdb2014-04-11 13:19:12 +0900799 if (rt6_need_strict(&fl6.daddr) && !oif)
Eric Dumazet870c3152014-10-17 09:17:20 -0700800 fl6.flowi6_oif = tcp_v6_iif(skb);
Wang Yufen9c76a112014-03-29 09:27:31 +0800801 else
802 fl6.flowi6_oif = oif;
Lorenzo Colittie1108612014-05-13 10:17:33 -0700803 fl6.flowi6_mark = IP6_REPLY_MARK(net, skb->mark);
David S. Miller1958b852011-03-12 16:36:19 -0500804 fl6.fl6_dport = t1->dest;
805 fl6.fl6_sport = t1->source;
David S. Miller4c9483b2011-03-12 16:22:43 -0500806 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700808 /* Pass a socket to ip6_dst_lookup either it is for RST
809 * Underlying function will use this to retrieve the network
810 * namespace
811 */
Steffen Klassert0e0d44a2013-08-28 08:04:14 +0200812 dst = ip6_dst_lookup_flow(ctl_sk, &fl6, NULL);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800813 if (!IS_ERR(dst)) {
814 skb_dst_set(buff, dst);
Eric Dumazetb903d322011-10-27 00:44:35 -0400815 ip6_xmit(ctl_sk, buff, &fl6, NULL, tclass);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800816 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
817 if (rst)
818 TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
819 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 }
821
822 kfree_skb(buff);
823}
824
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700825static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb)
826{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400827 const struct tcphdr *th = tcp_hdr(skb);
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700828 u32 seq = 0, ack_seq = 0;
Guo-Fu Tsengfa3e5b42008-10-09 21:11:56 -0700829 struct tcp_md5sig_key *key = NULL;
Shawn Lu658ddaa2012-01-31 22:35:48 +0000830#ifdef CONFIG_TCP_MD5SIG
831 const __u8 *hash_location = NULL;
832 struct ipv6hdr *ipv6h = ipv6_hdr(skb);
833 unsigned char newhash[16];
834 int genhash;
835 struct sock *sk1 = NULL;
836#endif
Wang Yufen9c76a112014-03-29 09:27:31 +0800837 int oif;
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700838
839 if (th->rst)
840 return;
841
Eric Dumazetc3658e82014-11-25 07:40:04 -0800842 /* If sk not NULL, it means we did a successful lookup and incoming
843 * route had to be correct. prequeue might have dropped our dst.
844 */
845 if (!sk && !ipv6_unicast_destination(skb))
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700846 return;
847
848#ifdef CONFIG_TCP_MD5SIG
Shawn Lu658ddaa2012-01-31 22:35:48 +0000849 hash_location = tcp_parse_md5sig_option(th);
850 if (!sk && hash_location) {
851 /*
852 * active side is lost. Try to find listening socket through
853 * source port, and then find md5 key through listening socket.
854 * we are not loose security here:
855 * Incoming packet is checked with md5 hash with finding key,
856 * no RST generated if md5 hash doesn't match.
857 */
858 sk1 = inet6_lookup_listener(dev_net(skb_dst(skb)->dev),
Tom Herbert5ba24952013-01-22 09:50:39 +0000859 &tcp_hashinfo, &ipv6h->saddr,
860 th->source, &ipv6h->daddr,
Eric Dumazet870c3152014-10-17 09:17:20 -0700861 ntohs(th->source), tcp_v6_iif(skb));
Shawn Lu658ddaa2012-01-31 22:35:48 +0000862 if (!sk1)
863 return;
864
865 rcu_read_lock();
866 key = tcp_v6_md5_do_lookup(sk1, &ipv6h->saddr);
867 if (!key)
868 goto release_sk1;
869
Eric Dumazet39f8e582015-03-24 15:58:55 -0700870 genhash = tcp_v6_md5_hash_skb(newhash, key, NULL, skb);
Shawn Lu658ddaa2012-01-31 22:35:48 +0000871 if (genhash || memcmp(hash_location, newhash, 16) != 0)
872 goto release_sk1;
873 } else {
874 key = sk ? tcp_v6_md5_do_lookup(sk, &ipv6h->saddr) : NULL;
875 }
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700876#endif
877
878 if (th->ack)
879 seq = ntohl(th->ack_seq);
880 else
881 ack_seq = ntohl(th->seq) + th->syn + th->fin + skb->len -
882 (th->doff << 2);
883
Wang Yufen9c76a112014-03-29 09:27:31 +0800884 oif = sk ? sk->sk_bound_dev_if : 0;
Eric Dumazet0f85fea2014-12-09 09:56:08 -0800885 tcp_v6_send_response(sk, skb, seq, ack_seq, 0, 0, 0, oif, key, 1, 0, 0);
Shawn Lu658ddaa2012-01-31 22:35:48 +0000886
887#ifdef CONFIG_TCP_MD5SIG
888release_sk1:
889 if (sk1) {
890 rcu_read_unlock();
891 sock_put(sk1);
892 }
893#endif
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700894}
895
Eric Dumazet0f85fea2014-12-09 09:56:08 -0800896static void tcp_v6_send_ack(struct sock *sk, struct sk_buff *skb, u32 seq,
897 u32 ack, u32 win, u32 tsval, u32 tsecr, int oif,
Florent Fourcot1d13a962014-01-16 17:21:22 +0100898 struct tcp_md5sig_key *key, u8 tclass,
899 u32 label)
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700900{
Eric Dumazet0f85fea2014-12-09 09:56:08 -0800901 tcp_v6_send_response(sk, skb, seq, ack, win, tsval, tsecr, oif, key, 0,
902 tclass, label);
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700903}
904
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
906{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700907 struct inet_timewait_sock *tw = inet_twsk(sk);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800908 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909
Eric Dumazet0f85fea2014-12-09 09:56:08 -0800910 tcp_v6_send_ack(sk, skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700911 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
Andrey Vaginee684b62013-02-11 05:50:19 +0000912 tcp_time_stamp + tcptw->tw_ts_offset,
Wang Yufen9c76a112014-03-29 09:27:31 +0800913 tcptw->tw_ts_recent, tw->tw_bound_dev_if, tcp_twsk_md5_key(tcptw),
Florent Fourcot21858cd2015-05-16 00:24:59 +0200914 tw->tw_tclass, cpu_to_be32(tw->tw_flowlabel));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700916 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917}
918
Gui Jianfeng6edafaa2008-08-06 23:50:04 -0700919static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
920 struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921{
Daniel Lee3a19ce02014-05-11 20:22:13 -0700922 /* sk->sk_state == TCP_LISTEN -> for regular TCP_SYN_RECV
923 * sk->sk_state == TCP_SYN_RECV -> for Fast Open.
924 */
Eric Dumazet0f85fea2014-12-09 09:56:08 -0800925 tcp_v6_send_ack(sk, skb, (sk->sk_state == TCP_LISTEN) ?
Daniel Lee3a19ce02014-05-11 20:22:13 -0700926 tcp_rsk(req)->snt_isn + 1 : tcp_sk(sk)->snd_nxt,
Eric Dumazet0f85fea2014-12-09 09:56:08 -0800927 tcp_rsk(req)->rcv_nxt, req->rcv_wnd,
928 tcp_time_stamp, req->ts_recent, sk->sk_bound_dev_if,
Florent Fourcot1d13a962014-01-16 17:21:22 +0100929 tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr),
930 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931}
932
933
Weilong Chen4c99aa42013-12-19 18:44:34 +0800934static struct sock *tcp_v6_hnd_req(struct sock *sk, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700936 const struct tcphdr *th = tcp_hdr(skb);
Eric Dumazet52452c52015-03-19 19:04:19 -0700937 struct request_sock *req;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 struct sock *nsk;
939
940 /* Find possible connection requests. */
Eric Dumazet52452c52015-03-19 19:04:19 -0700941 req = inet6_csk_search_req(sk, th->source,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700942 &ipv6_hdr(skb)->saddr,
Eric Dumazet870c3152014-10-17 09:17:20 -0700943 &ipv6_hdr(skb)->daddr, tcp_v6_iif(skb));
Eric Dumazetfa76ce732015-03-19 19:04:20 -0700944 if (req) {
945 nsk = tcp_check_req(sk, skb, req, false);
Eric Dumazet3257d8b2015-08-10 15:07:34 -0700946 if (!nsk || nsk == sk)
Eric Dumazetb357a362015-04-23 18:03:44 -0700947 reqsk_put(req);
Eric Dumazetfa76ce732015-03-19 19:04:20 -0700948 return nsk;
949 }
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900950 nsk = __inet6_lookup_established(sock_net(sk), &tcp_hashinfo,
Eric Dumazet870c3152014-10-17 09:17:20 -0700951 &ipv6_hdr(skb)->saddr, th->source,
952 &ipv6_hdr(skb)->daddr, ntohs(th->dest),
953 tcp_v6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954
955 if (nsk) {
956 if (nsk->sk_state != TCP_TIME_WAIT) {
957 bh_lock_sock(nsk);
958 return nsk;
959 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -0700960 inet_twsk_put(inet_twsk(nsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961 return NULL;
962 }
963
Glenn Griffinc6aefaf2008-02-07 21:49:26 -0800964#ifdef CONFIG_SYN_COOKIES
Florian Westphalaf9b4732010-06-03 00:43:44 +0000965 if (!th->syn)
Glenn Griffinc6aefaf2008-02-07 21:49:26 -0800966 sk = cookie_v6_check(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967#endif
968 return sk;
969}
970
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
972{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 if (skb->protocol == htons(ETH_P_IP))
974 return tcp_v4_conn_request(sk, skb);
975
976 if (!ipv6_unicast_destination(skb))
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900977 goto drop;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978
Octavian Purdila1fb6f152014-06-25 17:10:02 +0300979 return tcp_conn_request(&tcp6_request_sock_ops,
980 &tcp_request_sock_ipv6_ops, sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982drop:
Vijay Subramanian5f1e9422013-01-31 08:24:19 +0000983 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 return 0; /* don't send reset */
985}
986
Weilong Chen4c99aa42013-12-19 18:44:34 +0800987static struct sock *tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
988 struct request_sock *req,
989 struct dst_entry *dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990{
Eric Dumazet634fb9792013-10-09 15:21:29 -0700991 struct inet_request_sock *ireq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992 struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
993 struct tcp6_sock *newtcp6sk;
994 struct inet_sock *newinet;
995 struct tcp_sock *newtp;
996 struct sock *newsk;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800997#ifdef CONFIG_TCP_MD5SIG
998 struct tcp_md5sig_key *key;
999#endif
Neal Cardwell3840a062012-06-28 12:34:19 +00001000 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001
1002 if (skb->protocol == htons(ETH_P_IP)) {
1003 /*
1004 * v6 mapped
1005 */
1006
1007 newsk = tcp_v4_syn_recv_sock(sk, skb, req, dst);
1008
Ian Morris63159f22015-03-29 14:00:04 +01001009 if (!newsk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 return NULL;
1011
1012 newtcp6sk = (struct tcp6_sock *)newsk;
1013 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1014
1015 newinet = inet_sk(newsk);
1016 newnp = inet6_sk(newsk);
1017 newtp = tcp_sk(newsk);
1018
1019 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1020
Eric Dumazetd1e559d2015-03-18 14:05:35 -07001021 newnp->saddr = newsk->sk_v6_rcv_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001023 inet_csk(newsk)->icsk_af_ops = &ipv6_mapped;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 newsk->sk_backlog_rcv = tcp_v4_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001025#ifdef CONFIG_TCP_MD5SIG
1026 newtp->af_specific = &tcp_sock_ipv6_mapped_specific;
1027#endif
1028
Yan, Zheng676a1182011-09-25 02:21:30 +00001029 newnp->ipv6_ac_list = NULL;
1030 newnp->ipv6_fl_list = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 newnp->pktoptions = NULL;
1032 newnp->opt = NULL;
Eric Dumazet870c3152014-10-17 09:17:20 -07001033 newnp->mcast_oif = tcp_v6_iif(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001034 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
Florent Fourcot1397ed32013-12-08 15:46:57 +01001035 newnp->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(skb));
Florent Fourcotdf3687f2014-01-17 17:15:03 +01001036 if (np->repflow)
1037 newnp->flow_label = ip6_flowlabel(ipv6_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -07001039 /*
1040 * No need to charge this sock to the relevant IPv6 refcnt debug socks count
1041 * here, tcp_create_openreq_child now does this for us, see the comment in
1042 * that function for the gory details. -acme
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044
1045 /* It is tricky place. Until this moment IPv4 tcp
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001046 worked with IPv6 icsk.icsk_af_ops.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047 Sync it now.
1048 */
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001049 tcp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050
1051 return newsk;
1052 }
1053
Eric Dumazet634fb9792013-10-09 15:21:29 -07001054 ireq = inet_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055
1056 if (sk_acceptq_is_full(sk))
1057 goto out_overflow;
1058
David S. Miller493f3772010-12-02 12:14:29 -08001059 if (!dst) {
Neal Cardwell3840a062012-06-28 12:34:19 +00001060 dst = inet6_csk_route_req(sk, &fl6, req);
David S. Miller493f3772010-12-02 12:14:29 -08001061 if (!dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 goto out;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001063 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064
1065 newsk = tcp_create_openreq_child(sk, req, skb);
Ian Morris63159f22015-03-29 14:00:04 +01001066 if (!newsk)
Balazs Scheidler093d2822010-10-21 13:06:43 +02001067 goto out_nonewsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -07001069 /*
1070 * No need to charge this sock to the relevant IPv6 refcnt debug socks
1071 * count here, tcp_create_openreq_child now does this for us, see the
1072 * comment in that function for the gory details. -acme
1073 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074
Stephen Hemminger59eed272006-08-25 15:55:43 -07001075 newsk->sk_gso_type = SKB_GSO_TCPV6;
YOSHIFUJI Hideaki8e1ef0a2006-08-29 17:15:09 -07001076 __ip6_dst_store(newsk, dst, NULL, NULL);
Neal Cardwellfae6ef82012-08-19 03:30:38 +00001077 inet6_sk_rx_dst_set(newsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078
1079 newtcp6sk = (struct tcp6_sock *)newsk;
1080 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1081
1082 newtp = tcp_sk(newsk);
1083 newinet = inet_sk(newsk);
1084 newnp = inet6_sk(newsk);
1085
1086 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1087
Eric Dumazet634fb9792013-10-09 15:21:29 -07001088 newsk->sk_v6_daddr = ireq->ir_v6_rmt_addr;
1089 newnp->saddr = ireq->ir_v6_loc_addr;
1090 newsk->sk_v6_rcv_saddr = ireq->ir_v6_loc_addr;
1091 newsk->sk_bound_dev_if = ireq->ir_iif;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001093 /* Now IPv6 options...
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094
1095 First: no IPv4 options.
1096 */
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001097 newinet->inet_opt = NULL;
Yan, Zheng676a1182011-09-25 02:21:30 +00001098 newnp->ipv6_ac_list = NULL;
Masayuki Nakagawad35690b2007-03-16 16:14:03 -07001099 newnp->ipv6_fl_list = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100
1101 /* Clone RX bits */
1102 newnp->rxopt.all = np->rxopt.all;
1103
1104 /* Clone pktoptions received with SYN */
1105 newnp->pktoptions = NULL;
Ian Morris53b24b82015-03-29 14:00:05 +01001106 if (ireq->pktopts) {
Eric Dumazet634fb9792013-10-09 15:21:29 -07001107 newnp->pktoptions = skb_clone(ireq->pktopts,
Mel Gorman99a1dec2012-07-31 16:44:14 -07001108 sk_gfp_atomic(sk, GFP_ATOMIC));
Eric Dumazet634fb9792013-10-09 15:21:29 -07001109 consume_skb(ireq->pktopts);
1110 ireq->pktopts = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111 if (newnp->pktoptions)
1112 skb_set_owner_r(newnp->pktoptions, newsk);
1113 }
1114 newnp->opt = NULL;
Eric Dumazet870c3152014-10-17 09:17:20 -07001115 newnp->mcast_oif = tcp_v6_iif(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001116 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
Florent Fourcot1397ed32013-12-08 15:46:57 +01001117 newnp->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(skb));
Florent Fourcotdf3687f2014-01-17 17:15:03 +01001118 if (np->repflow)
1119 newnp->flow_label = ip6_flowlabel(ipv6_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120
1121 /* Clone native IPv6 options from listening socket (if any)
1122
1123 Yes, keeping reference count would be much more clever,
1124 but we make one more one thing there: reattach optmem
1125 to newsk.
1126 */
RongQing.Li43264e02012-07-01 17:18:59 +00001127 if (np->opt)
1128 newnp->opt = ipv6_dup_options(newsk, np->opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001130 inet_csk(newsk)->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131 if (newnp->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001132 inet_csk(newsk)->icsk_ext_hdr_len = (newnp->opt->opt_nflen +
1133 newnp->opt->opt_flen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134
Daniel Borkmann81164412015-01-05 23:57:48 +01001135 tcp_ca_openreq_child(newsk, dst);
1136
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 tcp_sync_mss(newsk, dst_mtu(dst));
David S. Miller0dbaee32010-12-13 12:52:14 -08001138 newtp->advmss = dst_metric_advmss(dst);
Neal Cardwelld135c522012-04-22 09:45:47 +00001139 if (tcp_sk(sk)->rx_opt.user_mss &&
1140 tcp_sk(sk)->rx_opt.user_mss < newtp->advmss)
1141 newtp->advmss = tcp_sk(sk)->rx_opt.user_mss;
1142
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143 tcp_initialize_rcv_mss(newsk);
1144
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001145 newinet->inet_daddr = newinet->inet_saddr = LOOPBACK4_IPV6;
1146 newinet->inet_rcv_saddr = LOOPBACK4_IPV6;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001148#ifdef CONFIG_TCP_MD5SIG
1149 /* Copy over the MD5 key from the original socket */
Wang Yufen4aa956d2014-03-29 09:27:29 +08001150 key = tcp_v6_md5_do_lookup(sk, &newsk->sk_v6_daddr);
Ian Morris53b24b82015-03-29 14:00:05 +01001151 if (key) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001152 /* We're using one, so create a matching key
1153 * on the newsk structure. If we fail to get
1154 * memory, then we end up not copying the key
1155 * across. Shucks.
1156 */
Eric Dumazetefe42082013-10-03 15:42:29 -07001157 tcp_md5_do_add(newsk, (union tcp_md5_addr *)&newsk->sk_v6_daddr,
Mel Gorman99a1dec2012-07-31 16:44:14 -07001158 AF_INET6, key->key, key->keylen,
1159 sk_gfp_atomic(sk, GFP_ATOMIC));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001160 }
1161#endif
1162
Balazs Scheidler093d2822010-10-21 13:06:43 +02001163 if (__inet_inherit_port(sk, newsk) < 0) {
Christoph Paasche337e242012-12-14 04:07:58 +00001164 inet_csk_prepare_forced_close(newsk);
1165 tcp_done(newsk);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001166 goto out;
1167 }
Eric Dumazet77a6a472015-03-18 14:05:36 -07001168 __inet_hash(newsk, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169
1170 return newsk;
1171
1172out_overflow:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001173 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001174out_nonewsk:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175 dst_release(dst);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001176out:
1177 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178 return NULL;
1179}
1180
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181/* The socket must have it's spinlock held when we get
1182 * here.
1183 *
1184 * We have a potential double-lock case here, so even when
1185 * doing backlog processing we use the BH locking scheme.
1186 * This is because we cannot sleep with the original spinlock
1187 * held.
1188 */
1189static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
1190{
1191 struct ipv6_pinfo *np = inet6_sk(sk);
1192 struct tcp_sock *tp;
1193 struct sk_buff *opt_skb = NULL;
1194
1195 /* Imagine: socket is IPv6. IPv4 packet arrives,
1196 goes to IPv4 receive handler and backlogged.
1197 From backlog it always goes here. Kerboom...
1198 Fortunately, tcp_rcv_established and rcv_established
1199 handle them correctly, but it is not case with
1200 tcp_v6_hnd_req and tcp_v6_send_reset(). --ANK
1201 */
1202
1203 if (skb->protocol == htons(ETH_P_IP))
1204 return tcp_v4_do_rcv(sk, skb);
1205
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001206 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207 goto discard;
1208
1209 /*
1210 * socket locking is here for SMP purposes as backlog rcv
1211 * is currently called with bh processing disabled.
1212 */
1213
1214 /* Do Stevens' IPV6_PKTOPTIONS.
1215
1216 Yes, guys, it is the only place in our code, where we
1217 may make it not affecting IPv4.
1218 The rest of code is protocol independent,
1219 and I do not like idea to uglify IPv4.
1220
1221 Actually, all the idea behind IPV6_PKTOPTIONS
1222 looks not very well thought. For now we latch
1223 options, received in the last packet, enqueued
1224 by tcp. Feel free to propose better solution.
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001225 --ANK (980728)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226 */
1227 if (np->rxopt.all)
Mel Gorman99a1dec2012-07-31 16:44:14 -07001228 opt_skb = skb_clone(skb, sk_gfp_atomic(sk, GFP_ATOMIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229
1230 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
Eric Dumazet5d299f32012-08-06 05:09:33 +00001231 struct dst_entry *dst = sk->sk_rx_dst;
1232
Tom Herbertbdeab992011-08-14 19:45:55 +00001233 sock_rps_save_rxhash(sk, skb);
Eric Dumazet3d973792014-11-11 05:54:27 -08001234 sk_mark_napi_id(sk, skb);
Eric Dumazet5d299f32012-08-06 05:09:33 +00001235 if (dst) {
1236 if (inet_sk(sk)->rx_dst_ifindex != skb->skb_iif ||
1237 dst->ops->check(dst, np->rx_dst_cookie) == NULL) {
1238 dst_release(dst);
1239 sk->sk_rx_dst = NULL;
1240 }
1241 }
1242
Vijay Subramanianc995ae22013-09-03 12:23:22 -07001243 tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244 if (opt_skb)
1245 goto ipv6_pktoptions;
1246 return 0;
1247 }
1248
Eric Dumazet12e25e12015-06-03 23:49:21 -07001249 if (tcp_checksum_complete(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250 goto csum_err;
1251
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001252 if (sk->sk_state == TCP_LISTEN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253 struct sock *nsk = tcp_v6_hnd_req(sk, skb);
1254 if (!nsk)
1255 goto discard;
1256
1257 /*
1258 * Queue it on the new socket if the new socket is active,
1259 * otherwise we just shortcircuit this and continue with
1260 * the new socket..
1261 */
Weilong Chen4c99aa42013-12-19 18:44:34 +08001262 if (nsk != sk) {
Tom Herbertbdeab992011-08-14 19:45:55 +00001263 sock_rps_save_rxhash(nsk, skb);
Eric Dumazet3d973792014-11-11 05:54:27 -08001264 sk_mark_napi_id(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 if (tcp_child_process(sk, nsk, skb))
1266 goto reset;
1267 if (opt_skb)
1268 __kfree_skb(opt_skb);
1269 return 0;
1270 }
Neil Horman47482f12011-04-06 13:07:09 -07001271 } else
Tom Herbertbdeab992011-08-14 19:45:55 +00001272 sock_rps_save_rxhash(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001274 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 goto reset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 if (opt_skb)
1277 goto ipv6_pktoptions;
1278 return 0;
1279
1280reset:
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001281 tcp_v6_send_reset(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282discard:
1283 if (opt_skb)
1284 __kfree_skb(opt_skb);
1285 kfree_skb(skb);
1286 return 0;
1287csum_err:
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001288 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_CSUMERRORS);
Pavel Emelyanov63231bddf2008-07-16 20:22:25 -07001289 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290 goto discard;
1291
1292
1293ipv6_pktoptions:
1294 /* Do you ask, what is it?
1295
1296 1. skb was enqueued by tcp.
1297 2. skb is added to tail of read queue, rather than out of order.
1298 3. socket is not in passive state.
1299 4. Finally, it really contains options, which user wants to receive.
1300 */
1301 tp = tcp_sk(sk);
1302 if (TCP_SKB_CB(opt_skb)->end_seq == tp->rcv_nxt &&
1303 !((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) {
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +09001304 if (np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo)
Eric Dumazet870c3152014-10-17 09:17:20 -07001305 np->mcast_oif = tcp_v6_iif(opt_skb);
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +09001306 if (np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim)
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001307 np->mcast_hops = ipv6_hdr(opt_skb)->hop_limit;
Florent Fourcot82e9f102013-12-08 15:46:59 +01001308 if (np->rxopt.bits.rxflow || np->rxopt.bits.rxtclass)
Florent Fourcot1397ed32013-12-08 15:46:57 +01001309 np->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(opt_skb));
Florent Fourcotdf3687f2014-01-17 17:15:03 +01001310 if (np->repflow)
1311 np->flow_label = ip6_flowlabel(ipv6_hdr(opt_skb));
Eric Dumazeta2247722014-09-27 09:50:56 -07001312 if (ipv6_opt_accepted(sk, opt_skb, &TCP_SKB_CB(opt_skb)->header.h6)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 skb_set_owner_r(opt_skb, sk);
1314 opt_skb = xchg(&np->pktoptions, opt_skb);
1315 } else {
1316 __kfree_skb(opt_skb);
1317 opt_skb = xchg(&np->pktoptions, NULL);
1318 }
1319 }
1320
Wei Yongjun800d55f2009-02-23 21:45:33 +00001321 kfree_skb(opt_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 return 0;
1323}
1324
Nicolas Dichtel2dc49d12014-12-22 18:22:48 +01001325static void tcp_v6_fill_cb(struct sk_buff *skb, const struct ipv6hdr *hdr,
1326 const struct tcphdr *th)
1327{
1328 /* This is tricky: we move IP6CB at its correct location into
1329 * TCP_SKB_CB(). It must be done after xfrm6_policy_check(), because
1330 * _decode_session6() uses IP6CB().
1331 * barrier() makes sure compiler won't play aliasing games.
1332 */
1333 memmove(&TCP_SKB_CB(skb)->header.h6, IP6CB(skb),
1334 sizeof(struct inet6_skb_parm));
1335 barrier();
1336
1337 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1338 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1339 skb->len - th->doff*4);
1340 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1341 TCP_SKB_CB(skb)->tcp_flags = tcp_flag_byte(th);
1342 TCP_SKB_CB(skb)->tcp_tw_isn = 0;
1343 TCP_SKB_CB(skb)->ip_dsfield = ipv6_get_dsfield(hdr);
1344 TCP_SKB_CB(skb)->sacked = 0;
1345}
1346
Alexey Kodanev4ad19de2015-03-27 12:24:22 +03001347static void tcp_v6_restore_cb(struct sk_buff *skb)
1348{
1349 /* We need to move header back to the beginning if xfrm6_policy_check()
1350 * and tcp_v6_fill_cb() are going to be called again.
1351 */
1352 memmove(IP6CB(skb), &TCP_SKB_CB(skb)->header.h6,
1353 sizeof(struct inet6_skb_parm));
1354}
1355
Herbert Xue5bbef22007-10-15 12:50:28 -07001356static int tcp_v6_rcv(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357{
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001358 const struct tcphdr *th;
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001359 const struct ipv6hdr *hdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360 struct sock *sk;
1361 int ret;
Pavel Emelyanova86b1e32008-07-16 20:20:58 -07001362 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363
1364 if (skb->pkt_type != PACKET_HOST)
1365 goto discard_it;
1366
1367 /*
1368 * Count it even if it's bad.
1369 */
Pavel Emelyanov63231bddf2008-07-16 20:22:25 -07001370 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371
1372 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1373 goto discard_it;
1374
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001375 th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376
1377 if (th->doff < sizeof(struct tcphdr)/4)
1378 goto bad_packet;
1379 if (!pskb_may_pull(skb, th->doff*4))
1380 goto discard_it;
1381
Tom Herberte4f45b72014-05-02 16:29:51 -07001382 if (skb_checksum_init(skb, IPPROTO_TCP, ip6_compute_pseudo))
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001383 goto csum_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001385 th = tcp_hdr(skb);
Stephen Hemmingere802af92010-04-22 15:24:53 -07001386 hdr = ipv6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387
Eric Dumazet870c3152014-10-17 09:17:20 -07001388 sk = __inet6_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest,
Nicolas Dichtel2dc49d12014-12-22 18:22:48 +01001389 inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 if (!sk)
1391 goto no_tcp_socket;
1392
1393process:
1394 if (sk->sk_state == TCP_TIME_WAIT)
1395 goto do_time_wait;
1396
Stephen Hemmingere802af92010-04-22 15:24:53 -07001397 if (hdr->hop_limit < inet6_sk(sk)->min_hopcount) {
1398 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
1399 goto discard_and_relse;
1400 }
1401
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
1403 goto discard_and_relse;
1404
Nicolas Dichtel2dc49d12014-12-22 18:22:48 +01001405 tcp_v6_fill_cb(skb, hdr, th);
1406
Dmitry Popov9ea88a12014-08-07 02:38:22 +04001407#ifdef CONFIG_TCP_MD5SIG
1408 if (tcp_v6_inbound_md5_hash(sk, skb))
1409 goto discard_and_relse;
1410#endif
1411
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001412 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 goto discard_and_relse;
1414
Eric Dumazet2c8c56e2014-11-11 05:54:28 -08001415 sk_incoming_cpu_update(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416 skb->dev = NULL;
1417
Fabio Olive Leite293b9c42006-09-25 22:28:47 -07001418 bh_lock_sock_nested(sk);
Marcelo Ricardo Leitner2efd0552015-05-20 16:35:41 -07001419 tcp_sk(sk)->segs_in += max_t(u16, 1, skb_shinfo(skb)->gso_segs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 ret = 0;
1421 if (!sock_owned_by_user(sk)) {
Dan Williams7bced392013-12-30 12:37:29 -08001422 if (!tcp_prequeue(sk, skb))
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001423 ret = tcp_v6_do_rcv(sk, skb);
Eric Dumazetda882c12012-04-22 23:38:54 +00001424 } else if (unlikely(sk_add_backlog(sk, skb,
1425 sk->sk_rcvbuf + sk->sk_sndbuf))) {
Zhu Yi6b03a532010-03-04 18:01:41 +00001426 bh_unlock_sock(sk);
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001427 NET_INC_STATS_BH(net, LINUX_MIB_TCPBACKLOGDROP);
Zhu Yi6b03a532010-03-04 18:01:41 +00001428 goto discard_and_relse;
1429 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 bh_unlock_sock(sk);
1431
1432 sock_put(sk);
1433 return ret ? -1 : 0;
1434
1435no_tcp_socket:
1436 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
1437 goto discard_it;
1438
Nicolas Dichtel2dc49d12014-12-22 18:22:48 +01001439 tcp_v6_fill_cb(skb, hdr, th);
1440
Eric Dumazet12e25e12015-06-03 23:49:21 -07001441 if (tcp_checksum_complete(skb)) {
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001442csum_error:
1443 TCP_INC_STATS_BH(net, TCP_MIB_CSUMERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444bad_packet:
Pavel Emelyanov63231bddf2008-07-16 20:22:25 -07001445 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001447 tcp_v6_send_reset(NULL, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 }
1449
1450discard_it:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451 kfree_skb(skb);
1452 return 0;
1453
1454discard_and_relse:
1455 sock_put(sk);
1456 goto discard_it;
1457
1458do_time_wait:
1459 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001460 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461 goto discard_it;
1462 }
1463
Nicolas Dichtel2dc49d12014-12-22 18:22:48 +01001464 tcp_v6_fill_cb(skb, hdr, th);
1465
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001466 if (tcp_checksum_complete(skb)) {
1467 inet_twsk_put(inet_twsk(sk));
1468 goto csum_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469 }
1470
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001471 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472 case TCP_TW_SYN:
1473 {
1474 struct sock *sk2;
1475
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001476 sk2 = inet6_lookup_listener(dev_net(skb->dev), &tcp_hashinfo,
Tom Herbert5ba24952013-01-22 09:50:39 +00001477 &ipv6_hdr(skb)->saddr, th->source,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001478 &ipv6_hdr(skb)->daddr,
Eric Dumazet870c3152014-10-17 09:17:20 -07001479 ntohs(th->dest), tcp_v6_iif(skb));
Ian Morris53b24b82015-03-29 14:00:05 +01001480 if (sk2) {
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -07001481 struct inet_timewait_sock *tw = inet_twsk(sk);
Eric Dumazetdbe7faa2015-07-08 14:28:30 -07001482 inet_twsk_deschedule_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483 sk = sk2;
Alexey Kodanev4ad19de2015-03-27 12:24:22 +03001484 tcp_v6_restore_cb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485 goto process;
1486 }
1487 /* Fall through to ACK */
1488 }
1489 case TCP_TW_ACK:
1490 tcp_v6_timewait_ack(sk, skb);
1491 break;
1492 case TCP_TW_RST:
Alexey Kodanev4ad19de2015-03-27 12:24:22 +03001493 tcp_v6_restore_cb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494 goto no_tcp_socket;
Wang Yufen4aa956d2014-03-29 09:27:29 +08001495 case TCP_TW_SUCCESS:
1496 ;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 }
1498 goto discard_it;
1499}
1500
Eric Dumazetc7109982012-07-26 12:18:11 +00001501static void tcp_v6_early_demux(struct sk_buff *skb)
1502{
1503 const struct ipv6hdr *hdr;
1504 const struct tcphdr *th;
1505 struct sock *sk;
1506
1507 if (skb->pkt_type != PACKET_HOST)
1508 return;
1509
1510 if (!pskb_may_pull(skb, skb_transport_offset(skb) + sizeof(struct tcphdr)))
1511 return;
1512
1513 hdr = ipv6_hdr(skb);
1514 th = tcp_hdr(skb);
1515
1516 if (th->doff < sizeof(struct tcphdr) / 4)
1517 return;
1518
Eric Dumazet870c3152014-10-17 09:17:20 -07001519 /* Note : We use inet6_iif() here, not tcp_v6_iif() */
Eric Dumazetc7109982012-07-26 12:18:11 +00001520 sk = __inet6_lookup_established(dev_net(skb->dev), &tcp_hashinfo,
1521 &hdr->saddr, th->source,
1522 &hdr->daddr, ntohs(th->dest),
1523 inet6_iif(skb));
1524 if (sk) {
1525 skb->sk = sk;
1526 skb->destructor = sock_edemux;
Eric Dumazetf7e4eb02015-03-15 21:12:13 -07001527 if (sk_fullsock(sk)) {
Michal Kubečekd0c294c2015-03-23 15:14:00 +01001528 struct dst_entry *dst = READ_ONCE(sk->sk_rx_dst);
Neal Cardwellf3f12132012-10-22 21:41:48 +00001529
Eric Dumazetc7109982012-07-26 12:18:11 +00001530 if (dst)
Eric Dumazet5d299f32012-08-06 05:09:33 +00001531 dst = dst_check(dst, inet6_sk(sk)->rx_dst_cookie);
Eric Dumazetc7109982012-07-26 12:18:11 +00001532 if (dst &&
Neal Cardwellf3f12132012-10-22 21:41:48 +00001533 inet_sk(sk)->rx_dst_ifindex == skb->skb_iif)
Eric Dumazetc7109982012-07-26 12:18:11 +00001534 skb_dst_set_noref(skb, dst);
1535 }
1536 }
1537}
1538
David S. Millerccb7c412010-12-01 18:09:13 -08001539static struct timewait_sock_ops tcp6_timewait_sock_ops = {
1540 .twsk_obj_size = sizeof(struct tcp6_timewait_sock),
1541 .twsk_unique = tcp_twsk_unique,
Wang Yufen4aa956d2014-03-29 09:27:29 +08001542 .twsk_destructor = tcp_twsk_destructor,
David S. Millerccb7c412010-12-01 18:09:13 -08001543};
1544
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001545static const struct inet_connection_sock_af_ops ipv6_specific = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001546 .queue_xmit = inet6_csk_xmit,
1547 .send_check = tcp_v6_send_check,
1548 .rebuild_header = inet6_sk_rebuild_header,
Eric Dumazet5d299f32012-08-06 05:09:33 +00001549 .sk_rx_dst_set = inet6_sk_rx_dst_set,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001550 .conn_request = tcp_v6_conn_request,
1551 .syn_recv_sock = tcp_v6_syn_recv_sock,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001552 .net_header_len = sizeof(struct ipv6hdr),
Eric Dumazet67469602012-04-24 07:37:38 +00001553 .net_frag_header_len = sizeof(struct frag_hdr),
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001554 .setsockopt = ipv6_setsockopt,
1555 .getsockopt = ipv6_getsockopt,
1556 .addr2sockaddr = inet6_csk_addr2sockaddr,
1557 .sockaddr_len = sizeof(struct sockaddr_in6),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001558 .bind_conflict = inet6_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001559#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001560 .compat_setsockopt = compat_ipv6_setsockopt,
1561 .compat_getsockopt = compat_ipv6_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001562#endif
Neal Cardwell4fab9072014-08-14 12:40:05 -04001563 .mtu_reduced = tcp_v6_mtu_reduced,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564};
1565
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001566#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001567static const struct tcp_sock_af_ops tcp_sock_ipv6_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001568 .md5_lookup = tcp_v6_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001569 .calc_md5_hash = tcp_v6_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001570 .md5_parse = tcp_v6_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001571};
David S. Millera9286302006-11-14 19:53:22 -08001572#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001573
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574/*
1575 * TCP over IPv4 via INET6 API
1576 */
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001577static const struct inet_connection_sock_af_ops ipv6_mapped = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001578 .queue_xmit = ip_queue_xmit,
1579 .send_check = tcp_v4_send_check,
1580 .rebuild_header = inet_sk_rebuild_header,
Eric Dumazet63d02d12012-08-09 14:11:00 +00001581 .sk_rx_dst_set = inet_sk_rx_dst_set,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001582 .conn_request = tcp_v6_conn_request,
1583 .syn_recv_sock = tcp_v6_syn_recv_sock,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001584 .net_header_len = sizeof(struct iphdr),
1585 .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_v4_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_mapped_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001599 .md5_lookup = tcp_v4_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001600 .calc_md5_hash = tcp_v4_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/* NOTE: A lot of things set to zero explicitly by call to
1606 * sk_alloc() so need not be done here.
1607 */
1608static int tcp_v6_init_sock(struct sock *sk)
1609{
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001610 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611
Neal Cardwell900f65d2012-04-19 09:55:21 +00001612 tcp_init_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001614 icsk->icsk_af_ops = &ipv6_specific;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001616#ifdef CONFIG_TCP_MD5SIG
David S. Millerac807fa2012-04-23 03:21:58 -04001617 tcp_sk(sk)->af_specific = &tcp_sock_ipv6_specific;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001618#endif
1619
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620 return 0;
1621}
1622
Brian Haley7d06b2e2008-06-14 17:04:49 -07001623static void tcp_v6_destroy_sock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001624{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625 tcp_v4_destroy_sock(sk);
Brian Haley7d06b2e2008-06-14 17:04:49 -07001626 inet6_destroy_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627}
1628
YOSHIFUJI Hideaki952a10b2007-04-21 20:13:44 +09001629#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630/* Proc filesystem TCPv6 sock list dumping. */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001631static void get_openreq6(struct seq_file *seq,
Eric Dumazetd4f06872015-03-12 16:44:09 -07001632 struct request_sock *req, int i, kuid_t uid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633{
Eric Dumazetfa76ce732015-03-19 19:04:20 -07001634 long ttd = req->rsk_timer.expires - jiffies;
Eric Dumazet634fb9792013-10-09 15:21:29 -07001635 const struct in6_addr *src = &inet_rsk(req)->ir_v6_loc_addr;
1636 const struct in6_addr *dest = &inet_rsk(req)->ir_v6_rmt_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637
1638 if (ttd < 0)
1639 ttd = 0;
1640
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641 seq_printf(seq,
1642 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Francesco Fuscod14c5ab2013-08-15 13:42:14 +02001643 "%02X %08X:%08X %02X:%08lX %08X %5u %8d %d %d %pK\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644 i,
1645 src->s6_addr32[0], src->s6_addr32[1],
1646 src->s6_addr32[2], src->s6_addr32[3],
Eric Dumazetb44084c2013-10-10 00:04:37 -07001647 inet_rsk(req)->ir_num,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648 dest->s6_addr32[0], dest->s6_addr32[1],
1649 dest->s6_addr32[2], dest->s6_addr32[3],
Eric Dumazet634fb9792013-10-09 15:21:29 -07001650 ntohs(inet_rsk(req)->ir_rmt_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 TCP_SYN_RECV,
Weilong Chen4c99aa42013-12-19 18:44:34 +08001652 0, 0, /* could print option size, but that is af dependent. */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001653 1, /* timers active (only the expire timer) */
1654 jiffies_to_clock_t(ttd),
Eric Dumazete6c022a2012-10-27 23:16:46 +00001655 req->num_timeout,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06001656 from_kuid_munged(seq_user_ns(seq), uid),
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001657 0, /* non standard timer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658 0, /* open_requests have no inode */
1659 0, req);
1660}
1661
1662static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i)
1663{
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001664 const struct in6_addr *dest, *src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665 __u16 destp, srcp;
1666 int timer_active;
1667 unsigned long timer_expires;
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001668 const struct inet_sock *inet = inet_sk(sp);
1669 const struct tcp_sock *tp = tcp_sk(sp);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001670 const struct inet_connection_sock *icsk = inet_csk(sp);
Yuchung Cheng0a672f72014-05-11 20:22:12 -07001671 struct fastopen_queue *fastopenq = icsk->icsk_accept_queue.fastopenq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672
Eric Dumazetefe42082013-10-03 15:42:29 -07001673 dest = &sp->sk_v6_daddr;
1674 src = &sp->sk_v6_rcv_saddr;
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001675 destp = ntohs(inet->inet_dport);
1676 srcp = ntohs(inet->inet_sport);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001677
1678 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679 timer_active = 1;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001680 timer_expires = icsk->icsk_timeout;
1681 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682 timer_active = 4;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001683 timer_expires = icsk->icsk_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684 } else if (timer_pending(&sp->sk_timer)) {
1685 timer_active = 2;
1686 timer_expires = sp->sk_timer.expires;
1687 } else {
1688 timer_active = 0;
1689 timer_expires = jiffies;
1690 }
1691
1692 seq_printf(seq,
1693 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Francesco Fuscod14c5ab2013-08-15 13:42:14 +02001694 "%02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %lu %lu %u %u %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 i,
1696 src->s6_addr32[0], src->s6_addr32[1],
1697 src->s6_addr32[2], src->s6_addr32[3], srcp,
1698 dest->s6_addr32[0], dest->s6_addr32[1],
1699 dest->s6_addr32[2], dest->s6_addr32[3], destp,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001700 sp->sk_state,
Sridhar Samudrala47da8ee2006-06-27 13:29:00 -07001701 tp->write_seq-tp->snd_una,
1702 (sp->sk_state == TCP_LISTEN) ? sp->sk_ack_backlog : (tp->rcv_nxt - tp->copied_seq),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703 timer_active,
Eric Dumazeta399a802012-08-08 21:13:53 +00001704 jiffies_delta_to_clock_t(timer_expires - jiffies),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001705 icsk->icsk_retransmits,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06001706 from_kuid_munged(seq_user_ns(seq), sock_i_uid(sp)),
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001707 icsk->icsk_probes_out,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001708 sock_i_ino(sp),
1709 atomic_read(&sp->sk_refcnt), sp,
Stephen Hemminger7be87352008-06-27 20:00:19 -07001710 jiffies_to_clock_t(icsk->icsk_rto),
1711 jiffies_to_clock_t(icsk->icsk_ack.ato),
Weilong Chen4c99aa42013-12-19 18:44:34 +08001712 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
Ilpo Järvinen0b6a05c2009-09-15 01:30:10 -07001713 tp->snd_cwnd,
Yuchung Cheng0a672f72014-05-11 20:22:12 -07001714 sp->sk_state == TCP_LISTEN ?
1715 (fastopenq ? fastopenq->max_qlen : 0) :
1716 (tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717 );
1718}
1719
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001720static void get_timewait6_sock(struct seq_file *seq,
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001721 struct inet_timewait_sock *tw, int i)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722{
Eric Dumazet789f5582015-04-12 18:51:09 -07001723 long delta = tw->tw_timer.expires - jiffies;
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001724 const struct in6_addr *dest, *src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725 __u16 destp, srcp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001726
Eric Dumazetefe42082013-10-03 15:42:29 -07001727 dest = &tw->tw_v6_daddr;
1728 src = &tw->tw_v6_rcv_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729 destp = ntohs(tw->tw_dport);
1730 srcp = ntohs(tw->tw_sport);
1731
1732 seq_printf(seq,
1733 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Dan Rosenberg71338aa2011-05-23 12:17:35 +00001734 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001735 i,
1736 src->s6_addr32[0], src->s6_addr32[1],
1737 src->s6_addr32[2], src->s6_addr32[3], srcp,
1738 dest->s6_addr32[0], dest->s6_addr32[1],
1739 dest->s6_addr32[2], dest->s6_addr32[3], destp,
1740 tw->tw_substate, 0, 0,
Eric Dumazeta399a802012-08-08 21:13:53 +00001741 3, jiffies_delta_to_clock_t(delta), 0, 0, 0, 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742 atomic_read(&tw->tw_refcnt), tw);
1743}
1744
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745static int tcp6_seq_show(struct seq_file *seq, void *v)
1746{
1747 struct tcp_iter_state *st;
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07001748 struct sock *sk = v;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749
1750 if (v == SEQ_START_TOKEN) {
1751 seq_puts(seq,
1752 " sl "
1753 "local_address "
1754 "remote_address "
1755 "st tx_queue rx_queue tr tm->when retrnsmt"
1756 " uid timeout inode\n");
1757 goto out;
1758 }
1759 st = seq->private;
1760
1761 switch (st->state) {
1762 case TCP_SEQ_STATE_LISTENING:
1763 case TCP_SEQ_STATE_ESTABLISHED:
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07001764 if (sk->sk_state == TCP_TIME_WAIT)
1765 get_timewait6_sock(seq, v, st->num);
1766 else
1767 get_tcp6_sock(seq, v, st->num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768 break;
1769 case TCP_SEQ_STATE_OPENREQ:
Eric Dumazetd4f06872015-03-12 16:44:09 -07001770 get_openreq6(seq, v, st->num, st->uid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772 }
1773out:
1774 return 0;
1775}
1776
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00001777static const struct file_operations tcp6_afinfo_seq_fops = {
1778 .owner = THIS_MODULE,
1779 .open = tcp_seq_open,
1780 .read = seq_read,
1781 .llseek = seq_lseek,
1782 .release = seq_release_net
1783};
1784
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785static struct tcp_seq_afinfo tcp6_seq_afinfo = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786 .name = "tcp6",
1787 .family = AF_INET6,
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00001788 .seq_fops = &tcp6_afinfo_seq_fops,
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07001789 .seq_ops = {
1790 .show = tcp6_seq_show,
1791 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792};
1793
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001794int __net_init tcp6_proc_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001795{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07001796 return tcp_proc_register(net, &tcp6_seq_afinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797}
1798
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07001799void tcp6_proc_exit(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001800{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07001801 tcp_proc_unregister(net, &tcp6_seq_afinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802}
1803#endif
1804
Eric Dumazetf77d6022013-05-09 10:28:16 +00001805static void tcp_v6_clear_sk(struct sock *sk, int size)
1806{
1807 struct inet_sock *inet = inet_sk(sk);
1808
1809 /* we do not want to clear pinet6 field, because of RCU lookups */
1810 sk_prot_clear_nulls(sk, offsetof(struct inet_sock, pinet6));
1811
1812 size -= offsetof(struct inet_sock, pinet6) + sizeof(inet->pinet6);
1813 memset(&inet->pinet6 + 1, 0, size);
1814}
1815
Linus Torvalds1da177e2005-04-16 15:20:36 -07001816struct proto tcpv6_prot = {
1817 .name = "TCPv6",
1818 .owner = THIS_MODULE,
1819 .close = tcp_close,
1820 .connect = tcp_v6_connect,
1821 .disconnect = tcp_disconnect,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001822 .accept = inet_csk_accept,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823 .ioctl = tcp_ioctl,
1824 .init = tcp_v6_init_sock,
1825 .destroy = tcp_v6_destroy_sock,
1826 .shutdown = tcp_shutdown,
1827 .setsockopt = tcp_setsockopt,
1828 .getsockopt = tcp_getsockopt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829 .recvmsg = tcp_recvmsg,
Changli Gao7ba42912010-07-10 20:41:55 +00001830 .sendmsg = tcp_sendmsg,
1831 .sendpage = tcp_sendpage,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832 .backlog_rcv = tcp_v6_do_rcv,
Eric Dumazet46d3cea2012-07-11 05:50:31 +00001833 .release_cb = tcp_release_cb,
Eric Dumazet77a6a472015-03-18 14:05:36 -07001834 .hash = inet_hash,
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001835 .unhash = inet_unhash,
1836 .get_port = inet_csk_get_port,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837 .enter_memory_pressure = tcp_enter_memory_pressure,
Eric Dumazetc9bee3b72013-07-22 20:27:07 -07001838 .stream_memory_free = tcp_stream_memory_free,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839 .sockets_allocated = &tcp_sockets_allocated,
1840 .memory_allocated = &tcp_memory_allocated,
1841 .memory_pressure = &tcp_memory_pressure,
Arnaldo Carvalho de Melo0a5578c2005-08-09 20:11:41 -07001842 .orphan_count = &tcp_orphan_count,
Eric W. Biedermana4fe34b2013-10-19 16:25:36 -07001843 .sysctl_mem = sysctl_tcp_mem,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844 .sysctl_wmem = sysctl_tcp_wmem,
1845 .sysctl_rmem = sysctl_tcp_rmem,
1846 .max_header = MAX_TCP_HEADER,
1847 .obj_size = sizeof(struct tcp6_sock),
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001848 .slab_flags = SLAB_DESTROY_BY_RCU,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08001849 .twsk_prot = &tcp6_timewait_sock_ops,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001850 .rsk_prot = &tcp6_request_sock_ops,
Pavel Emelyanov39d8cda2008-03-22 16:50:58 -07001851 .h.hashinfo = &tcp_hashinfo,
Changli Gao7ba42912010-07-10 20:41:55 +00001852 .no_autobind = true,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001853#ifdef CONFIG_COMPAT
1854 .compat_setsockopt = compat_tcp_setsockopt,
1855 .compat_getsockopt = compat_tcp_getsockopt,
1856#endif
Andrew Mortonc255a452012-07-31 16:43:02 -07001857#ifdef CONFIG_MEMCG_KMEM
Glauber Costad1a4c0b2011-12-11 21:47:04 +00001858 .proto_cgroup = tcp_proto_cgroup,
1859#endif
Eric Dumazetf77d6022013-05-09 10:28:16 +00001860 .clear_sk = tcp_v6_clear_sk,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861};
1862
Alexey Dobriyan41135cc2009-09-14 12:22:28 +00001863static const struct inet6_protocol tcpv6_protocol = {
Eric Dumazetc7109982012-07-26 12:18:11 +00001864 .early_demux = tcp_v6_early_demux,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865 .handler = tcp_v6_rcv,
1866 .err_handler = tcp_v6_err,
1867 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
1868};
1869
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870static struct inet_protosw tcpv6_protosw = {
1871 .type = SOCK_STREAM,
1872 .protocol = IPPROTO_TCP,
1873 .prot = &tcpv6_prot,
1874 .ops = &inet6_stream_ops,
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001875 .flags = INET_PROTOSW_PERMANENT |
1876 INET_PROTOSW_ICSK,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877};
1878
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001879static int __net_init tcpv6_net_init(struct net *net)
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001880{
Denis V. Lunev56772422008-04-03 14:28:30 -07001881 return inet_ctl_sock_create(&net->ipv6.tcp_sk, PF_INET6,
1882 SOCK_RAW, IPPROTO_TCP, net);
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001883}
1884
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001885static void __net_exit tcpv6_net_exit(struct net *net)
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001886{
Denis V. Lunev56772422008-04-03 14:28:30 -07001887 inet_ctl_sock_destroy(net->ipv6.tcp_sk);
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00001888}
1889
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001890static void __net_exit tcpv6_net_exit_batch(struct list_head *net_exit_list)
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00001891{
1892 inet_twsk_purge(&tcp_hashinfo, &tcp_death_row, AF_INET6);
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001893}
1894
1895static struct pernet_operations tcpv6_net_ops = {
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00001896 .init = tcpv6_net_init,
1897 .exit = tcpv6_net_exit,
1898 .exit_batch = tcpv6_net_exit_batch,
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001899};
1900
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001901int __init tcpv6_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902{
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001903 int ret;
David Woodhouseae0f7d52006-01-11 15:53:04 -08001904
Vlad Yasevich33362882012-11-15 08:49:15 +00001905 ret = inet6_add_protocol(&tcpv6_protocol, IPPROTO_TCP);
1906 if (ret)
Vlad Yasevichc6b641a2012-11-15 08:49:22 +00001907 goto out;
Vlad Yasevich33362882012-11-15 08:49:15 +00001908
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001909 /* register inet6 protocol */
1910 ret = inet6_register_protosw(&tcpv6_protosw);
1911 if (ret)
1912 goto out_tcpv6_protocol;
1913
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001914 ret = register_pernet_subsys(&tcpv6_net_ops);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001915 if (ret)
1916 goto out_tcpv6_protosw;
1917out:
1918 return ret;
1919
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001920out_tcpv6_protosw:
1921 inet6_unregister_protosw(&tcpv6_protosw);
Vlad Yasevich33362882012-11-15 08:49:15 +00001922out_tcpv6_protocol:
1923 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001924 goto out;
1925}
1926
Daniel Lezcano09f77092007-12-13 05:34:58 -08001927void tcpv6_exit(void)
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001928{
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001929 unregister_pernet_subsys(&tcpv6_net_ops);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001930 inet6_unregister_protosw(&tcpv6_protosw);
1931 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001932}