blob: 9400b4326f22346b2edfbebfb8824f5324b3e4f3 [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>
Jeff Garzik18134be2007-10-26 22:53:14 -070062#include <net/netdma.h>
Denis V. Lunev3d58b5f2008-04-03 14:22:32 -070063#include <net/inet_common.h>
David S. Miller6e5714e2011-08-03 20:50:44 -070064#include <net/secure_seq.h>
Glauber Costad1a4c0b2011-12-11 21:47:04 +000065#include <net/tcp_memcontrol.h>
Eliezer Tamir076bb0c2013-07-10 17:13:17 +030066#include <net/busy_poll.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
Linus Torvalds1da177e2005-04-16 15:20:36 -070068#include <linux/proc_fs.h>
69#include <linux/seq_file.h>
70
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080071#include <linux/crypto.h>
72#include <linux/scatterlist.h>
73
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080074static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb);
Gui Jianfeng6edafaa2008-08-06 23:50:04 -070075static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
76 struct request_sock *req);
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
78static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
Stephen Hemminger3b401a82009-09-01 19:25:04 +000080static const struct inet_connection_sock_af_ops ipv6_mapped;
81static const struct inet_connection_sock_af_ops ipv6_specific;
David S. Millera9286302006-11-14 19:53:22 -080082#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +000083static const struct tcp_sock_af_ops tcp_sock_ipv6_specific;
84static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific;
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +090085#else
86static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
Eric Dumazetb71d1d42011-04-22 04:53:02 +000087 const struct in6_addr *addr)
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +090088{
89 return NULL;
90}
David S. Millera9286302006-11-14 19:53:22 -080091#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070092
Neal Cardwellfae6ef82012-08-19 03:30:38 +000093static void inet6_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb)
94{
95 struct dst_entry *dst = skb_dst(skb);
Neal Cardwellfae6ef82012-08-19 03:30:38 +000096
Eric Dumazetca777ef2014-09-08 08:06:07 -070097 if (dst) {
98 const struct rt6_info *rt = (const struct rt6_info *)dst;
99
100 dst_hold(dst);
101 sk->sk_rx_dst = dst;
102 inet_sk(sk)->rx_dst_ifindex = skb->skb_iif;
103 if (rt->rt6i_node)
104 inet6_sk(sk)->rx_dst_cookie = rt->rt6i_node->fn_sernum;
105 }
Neal Cardwellfae6ef82012-08-19 03:30:38 +0000106}
107
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108static void tcp_v6_hash(struct sock *sk)
109{
110 if (sk->sk_state != TCP_CLOSE) {
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -0800111 if (inet_csk(sk)->icsk_af_ops == &ipv6_mapped) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 tcp_prot.hash(sk);
113 return;
114 }
115 local_bh_disable();
Eric Dumazet9327f702009-12-04 03:46:54 +0000116 __inet6_hash(sk, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 local_bh_enable();
118 }
119}
120
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400121static __u32 tcp_v6_init_sequence(const struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122{
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700123 return secure_tcpv6_sequence_number(ipv6_hdr(skb)->daddr.s6_addr32,
124 ipv6_hdr(skb)->saddr.s6_addr32,
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700125 tcp_hdr(skb)->dest,
126 tcp_hdr(skb)->source);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127}
128
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900129static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 int addr_len)
131{
132 struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900133 struct inet_sock *inet = inet_sk(sk);
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800134 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 struct ipv6_pinfo *np = inet6_sk(sk);
136 struct tcp_sock *tp = tcp_sk(sk);
Arnaud Ebalard20c59de2010-06-01 21:35:01 +0000137 struct in6_addr *saddr = NULL, *final_p, final;
David S. Miller493f3772010-12-02 12:14:29 -0800138 struct rt6_info *rt;
David S. Miller4c9483b2011-03-12 16:22:43 -0500139 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 struct dst_entry *dst;
141 int addr_type;
142 int err;
143
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900144 if (addr_len < SIN6_LEN_RFC2133)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 return -EINVAL;
146
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900147 if (usin->sin6_family != AF_INET6)
Eric Dumazeta02cec22010-09-22 20:43:57 +0000148 return -EAFNOSUPPORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149
David S. Miller4c9483b2011-03-12 16:22:43 -0500150 memset(&fl6, 0, sizeof(fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151
152 if (np->sndflow) {
David S. Miller4c9483b2011-03-12 16:22:43 -0500153 fl6.flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK;
154 IP6_ECN_flow_init(fl6.flowlabel);
155 if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 struct ip6_flowlabel *flowlabel;
David S. Miller4c9483b2011-03-12 16:22:43 -0500157 flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 if (flowlabel == NULL)
159 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 fl6_sock_release(flowlabel);
161 }
162 }
163
164 /*
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900165 * connect() to INADDR_ANY means loopback (BSD'ism).
166 */
167
Weilong Chen4c99aa42013-12-19 18:44:34 +0800168 if (ipv6_addr_any(&usin->sin6_addr))
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900169 usin->sin6_addr.s6_addr[15] = 0x1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170
171 addr_type = ipv6_addr_type(&usin->sin6_addr);
172
Weilong Chen4c99aa42013-12-19 18:44:34 +0800173 if (addr_type & IPV6_ADDR_MULTICAST)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 return -ENETUNREACH;
175
176 if (addr_type&IPV6_ADDR_LINKLOCAL) {
177 if (addr_len >= sizeof(struct sockaddr_in6) &&
178 usin->sin6_scope_id) {
179 /* If interface is set while binding, indices
180 * must coincide.
181 */
182 if (sk->sk_bound_dev_if &&
183 sk->sk_bound_dev_if != usin->sin6_scope_id)
184 return -EINVAL;
185
186 sk->sk_bound_dev_if = usin->sin6_scope_id;
187 }
188
189 /* Connect to link-local address requires an interface */
190 if (!sk->sk_bound_dev_if)
191 return -EINVAL;
192 }
193
194 if (tp->rx_opt.ts_recent_stamp &&
Eric Dumazetefe42082013-10-03 15:42:29 -0700195 !ipv6_addr_equal(&sk->sk_v6_daddr, &usin->sin6_addr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 tp->rx_opt.ts_recent = 0;
197 tp->rx_opt.ts_recent_stamp = 0;
198 tp->write_seq = 0;
199 }
200
Eric Dumazetefe42082013-10-03 15:42:29 -0700201 sk->sk_v6_daddr = usin->sin6_addr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500202 np->flow_label = fl6.flowlabel;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203
Tom Herbertb73c3d02014-07-01 21:32:17 -0700204 ip6_set_txhash(sk);
205
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 /*
207 * TCP over IPv4
208 */
209
210 if (addr_type == IPV6_ADDR_MAPPED) {
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800211 u32 exthdrlen = icsk->icsk_ext_hdr_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 struct sockaddr_in sin;
213
214 SOCK_DEBUG(sk, "connect: ipv4 mapped\n");
215
216 if (__ipv6_only_sock(sk))
217 return -ENETUNREACH;
218
219 sin.sin_family = AF_INET;
220 sin.sin_port = usin->sin6_port;
221 sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
222
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800223 icsk->icsk_af_ops = &ipv6_mapped;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 sk->sk_backlog_rcv = tcp_v4_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800225#ifdef CONFIG_TCP_MD5SIG
226 tp->af_specific = &tcp_sock_ipv6_mapped_specific;
227#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228
229 err = tcp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
230
231 if (err) {
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800232 icsk->icsk_ext_hdr_len = exthdrlen;
233 icsk->icsk_af_ops = &ipv6_specific;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 sk->sk_backlog_rcv = tcp_v6_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800235#ifdef CONFIG_TCP_MD5SIG
236 tp->af_specific = &tcp_sock_ipv6_specific;
237#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 goto failure;
239 } else {
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000240 ipv6_addr_set_v4mapped(inet->inet_saddr, &np->saddr);
241 ipv6_addr_set_v4mapped(inet->inet_rcv_saddr,
Eric Dumazetefe42082013-10-03 15:42:29 -0700242 &sk->sk_v6_rcv_saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 }
244
245 return err;
246 }
247
Eric Dumazetefe42082013-10-03 15:42:29 -0700248 if (!ipv6_addr_any(&sk->sk_v6_rcv_saddr))
249 saddr = &sk->sk_v6_rcv_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250
David S. Miller4c9483b2011-03-12 16:22:43 -0500251 fl6.flowi6_proto = IPPROTO_TCP;
Eric Dumazetefe42082013-10-03 15:42:29 -0700252 fl6.daddr = sk->sk_v6_daddr;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000253 fl6.saddr = saddr ? *saddr : np->saddr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500254 fl6.flowi6_oif = sk->sk_bound_dev_if;
255 fl6.flowi6_mark = sk->sk_mark;
David S. Miller1958b852011-03-12 16:36:19 -0500256 fl6.fl6_dport = usin->sin6_port;
257 fl6.fl6_sport = inet->inet_sport;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258
David S. Miller4c9483b2011-03-12 16:22:43 -0500259 final_p = fl6_update_dst(&fl6, np->opt, &final);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260
David S. Miller4c9483b2011-03-12 16:22:43 -0500261 security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -0700262
Steffen Klassert0e0d44a2013-08-28 08:04:14 +0200263 dst = ip6_dst_lookup_flow(sk, &fl6, final_p);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800264 if (IS_ERR(dst)) {
265 err = PTR_ERR(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 goto failure;
David S. Miller14e50e52007-05-24 18:17:54 -0700267 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268
269 if (saddr == NULL) {
David S. Miller4c9483b2011-03-12 16:22:43 -0500270 saddr = &fl6.saddr;
Eric Dumazetefe42082013-10-03 15:42:29 -0700271 sk->sk_v6_rcv_saddr = *saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 }
273
274 /* set the source address */
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000275 np->saddr = *saddr;
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000276 inet->inet_rcv_saddr = LOOPBACK4_IPV6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277
Herbert Xuf83ef8c2006-06-30 13:37:03 -0700278 sk->sk_gso_type = SKB_GSO_TCPV6;
YOSHIFUJI Hideaki8e1ef0a2006-08-29 17:15:09 -0700279 __ip6_dst_store(sk, dst, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280
David S. Miller493f3772010-12-02 12:14:29 -0800281 rt = (struct rt6_info *) dst;
282 if (tcp_death_row.sysctl_tw_recycle &&
283 !tp->rx_opt.ts_recent_stamp &&
Eric Dumazetefe42082013-10-03 15:42:29 -0700284 ipv6_addr_equal(&rt->rt6i_dst.addr, &sk->sk_v6_daddr))
David S. Miller81166dd2012-07-10 03:14:24 -0700285 tcp_fetch_timewait_stamp(sk, dst);
David S. Miller493f3772010-12-02 12:14:29 -0800286
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800287 icsk->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 if (np->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800289 icsk->icsk_ext_hdr_len = (np->opt->opt_flen +
290 np->opt->opt_nflen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291
292 tp->rx_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
293
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000294 inet->inet_dport = usin->sin6_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295
296 tcp_set_state(sk, TCP_SYN_SENT);
Arnaldo Carvalho de Melod8313f52005-12-13 23:25:44 -0800297 err = inet6_hash_connect(&tcp_death_row, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 if (err)
299 goto late_failure;
300
Andrey Vagin2b916472012-11-22 01:13:58 +0000301 if (!tp->write_seq && likely(!tp->repair))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 tp->write_seq = secure_tcpv6_sequence_number(np->saddr.s6_addr32,
Eric Dumazetefe42082013-10-03 15:42:29 -0700303 sk->sk_v6_daddr.s6_addr32,
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000304 inet->inet_sport,
305 inet->inet_dport);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306
307 err = tcp_connect(sk);
308 if (err)
309 goto late_failure;
310
311 return 0;
312
313late_failure:
314 tcp_set_state(sk, TCP_CLOSE);
315 __sk_dst_reset(sk);
316failure:
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000317 inet->inet_dport = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 sk->sk_route_caps = 0;
319 return err;
320}
321
Eric Dumazet563d34d2012-07-23 09:48:52 +0200322static void tcp_v6_mtu_reduced(struct sock *sk)
323{
324 struct dst_entry *dst;
325
326 if ((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE))
327 return;
328
329 dst = inet6_csk_update_pmtu(sk, tcp_sk(sk)->mtu_info);
330 if (!dst)
331 return;
332
333 if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst)) {
334 tcp_sync_mss(sk, dst_mtu(dst));
335 tcp_simple_retransmit(sk);
336 }
337}
338
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700340 u8 type, u8 code, int offset, __be32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341{
Weilong Chen4c99aa42013-12-19 18:44:34 +0800342 const struct ipv6hdr *hdr = (const struct ipv6hdr *)skb->data;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -0300343 const struct tcphdr *th = (struct tcphdr *)(skb->data+offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 struct ipv6_pinfo *np;
345 struct sock *sk;
346 int err;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900347 struct tcp_sock *tp;
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700348 struct request_sock *fastopen;
349 __u32 seq, snd_una;
Pavel Emelyanovca12a1a2008-07-16 20:28:42 -0700350 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351
Pavel Emelyanovca12a1a2008-07-16 20:28:42 -0700352 sk = inet6_lookup(net, &tcp_hashinfo, &hdr->daddr,
Pavel Emelyanovd86e0da2008-01-31 05:07:21 -0800353 th->dest, &hdr->saddr, th->source, skb->dev->ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354
355 if (sk == NULL) {
Denis V. Luneve41b5362008-10-08 10:33:26 -0700356 ICMP6_INC_STATS_BH(net, __in6_dev_get(skb->dev),
357 ICMP6_MIB_INERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 return;
359 }
360
361 if (sk->sk_state == TCP_TIME_WAIT) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -0700362 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 return;
364 }
365
366 bh_lock_sock(sk);
Eric Dumazet563d34d2012-07-23 09:48:52 +0200367 if (sock_owned_by_user(sk) && type != ICMPV6_PKT_TOOBIG)
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700368 NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369
370 if (sk->sk_state == TCP_CLOSE)
371 goto out;
372
Stephen Hemmingere802af92010-04-22 15:24:53 -0700373 if (ipv6_hdr(skb)->hop_limit < inet6_sk(sk)->min_hopcount) {
374 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
375 goto out;
376 }
377
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 tp = tcp_sk(sk);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900379 seq = ntohl(th->seq);
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700380 /* XXX (TFO) - tp->snd_una should be ISN (tcp_create_openreq_child() */
381 fastopen = tp->fastopen_rsk;
382 snd_una = fastopen ? tcp_rsk(fastopen)->snt_isn : tp->snd_una;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 if (sk->sk_state != TCP_LISTEN &&
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700384 !between(seq, snd_una, tp->snd_nxt)) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700385 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 goto out;
387 }
388
389 np = inet6_sk(sk);
390
David S. Millerec18d9a2012-07-12 00:25:15 -0700391 if (type == NDISC_REDIRECT) {
392 struct dst_entry *dst = __sk_dst_check(sk, np->dst_cookie);
393
David S. Miller1ed5c482012-07-12 00:41:25 -0700394 if (dst)
David S. Miller6700c272012-07-17 03:29:28 -0700395 dst->ops->redirect(dst, sk, skb);
Christoph Paasch50a75a82013-04-07 04:53:15 +0000396 goto out;
David S. Millerec18d9a2012-07-12 00:25:15 -0700397 }
398
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 if (type == ICMPV6_PKT_TOOBIG) {
Eric Dumazet0d4f0602013-03-18 07:01:28 +0000400 /* We are not interested in TCP_LISTEN and open_requests
401 * (SYN-ACKs send out by Linux are always <576bytes so
402 * they should go through unfragmented).
403 */
404 if (sk->sk_state == TCP_LISTEN)
405 goto out;
406
Hannes Frederic Sowa93b36cf2013-12-15 03:41:14 +0100407 if (!ip6_sk_accept_pmtu(sk))
408 goto out;
409
Eric Dumazet563d34d2012-07-23 09:48:52 +0200410 tp->mtu_info = ntohl(info);
411 if (!sock_owned_by_user(sk))
412 tcp_v6_mtu_reduced(sk);
Julian Anastasovd013ef2a2012-09-05 10:53:18 +0000413 else if (!test_and_set_bit(TCP_MTU_REDUCED_DEFERRED,
414 &tp->tsq_flags))
415 sock_hold(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 goto out;
417 }
418
419 icmpv6_err_convert(type, code, &err);
420
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700421 /* Might be for an request_sock */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 switch (sk->sk_state) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700423 struct request_sock *req, **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 case TCP_LISTEN:
425 if (sock_owned_by_user(sk))
426 goto out;
427
Arnaldo Carvalho de Melo81297652005-12-13 23:15:24 -0800428 req = inet6_csk_search_req(sk, &prev, th->dest, &hdr->daddr,
429 &hdr->saddr, inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 if (!req)
431 goto out;
432
433 /* ICMPs are not backlogged, hence we cannot get
434 * an established socket here.
435 */
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700436 WARN_ON(req->sk != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700438 if (seq != tcp_rsk(req)->snt_isn) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700439 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 goto out;
441 }
442
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700443 inet_csk_reqsk_queue_drop(sk, req, prev);
Vijay Subramanian5f1e9422013-01-31 08:24:19 +0000444 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 goto out;
446
447 case TCP_SYN_SENT:
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700448 case TCP_SYN_RECV:
449 /* Only in fast or simultaneous open. If a fast open socket is
450 * is already accepted it is treated as a connected one below.
451 */
452 if (fastopen && fastopen->sk == NULL)
453 break;
454
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 if (!sock_owned_by_user(sk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 sk->sk_err = err;
457 sk->sk_error_report(sk); /* Wake people up to see the error (see connect in sock.c) */
458
459 tcp_done(sk);
460 } else
461 sk->sk_err_soft = err;
462 goto out;
463 }
464
465 if (!sock_owned_by_user(sk) && np->recverr) {
466 sk->sk_err = err;
467 sk->sk_error_report(sk);
468 } else
469 sk->sk_err_soft = err;
470
471out:
472 bh_unlock_sock(sk);
473 sock_put(sk);
474}
475
476
Neal Cardwell9f10d3f2012-06-28 12:34:21 +0000477static int tcp_v6_send_synack(struct sock *sk, struct dst_entry *dst,
Octavian Purdilad6274bd2014-06-25 17:09:58 +0300478 struct flowi *fl,
Neal Cardwell3840a062012-06-28 12:34:19 +0000479 struct request_sock *req,
Daniel Lee3a19ce02014-05-11 20:22:13 -0700480 u16 queue_mapping,
481 struct tcp_fastopen_cookie *foc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482{
Eric Dumazet634fb9792013-10-09 15:21:29 -0700483 struct inet_request_sock *ireq = inet_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 struct ipv6_pinfo *np = inet6_sk(sk);
Octavian Purdilad6274bd2014-06-25 17:09:58 +0300485 struct flowi6 *fl6 = &fl->u.ip6;
Weilong Chen4c99aa42013-12-19 18:44:34 +0800486 struct sk_buff *skb;
Neal Cardwell94942182012-06-28 12:34:20 +0000487 int err = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488
Neal Cardwell9f10d3f2012-06-28 12:34:21 +0000489 /* First, grab a route. */
490 if (!dst && (dst = inet6_csk_route_req(sk, fl6, req)) == NULL)
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800491 goto done;
Neal Cardwell94942182012-06-28 12:34:20 +0000492
Daniel Lee3a19ce02014-05-11 20:22:13 -0700493 skb = tcp_make_synack(sk, dst, req, foc);
Neal Cardwell94942182012-06-28 12:34:20 +0000494
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 if (skb) {
Eric Dumazet634fb9792013-10-09 15:21:29 -0700496 __tcp_v6_send_check(skb, &ireq->ir_v6_loc_addr,
497 &ireq->ir_v6_rmt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498
Eric Dumazet634fb9792013-10-09 15:21:29 -0700499 fl6->daddr = ireq->ir_v6_rmt_addr;
Florent Fourcotdf3687f2014-01-17 17:15:03 +0100500 if (np->repflow && (ireq->pktopts != NULL))
501 fl6->flowlabel = ip6_flowlabel(ipv6_hdr(ireq->pktopts));
502
Eric Dumazetfff32692012-06-01 01:47:50 +0000503 skb_set_queue_mapping(skb, queue_mapping);
RongQing.Li43264e02012-07-01 17:18:59 +0000504 err = ip6_xmit(sk, skb, fl6, np->opt, np->tclass);
Gerrit Renkerb9df3cb2006-11-14 11:21:36 -0200505 err = net_xmit_eval(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 }
507
508done:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 return err;
510}
511
Octavian Purdila72659ec2010-01-17 19:09:39 -0800512
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700513static void tcp_v6_reqsk_destructor(struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514{
Eric Dumazet634fb9792013-10-09 15:21:29 -0700515 kfree_skb(inet_rsk(req)->pktopts);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516}
517
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800518#ifdef CONFIG_TCP_MD5SIG
519static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000520 const struct in6_addr *addr)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800521{
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000522 return tcp_md5_do_lookup(sk, (union tcp_md5_addr *)addr, AF_INET6);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800523}
524
525static struct tcp_md5sig_key *tcp_v6_md5_lookup(struct sock *sk,
526 struct sock *addr_sk)
527{
Eric Dumazetefe42082013-10-03 15:42:29 -0700528 return tcp_v6_md5_do_lookup(sk, &addr_sk->sk_v6_daddr);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800529}
530
531static struct tcp_md5sig_key *tcp_v6_reqsk_md5_lookup(struct sock *sk,
532 struct request_sock *req)
533{
Eric Dumazet634fb9792013-10-09 15:21:29 -0700534 return tcp_v6_md5_do_lookup(sk, &inet_rsk(req)->ir_v6_rmt_addr);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800535}
536
Wang Yufen4aa956d2014-03-29 09:27:29 +0800537static int tcp_v6_parse_md5_keys(struct sock *sk, char __user *optval,
538 int optlen)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800539{
540 struct tcp_md5sig cmd;
541 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&cmd.tcpm_addr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800542
543 if (optlen < sizeof(cmd))
544 return -EINVAL;
545
546 if (copy_from_user(&cmd, optval, sizeof(cmd)))
547 return -EFAULT;
548
549 if (sin6->sin6_family != AF_INET6)
550 return -EINVAL;
551
552 if (!cmd.tcpm_keylen) {
Brian Haleye773e4f2007-08-24 23:16:08 -0700553 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000554 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3],
555 AF_INET);
556 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr,
557 AF_INET6);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800558 }
559
560 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
561 return -EINVAL;
562
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000563 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
564 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3],
565 AF_INET, cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800566
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000567 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr,
568 AF_INET6, cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800569}
570
Adam Langley49a72df2008-07-19 00:01:42 -0700571static int tcp_v6_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000572 const struct in6_addr *daddr,
573 const struct in6_addr *saddr, int nbytes)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800574{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800575 struct tcp6_pseudohdr *bp;
Adam Langley49a72df2008-07-19 00:01:42 -0700576 struct scatterlist sg;
YOSHIFUJI Hideaki8d26d762008-04-17 13:19:16 +0900577
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800578 bp = &hp->md5_blk.ip6;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800579 /* 1. TCP pseudo-header (RFC2460) */
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000580 bp->saddr = *saddr;
581 bp->daddr = *daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700582 bp->protocol = cpu_to_be32(IPPROTO_TCP);
Adam Langley00b13042008-07-31 21:36:07 -0700583 bp->len = cpu_to_be32(nbytes);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800584
Adam Langley49a72df2008-07-19 00:01:42 -0700585 sg_init_one(&sg, bp, sizeof(*bp));
586 return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
587}
David S. Millerc7da57a2007-10-26 00:41:21 -0700588
Adam Langley49a72df2008-07-19 00:01:42 -0700589static int tcp_v6_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key,
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000590 const struct in6_addr *daddr, struct in6_addr *saddr,
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400591 const struct tcphdr *th)
Adam Langley49a72df2008-07-19 00:01:42 -0700592{
593 struct tcp_md5sig_pool *hp;
594 struct hash_desc *desc;
595
596 hp = tcp_get_md5sig_pool();
597 if (!hp)
598 goto clear_hash_noput;
599 desc = &hp->md5_desc;
600
601 if (crypto_hash_init(desc))
602 goto clear_hash;
603 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
604 goto clear_hash;
605 if (tcp_md5_hash_header(hp, th))
606 goto clear_hash;
607 if (tcp_md5_hash_key(hp, key))
608 goto clear_hash;
609 if (crypto_hash_final(desc, md5_hash))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800610 goto clear_hash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800611
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800612 tcp_put_md5sig_pool();
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800613 return 0;
Adam Langley49a72df2008-07-19 00:01:42 -0700614
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800615clear_hash:
616 tcp_put_md5sig_pool();
617clear_hash_noput:
618 memset(md5_hash, 0, 16);
Adam Langley49a72df2008-07-19 00:01:42 -0700619 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800620}
621
Adam Langley49a72df2008-07-19 00:01:42 -0700622static int tcp_v6_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400623 const struct sock *sk,
624 const struct request_sock *req,
625 const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800626{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000627 const struct in6_addr *saddr, *daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700628 struct tcp_md5sig_pool *hp;
629 struct hash_desc *desc;
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400630 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800631
632 if (sk) {
633 saddr = &inet6_sk(sk)->saddr;
Eric Dumazetefe42082013-10-03 15:42:29 -0700634 daddr = &sk->sk_v6_daddr;
Adam Langley49a72df2008-07-19 00:01:42 -0700635 } else if (req) {
Eric Dumazet634fb9792013-10-09 15:21:29 -0700636 saddr = &inet_rsk(req)->ir_v6_loc_addr;
637 daddr = &inet_rsk(req)->ir_v6_rmt_addr;
Adam Langley49a72df2008-07-19 00:01:42 -0700638 } else {
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000639 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
Adam Langley49a72df2008-07-19 00:01:42 -0700640 saddr = &ip6h->saddr;
641 daddr = &ip6h->daddr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800642 }
Adam Langley49a72df2008-07-19 00:01:42 -0700643
644 hp = tcp_get_md5sig_pool();
645 if (!hp)
646 goto clear_hash_noput;
647 desc = &hp->md5_desc;
648
649 if (crypto_hash_init(desc))
650 goto clear_hash;
651
652 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
653 goto clear_hash;
654 if (tcp_md5_hash_header(hp, th))
655 goto clear_hash;
656 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
657 goto clear_hash;
658 if (tcp_md5_hash_key(hp, key))
659 goto clear_hash;
660 if (crypto_hash_final(desc, md5_hash))
661 goto clear_hash;
662
663 tcp_put_md5sig_pool();
664 return 0;
665
666clear_hash:
667 tcp_put_md5sig_pool();
668clear_hash_noput:
669 memset(md5_hash, 0, 16);
670 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800671}
672
Dmitry Popov9ea88a12014-08-07 02:38:22 +0400673static int __tcp_v6_inbound_md5_hash(struct sock *sk,
674 const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800675{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400676 const __u8 *hash_location = NULL;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800677 struct tcp_md5sig_key *hash_expected;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000678 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
Eric Dumazet318cf7a2011-10-24 02:46:04 -0400679 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800680 int genhash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800681 u8 newhash[16];
682
683 hash_expected = tcp_v6_md5_do_lookup(sk, &ip6h->saddr);
YOSHIFUJI Hideaki7d5d5522008-04-17 12:29:53 +0900684 hash_location = tcp_parse_md5sig_option(th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800685
David S. Miller785957d2008-07-30 03:03:15 -0700686 /* We've parsed the options - do we have a hash? */
687 if (!hash_expected && !hash_location)
688 return 0;
689
690 if (hash_expected && !hash_location) {
691 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800692 return 1;
693 }
694
David S. Miller785957d2008-07-30 03:03:15 -0700695 if (!hash_expected && hash_location) {
696 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800697 return 1;
698 }
699
700 /* check the signature */
Adam Langley49a72df2008-07-19 00:01:42 -0700701 genhash = tcp_v6_md5_hash_skb(newhash,
702 hash_expected,
703 NULL, NULL, skb);
704
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800705 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
Joe Perchese87cc472012-05-13 21:56:26 +0000706 net_info_ratelimited("MD5 Hash %s for [%pI6c]:%u->[%pI6c]:%u\n",
707 genhash ? "failed" : "mismatch",
708 &ip6h->saddr, ntohs(th->source),
709 &ip6h->daddr, ntohs(th->dest));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800710 return 1;
711 }
712 return 0;
713}
Dmitry Popov9ea88a12014-08-07 02:38:22 +0400714
715static int tcp_v6_inbound_md5_hash(struct sock *sk, const struct sk_buff *skb)
716{
717 int ret;
718
719 rcu_read_lock();
720 ret = __tcp_v6_inbound_md5_hash(sk, skb);
721 rcu_read_unlock();
722
723 return ret;
724}
725
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800726#endif
727
Octavian Purdila16bea702014-06-25 17:09:53 +0300728static void tcp_v6_init_req(struct request_sock *req, struct sock *sk,
729 struct sk_buff *skb)
730{
731 struct inet_request_sock *ireq = inet_rsk(req);
732 struct ipv6_pinfo *np = inet6_sk(sk);
733
734 ireq->ir_v6_rmt_addr = ipv6_hdr(skb)->saddr;
735 ireq->ir_v6_loc_addr = ipv6_hdr(skb)->daddr;
736
737 ireq->ir_iif = sk->sk_bound_dev_if;
738
739 /* So that link locals have meaning */
740 if (!sk->sk_bound_dev_if &&
741 ipv6_addr_type(&ireq->ir_v6_rmt_addr) & IPV6_ADDR_LINKLOCAL)
742 ireq->ir_iif = inet6_iif(skb);
743
Eric Dumazet04317da2014-09-05 15:33:32 -0700744 if (!TCP_SKB_CB(skb)->tcp_tw_isn &&
Eric Dumazeta2247722014-09-27 09:50:56 -0700745 (ipv6_opt_accepted(sk, skb, &TCP_SKB_CB(skb)->header.h6) ||
746 np->rxopt.bits.rxinfo ||
Octavian Purdila16bea702014-06-25 17:09:53 +0300747 np->rxopt.bits.rxoinfo || np->rxopt.bits.rxhlim ||
748 np->rxopt.bits.rxohlim || np->repflow)) {
749 atomic_inc(&skb->users);
750 ireq->pktopts = skb;
751 }
752}
753
Octavian Purdilad94e0412014-06-25 17:09:55 +0300754static struct dst_entry *tcp_v6_route_req(struct sock *sk, struct flowi *fl,
755 const struct request_sock *req,
756 bool *strict)
757{
758 if (strict)
759 *strict = true;
760 return inet6_csk_route_req(sk, &fl->u.ip6, req);
761}
762
Glenn Griffinc6aefaf2008-02-07 21:49:26 -0800763struct request_sock_ops tcp6_request_sock_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 .family = AF_INET6,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700765 .obj_size = sizeof(struct tcp6_request_sock),
Octavian Purdila5db92c92014-06-25 17:09:59 +0300766 .rtx_syn_ack = tcp_rtx_synack,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700767 .send_ack = tcp_v6_reqsk_send_ack,
768 .destructor = tcp_v6_reqsk_destructor,
Octavian Purdila72659ec2010-01-17 19:09:39 -0800769 .send_reset = tcp_v6_send_reset,
Wang Yufen4aa956d2014-03-29 09:27:29 +0800770 .syn_ack_timeout = tcp_syn_ack_timeout,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771};
772
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +0000773static const struct tcp_request_sock_ops tcp_request_sock_ipv6_ops = {
Octavian Purdila2aec4a22014-06-25 17:10:00 +0300774 .mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) -
775 sizeof(struct ipv6hdr),
Octavian Purdila16bea702014-06-25 17:09:53 +0300776#ifdef CONFIG_TCP_MD5SIG
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800777 .md5_lookup = tcp_v6_reqsk_md5_lookup,
John Dykstrae3afe7b2009-07-16 05:04:51 +0000778 .calc_md5_hash = tcp_v6_md5_hash_skb,
Andrew Mortonb6332e62006-11-30 19:16:28 -0800779#endif
Octavian Purdila16bea702014-06-25 17:09:53 +0300780 .init_req = tcp_v6_init_req,
Octavian Purdilafb7b37a2014-06-25 17:09:54 +0300781#ifdef CONFIG_SYN_COOKIES
782 .cookie_init_seq = cookie_v6_init_sequence,
783#endif
Octavian Purdilad94e0412014-06-25 17:09:55 +0300784 .route_req = tcp_v6_route_req,
Octavian Purdila936b8bd2014-06-25 17:09:57 +0300785 .init_seq = tcp_v6_init_sequence,
Octavian Purdilad6274bd2014-06-25 17:09:58 +0300786 .send_synack = tcp_v6_send_synack,
Octavian Purdila695da142014-06-25 17:10:01 +0300787 .queue_hash_add = inet6_csk_reqsk_queue_hash_add,
Octavian Purdila16bea702014-06-25 17:09:53 +0300788};
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800789
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700790static void tcp_v6_send_response(struct sk_buff *skb, u32 seq, u32 ack, u32 win,
Wang Yufen9c76a112014-03-29 09:27:31 +0800791 u32 tsval, u32 tsecr, int oif,
Florent Fourcot1d13a962014-01-16 17:21:22 +0100792 struct tcp_md5sig_key *key, int rst, u8 tclass,
793 u32 label)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400795 const struct tcphdr *th = tcp_hdr(skb);
796 struct tcphdr *t1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 struct sk_buff *buff;
David S. Miller4c9483b2011-03-12 16:22:43 -0500798 struct flowi6 fl6;
Eric Dumazetadf30902009-06-02 05:19:30 +0000799 struct net *net = dev_net(skb_dst(skb)->dev);
Daniel Lezcanoe5047992008-03-07 11:16:26 -0800800 struct sock *ctl_sk = net->ipv6.tcp_sk;
YOSHIFUJI Hideaki9cb57342008-01-12 02:16:03 -0800801 unsigned int tot_len = sizeof(struct tcphdr);
Eric Dumazetadf30902009-06-02 05:19:30 +0000802 struct dst_entry *dst;
Al Viroe69a4adc2006-11-14 20:56:00 -0800803 __be32 *topt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804
Andrey Vaginee684b62013-02-11 05:50:19 +0000805 if (tsecr)
YOSHIFUJI Hideaki4244f8a2006-10-10 19:40:50 -0700806 tot_len += TCPOLEN_TSTAMP_ALIGNED;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800807#ifdef CONFIG_TCP_MD5SIG
808 if (key)
809 tot_len += TCPOLEN_MD5SIG_ALIGNED;
810#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811
812 buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
813 GFP_ATOMIC);
814 if (buff == NULL)
815 return;
816
817 skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
818
Ilpo Järvinen77c676d2008-10-09 14:41:38 -0700819 t1 = (struct tcphdr *) skb_push(buff, tot_len);
Herbert Xu6651ffc2010-04-21 00:47:15 -0700820 skb_reset_transport_header(buff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821
822 /* Swap the send and the receive. */
823 memset(t1, 0, sizeof(*t1));
824 t1->dest = th->source;
825 t1->source = th->dest;
Ilpo Järvinen77c676d2008-10-09 14:41:38 -0700826 t1->doff = tot_len / 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 t1->seq = htonl(seq);
828 t1->ack_seq = htonl(ack);
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700829 t1->ack = !rst || !th->ack;
830 t1->rst = rst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 t1->window = htons(win);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800832
Al Viroe69a4adc2006-11-14 20:56:00 -0800833 topt = (__be32 *)(t1 + 1);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900834
Andrey Vaginee684b62013-02-11 05:50:19 +0000835 if (tsecr) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800836 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
837 (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
Andrey Vaginee684b62013-02-11 05:50:19 +0000838 *topt++ = htonl(tsval);
839 *topt++ = htonl(tsecr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 }
841
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800842#ifdef CONFIG_TCP_MD5SIG
843 if (key) {
844 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
845 (TCPOPT_MD5SIG << 8) | TCPOLEN_MD5SIG);
Adam Langley49a72df2008-07-19 00:01:42 -0700846 tcp_v6_md5_hash_hdr((__u8 *)topt, key,
Adam Langley90b7e112008-07-31 20:49:48 -0700847 &ipv6_hdr(skb)->saddr,
848 &ipv6_hdr(skb)->daddr, t1);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800849 }
850#endif
851
David S. Miller4c9483b2011-03-12 16:22:43 -0500852 memset(&fl6, 0, sizeof(fl6));
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000853 fl6.daddr = ipv6_hdr(skb)->saddr;
854 fl6.saddr = ipv6_hdr(skb)->daddr;
Florent Fourcot1d13a962014-01-16 17:21:22 +0100855 fl6.flowlabel = label;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856
David S. Millere5700af2010-04-21 14:59:20 -0700857 buff->ip_summed = CHECKSUM_PARTIAL;
858 buff->csum = 0;
859
David S. Miller4c9483b2011-03-12 16:22:43 -0500860 __tcp_v6_send_check(buff, &fl6.saddr, &fl6.daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861
David S. Miller4c9483b2011-03-12 16:22:43 -0500862 fl6.flowi6_proto = IPPROTO_TCP;
Lorenzo Colittia36dbdb2014-04-11 13:19:12 +0900863 if (rt6_need_strict(&fl6.daddr) && !oif)
Alexey Kuznetsov4c675252012-10-12 04:34:17 +0000864 fl6.flowi6_oif = inet6_iif(skb);
Wang Yufen9c76a112014-03-29 09:27:31 +0800865 else
866 fl6.flowi6_oif = oif;
Lorenzo Colittie1108612014-05-13 10:17:33 -0700867 fl6.flowi6_mark = IP6_REPLY_MARK(net, skb->mark);
David S. Miller1958b852011-03-12 16:36:19 -0500868 fl6.fl6_dport = t1->dest;
869 fl6.fl6_sport = t1->source;
David S. Miller4c9483b2011-03-12 16:22:43 -0500870 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700872 /* Pass a socket to ip6_dst_lookup either it is for RST
873 * Underlying function will use this to retrieve the network
874 * namespace
875 */
Steffen Klassert0e0d44a2013-08-28 08:04:14 +0200876 dst = ip6_dst_lookup_flow(ctl_sk, &fl6, NULL);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800877 if (!IS_ERR(dst)) {
878 skb_dst_set(buff, dst);
Eric Dumazetb903d322011-10-27 00:44:35 -0400879 ip6_xmit(ctl_sk, buff, &fl6, NULL, tclass);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800880 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
881 if (rst)
882 TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
883 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 }
885
886 kfree_skb(buff);
887}
888
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700889static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb)
890{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400891 const struct tcphdr *th = tcp_hdr(skb);
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700892 u32 seq = 0, ack_seq = 0;
Guo-Fu Tsengfa3e5b42008-10-09 21:11:56 -0700893 struct tcp_md5sig_key *key = NULL;
Shawn Lu658ddaa2012-01-31 22:35:48 +0000894#ifdef CONFIG_TCP_MD5SIG
895 const __u8 *hash_location = NULL;
896 struct ipv6hdr *ipv6h = ipv6_hdr(skb);
897 unsigned char newhash[16];
898 int genhash;
899 struct sock *sk1 = NULL;
900#endif
Wang Yufen9c76a112014-03-29 09:27:31 +0800901 int oif;
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700902
903 if (th->rst)
904 return;
905
906 if (!ipv6_unicast_destination(skb))
907 return;
908
909#ifdef CONFIG_TCP_MD5SIG
Shawn Lu658ddaa2012-01-31 22:35:48 +0000910 hash_location = tcp_parse_md5sig_option(th);
911 if (!sk && hash_location) {
912 /*
913 * active side is lost. Try to find listening socket through
914 * source port, and then find md5 key through listening socket.
915 * we are not loose security here:
916 * Incoming packet is checked with md5 hash with finding key,
917 * no RST generated if md5 hash doesn't match.
918 */
919 sk1 = inet6_lookup_listener(dev_net(skb_dst(skb)->dev),
Tom Herbert5ba24952013-01-22 09:50:39 +0000920 &tcp_hashinfo, &ipv6h->saddr,
921 th->source, &ipv6h->daddr,
Shawn Lu658ddaa2012-01-31 22:35:48 +0000922 ntohs(th->source), inet6_iif(skb));
923 if (!sk1)
924 return;
925
926 rcu_read_lock();
927 key = tcp_v6_md5_do_lookup(sk1, &ipv6h->saddr);
928 if (!key)
929 goto release_sk1;
930
931 genhash = tcp_v6_md5_hash_skb(newhash, key, NULL, NULL, skb);
932 if (genhash || memcmp(hash_location, newhash, 16) != 0)
933 goto release_sk1;
934 } else {
935 key = sk ? tcp_v6_md5_do_lookup(sk, &ipv6h->saddr) : NULL;
936 }
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700937#endif
938
939 if (th->ack)
940 seq = ntohl(th->ack_seq);
941 else
942 ack_seq = ntohl(th->seq) + th->syn + th->fin + skb->len -
943 (th->doff << 2);
944
Wang Yufen9c76a112014-03-29 09:27:31 +0800945 oif = sk ? sk->sk_bound_dev_if : 0;
946 tcp_v6_send_response(skb, seq, ack_seq, 0, 0, 0, oif, key, 1, 0, 0);
Shawn Lu658ddaa2012-01-31 22:35:48 +0000947
948#ifdef CONFIG_TCP_MD5SIG
949release_sk1:
950 if (sk1) {
951 rcu_read_unlock();
952 sock_put(sk1);
953 }
954#endif
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700955}
956
Andrey Vaginee684b62013-02-11 05:50:19 +0000957static void tcp_v6_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
Wang Yufen9c76a112014-03-29 09:27:31 +0800958 u32 win, u32 tsval, u32 tsecr, int oif,
Florent Fourcot1d13a962014-01-16 17:21:22 +0100959 struct tcp_md5sig_key *key, u8 tclass,
960 u32 label)
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700961{
Wang Yufen9c76a112014-03-29 09:27:31 +0800962 tcp_v6_send_response(skb, seq, ack, win, tsval, tsecr, oif, key, 0, tclass,
Florent Fourcot1d13a962014-01-16 17:21:22 +0100963 label);
Ilpo Järvinen626e2642008-10-09 14:42:40 -0700964}
965
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
967{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700968 struct inet_timewait_sock *tw = inet_twsk(sk);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800969 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900971 tcp_v6_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700972 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
Andrey Vaginee684b62013-02-11 05:50:19 +0000973 tcp_time_stamp + tcptw->tw_ts_offset,
Wang Yufen9c76a112014-03-29 09:27:31 +0800974 tcptw->tw_ts_recent, tw->tw_bound_dev_if, tcp_twsk_md5_key(tcptw),
Florent Fourcot1d13a962014-01-16 17:21:22 +0100975 tw->tw_tclass, (tw->tw_flowlabel << 12));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700977 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978}
979
Gui Jianfeng6edafaa2008-08-06 23:50:04 -0700980static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
981 struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982{
Daniel Lee3a19ce02014-05-11 20:22:13 -0700983 /* sk->sk_state == TCP_LISTEN -> for regular TCP_SYN_RECV
984 * sk->sk_state == TCP_SYN_RECV -> for Fast Open.
985 */
986 tcp_v6_send_ack(skb, (sk->sk_state == TCP_LISTEN) ?
987 tcp_rsk(req)->snt_isn + 1 : tcp_sk(sk)->snd_nxt,
988 tcp_rsk(req)->rcv_nxt,
Wang Yufen9c76a112014-03-29 09:27:31 +0800989 req->rcv_wnd, tcp_time_stamp, req->ts_recent, sk->sk_bound_dev_if,
Florent Fourcot1d13a962014-01-16 17:21:22 +0100990 tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr),
991 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992}
993
994
Weilong Chen4c99aa42013-12-19 18:44:34 +0800995static struct sock *tcp_v6_hnd_req(struct sock *sk, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996{
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700997 struct request_sock *req, **prev;
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700998 const struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 struct sock *nsk;
1000
1001 /* Find possible connection requests. */
Arnaldo Carvalho de Melo81297652005-12-13 23:15:24 -08001002 req = inet6_csk_search_req(sk, &prev, th->source,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001003 &ipv6_hdr(skb)->saddr,
1004 &ipv6_hdr(skb)->daddr, inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 if (req)
Jerry Chu83368862012-08-31 12:29:12 +00001006 return tcp_check_req(sk, skb, req, prev, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001008 nsk = __inet6_lookup_established(sock_net(sk), &tcp_hashinfo,
Pavel Emelyanovd86e0da2008-01-31 05:07:21 -08001009 &ipv6_hdr(skb)->saddr, th->source,
1010 &ipv6_hdr(skb)->daddr, ntohs(th->dest), inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011
1012 if (nsk) {
1013 if (nsk->sk_state != TCP_TIME_WAIT) {
1014 bh_lock_sock(nsk);
1015 return nsk;
1016 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001017 inet_twsk_put(inet_twsk(nsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 return NULL;
1019 }
1020
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001021#ifdef CONFIG_SYN_COOKIES
Florian Westphalaf9b4732010-06-03 00:43:44 +00001022 if (!th->syn)
Glenn Griffinc6aefaf2008-02-07 21:49:26 -08001023 sk = cookie_v6_check(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024#endif
1025 return sk;
1026}
1027
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
1029{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 if (skb->protocol == htons(ETH_P_IP))
1031 return tcp_v4_conn_request(sk, skb);
1032
1033 if (!ipv6_unicast_destination(skb))
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001034 goto drop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035
Octavian Purdila1fb6f152014-06-25 17:10:02 +03001036 return tcp_conn_request(&tcp6_request_sock_ops,
1037 &tcp_request_sock_ipv6_ops, sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039drop:
Vijay Subramanian5f1e9422013-01-31 08:24:19 +00001040 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 return 0; /* don't send reset */
1042}
1043
Weilong Chen4c99aa42013-12-19 18:44:34 +08001044static struct sock *tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
1045 struct request_sock *req,
1046 struct dst_entry *dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047{
Eric Dumazet634fb9792013-10-09 15:21:29 -07001048 struct inet_request_sock *ireq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
1050 struct tcp6_sock *newtcp6sk;
1051 struct inet_sock *newinet;
1052 struct tcp_sock *newtp;
1053 struct sock *newsk;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001054#ifdef CONFIG_TCP_MD5SIG
1055 struct tcp_md5sig_key *key;
1056#endif
Neal Cardwell3840a062012-06-28 12:34:19 +00001057 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058
1059 if (skb->protocol == htons(ETH_P_IP)) {
1060 /*
1061 * v6 mapped
1062 */
1063
1064 newsk = tcp_v4_syn_recv_sock(sk, skb, req, dst);
1065
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001066 if (newsk == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 return NULL;
1068
1069 newtcp6sk = (struct tcp6_sock *)newsk;
1070 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1071
1072 newinet = inet_sk(newsk);
1073 newnp = inet6_sk(newsk);
1074 newtp = tcp_sk(newsk);
1075
1076 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1077
Eric Dumazetefe42082013-10-03 15:42:29 -07001078 ipv6_addr_set_v4mapped(newinet->inet_daddr, &newsk->sk_v6_daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001080 ipv6_addr_set_v4mapped(newinet->inet_saddr, &newnp->saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081
Eric Dumazetefe42082013-10-03 15:42:29 -07001082 newsk->sk_v6_rcv_saddr = newnp->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001084 inet_csk(newsk)->icsk_af_ops = &ipv6_mapped;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 newsk->sk_backlog_rcv = tcp_v4_do_rcv;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001086#ifdef CONFIG_TCP_MD5SIG
1087 newtp->af_specific = &tcp_sock_ipv6_mapped_specific;
1088#endif
1089
Yan, Zheng676a1182011-09-25 02:21:30 +00001090 newnp->ipv6_ac_list = NULL;
1091 newnp->ipv6_fl_list = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092 newnp->pktoptions = NULL;
1093 newnp->opt = NULL;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001094 newnp->mcast_oif = inet6_iif(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001095 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
Florent Fourcot1397ed32013-12-08 15:46:57 +01001096 newnp->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(skb));
Florent Fourcotdf3687f2014-01-17 17:15:03 +01001097 if (np->repflow)
1098 newnp->flow_label = ip6_flowlabel(ipv6_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -07001100 /*
1101 * No need to charge this sock to the relevant IPv6 refcnt debug socks count
1102 * here, tcp_create_openreq_child now does this for us, see the comment in
1103 * that function for the gory details. -acme
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105
1106 /* It is tricky place. Until this moment IPv4 tcp
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001107 worked with IPv6 icsk.icsk_af_ops.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108 Sync it now.
1109 */
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001110 tcp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111
1112 return newsk;
1113 }
1114
Eric Dumazet634fb9792013-10-09 15:21:29 -07001115 ireq = inet_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116
1117 if (sk_acceptq_is_full(sk))
1118 goto out_overflow;
1119
David S. Miller493f3772010-12-02 12:14:29 -08001120 if (!dst) {
Neal Cardwell3840a062012-06-28 12:34:19 +00001121 dst = inet6_csk_route_req(sk, &fl6, req);
David S. Miller493f3772010-12-02 12:14:29 -08001122 if (!dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123 goto out;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001124 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125
1126 newsk = tcp_create_openreq_child(sk, req, skb);
1127 if (newsk == NULL)
Balazs Scheidler093d2822010-10-21 13:06:43 +02001128 goto out_nonewsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -07001130 /*
1131 * No need to charge this sock to the relevant IPv6 refcnt debug socks
1132 * count here, tcp_create_openreq_child now does this for us, see the
1133 * comment in that function for the gory details. -acme
1134 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135
Stephen Hemminger59eed272006-08-25 15:55:43 -07001136 newsk->sk_gso_type = SKB_GSO_TCPV6;
YOSHIFUJI Hideaki8e1ef0a2006-08-29 17:15:09 -07001137 __ip6_dst_store(newsk, dst, NULL, NULL);
Neal Cardwellfae6ef82012-08-19 03:30:38 +00001138 inet6_sk_rx_dst_set(newsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139
1140 newtcp6sk = (struct tcp6_sock *)newsk;
1141 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1142
1143 newtp = tcp_sk(newsk);
1144 newinet = inet_sk(newsk);
1145 newnp = inet6_sk(newsk);
1146
1147 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1148
Eric Dumazet634fb9792013-10-09 15:21:29 -07001149 newsk->sk_v6_daddr = ireq->ir_v6_rmt_addr;
1150 newnp->saddr = ireq->ir_v6_loc_addr;
1151 newsk->sk_v6_rcv_saddr = ireq->ir_v6_loc_addr;
1152 newsk->sk_bound_dev_if = ireq->ir_iif;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153
Tom Herbertb73c3d02014-07-01 21:32:17 -07001154 ip6_set_txhash(newsk);
1155
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001156 /* Now IPv6 options...
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157
1158 First: no IPv4 options.
1159 */
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001160 newinet->inet_opt = NULL;
Yan, Zheng676a1182011-09-25 02:21:30 +00001161 newnp->ipv6_ac_list = NULL;
Masayuki Nakagawad35690b2007-03-16 16:14:03 -07001162 newnp->ipv6_fl_list = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163
1164 /* Clone RX bits */
1165 newnp->rxopt.all = np->rxopt.all;
1166
1167 /* Clone pktoptions received with SYN */
1168 newnp->pktoptions = NULL;
Eric Dumazet634fb9792013-10-09 15:21:29 -07001169 if (ireq->pktopts != NULL) {
1170 newnp->pktoptions = skb_clone(ireq->pktopts,
Mel Gorman99a1dec2012-07-31 16:44:14 -07001171 sk_gfp_atomic(sk, GFP_ATOMIC));
Eric Dumazet634fb9792013-10-09 15:21:29 -07001172 consume_skb(ireq->pktopts);
1173 ireq->pktopts = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174 if (newnp->pktoptions)
1175 skb_set_owner_r(newnp->pktoptions, newsk);
1176 }
1177 newnp->opt = NULL;
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001178 newnp->mcast_oif = inet6_iif(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001179 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
Florent Fourcot1397ed32013-12-08 15:46:57 +01001180 newnp->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(skb));
Florent Fourcotdf3687f2014-01-17 17:15:03 +01001181 if (np->repflow)
1182 newnp->flow_label = ip6_flowlabel(ipv6_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183
1184 /* Clone native IPv6 options from listening socket (if any)
1185
1186 Yes, keeping reference count would be much more clever,
1187 but we make one more one thing there: reattach optmem
1188 to newsk.
1189 */
RongQing.Li43264e02012-07-01 17:18:59 +00001190 if (np->opt)
1191 newnp->opt = ipv6_dup_options(newsk, np->opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001193 inet_csk(newsk)->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194 if (newnp->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001195 inet_csk(newsk)->icsk_ext_hdr_len = (newnp->opt->opt_nflen +
1196 newnp->opt->opt_flen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197
1198 tcp_sync_mss(newsk, dst_mtu(dst));
David S. Miller0dbaee32010-12-13 12:52:14 -08001199 newtp->advmss = dst_metric_advmss(dst);
Neal Cardwelld135c522012-04-22 09:45:47 +00001200 if (tcp_sk(sk)->rx_opt.user_mss &&
1201 tcp_sk(sk)->rx_opt.user_mss < newtp->advmss)
1202 newtp->advmss = tcp_sk(sk)->rx_opt.user_mss;
1203
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204 tcp_initialize_rcv_mss(newsk);
1205
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001206 newinet->inet_daddr = newinet->inet_saddr = LOOPBACK4_IPV6;
1207 newinet->inet_rcv_saddr = LOOPBACK4_IPV6;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001209#ifdef CONFIG_TCP_MD5SIG
1210 /* Copy over the MD5 key from the original socket */
Wang Yufen4aa956d2014-03-29 09:27:29 +08001211 key = tcp_v6_md5_do_lookup(sk, &newsk->sk_v6_daddr);
1212 if (key != NULL) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001213 /* We're using one, so create a matching key
1214 * on the newsk structure. If we fail to get
1215 * memory, then we end up not copying the key
1216 * across. Shucks.
1217 */
Eric Dumazetefe42082013-10-03 15:42:29 -07001218 tcp_md5_do_add(newsk, (union tcp_md5_addr *)&newsk->sk_v6_daddr,
Mel Gorman99a1dec2012-07-31 16:44:14 -07001219 AF_INET6, key->key, key->keylen,
1220 sk_gfp_atomic(sk, GFP_ATOMIC));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001221 }
1222#endif
1223
Balazs Scheidler093d2822010-10-21 13:06:43 +02001224 if (__inet_inherit_port(sk, newsk) < 0) {
Christoph Paasche337e242012-12-14 04:07:58 +00001225 inet_csk_prepare_forced_close(newsk);
1226 tcp_done(newsk);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001227 goto out;
1228 }
Eric Dumazet9327f702009-12-04 03:46:54 +00001229 __inet6_hash(newsk, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230
1231 return newsk;
1232
1233out_overflow:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001234 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001235out_nonewsk:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236 dst_release(dst);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001237out:
1238 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239 return NULL;
1240}
1241
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242/* The socket must have it's spinlock held when we get
1243 * here.
1244 *
1245 * We have a potential double-lock case here, so even when
1246 * doing backlog processing we use the BH locking scheme.
1247 * This is because we cannot sleep with the original spinlock
1248 * held.
1249 */
1250static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
1251{
1252 struct ipv6_pinfo *np = inet6_sk(sk);
1253 struct tcp_sock *tp;
1254 struct sk_buff *opt_skb = NULL;
1255
1256 /* Imagine: socket is IPv6. IPv4 packet arrives,
1257 goes to IPv4 receive handler and backlogged.
1258 From backlog it always goes here. Kerboom...
1259 Fortunately, tcp_rcv_established and rcv_established
1260 handle them correctly, but it is not case with
1261 tcp_v6_hnd_req and tcp_v6_send_reset(). --ANK
1262 */
1263
1264 if (skb->protocol == htons(ETH_P_IP))
1265 return tcp_v4_do_rcv(sk, skb);
1266
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001267 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 goto discard;
1269
1270 /*
1271 * socket locking is here for SMP purposes as backlog rcv
1272 * is currently called with bh processing disabled.
1273 */
1274
1275 /* Do Stevens' IPV6_PKTOPTIONS.
1276
1277 Yes, guys, it is the only place in our code, where we
1278 may make it not affecting IPv4.
1279 The rest of code is protocol independent,
1280 and I do not like idea to uglify IPv4.
1281
1282 Actually, all the idea behind IPV6_PKTOPTIONS
1283 looks not very well thought. For now we latch
1284 options, received in the last packet, enqueued
1285 by tcp. Feel free to propose better solution.
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001286 --ANK (980728)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287 */
1288 if (np->rxopt.all)
Mel Gorman99a1dec2012-07-31 16:44:14 -07001289 opt_skb = skb_clone(skb, sk_gfp_atomic(sk, GFP_ATOMIC));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290
1291 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
Eric Dumazet5d299f32012-08-06 05:09:33 +00001292 struct dst_entry *dst = sk->sk_rx_dst;
1293
Tom Herbertbdeab992011-08-14 19:45:55 +00001294 sock_rps_save_rxhash(sk, skb);
Eric Dumazet5d299f32012-08-06 05:09:33 +00001295 if (dst) {
1296 if (inet_sk(sk)->rx_dst_ifindex != skb->skb_iif ||
1297 dst->ops->check(dst, np->rx_dst_cookie) == NULL) {
1298 dst_release(dst);
1299 sk->sk_rx_dst = NULL;
1300 }
1301 }
1302
Vijay Subramanianc995ae22013-09-03 12:23:22 -07001303 tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304 if (opt_skb)
1305 goto ipv6_pktoptions;
1306 return 0;
1307 }
1308
Arnaldo Carvalho de Meloab6a5bb2007-03-18 17:43:48 -07001309 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 goto csum_err;
1311
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001312 if (sk->sk_state == TCP_LISTEN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 struct sock *nsk = tcp_v6_hnd_req(sk, skb);
1314 if (!nsk)
1315 goto discard;
1316
1317 /*
1318 * Queue it on the new socket if the new socket is active,
1319 * otherwise we just shortcircuit this and continue with
1320 * the new socket..
1321 */
Weilong Chen4c99aa42013-12-19 18:44:34 +08001322 if (nsk != sk) {
Tom Herbertbdeab992011-08-14 19:45:55 +00001323 sock_rps_save_rxhash(nsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324 if (tcp_child_process(sk, nsk, skb))
1325 goto reset;
1326 if (opt_skb)
1327 __kfree_skb(opt_skb);
1328 return 0;
1329 }
Neil Horman47482f12011-04-06 13:07:09 -07001330 } else
Tom Herbertbdeab992011-08-14 19:45:55 +00001331 sock_rps_save_rxhash(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001333 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334 goto reset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335 if (opt_skb)
1336 goto ipv6_pktoptions;
1337 return 0;
1338
1339reset:
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001340 tcp_v6_send_reset(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341discard:
1342 if (opt_skb)
1343 __kfree_skb(opt_skb);
1344 kfree_skb(skb);
1345 return 0;
1346csum_err:
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001347 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_CSUMERRORS);
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001348 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349 goto discard;
1350
1351
1352ipv6_pktoptions:
1353 /* Do you ask, what is it?
1354
1355 1. skb was enqueued by tcp.
1356 2. skb is added to tail of read queue, rather than out of order.
1357 3. socket is not in passive state.
1358 4. Finally, it really contains options, which user wants to receive.
1359 */
1360 tp = tcp_sk(sk);
1361 if (TCP_SKB_CB(opt_skb)->end_seq == tp->rcv_nxt &&
1362 !((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) {
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +09001363 if (np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo)
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001364 np->mcast_oif = inet6_iif(opt_skb);
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +09001365 if (np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim)
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001366 np->mcast_hops = ipv6_hdr(opt_skb)->hop_limit;
Florent Fourcot82e9f102013-12-08 15:46:59 +01001367 if (np->rxopt.bits.rxflow || np->rxopt.bits.rxtclass)
Florent Fourcot1397ed32013-12-08 15:46:57 +01001368 np->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(opt_skb));
Florent Fourcotdf3687f2014-01-17 17:15:03 +01001369 if (np->repflow)
1370 np->flow_label = ip6_flowlabel(ipv6_hdr(opt_skb));
Eric Dumazeta2247722014-09-27 09:50:56 -07001371 if (ipv6_opt_accepted(sk, opt_skb, &TCP_SKB_CB(opt_skb)->header.h6)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 skb_set_owner_r(opt_skb, sk);
1373 opt_skb = xchg(&np->pktoptions, opt_skb);
1374 } else {
1375 __kfree_skb(opt_skb);
1376 opt_skb = xchg(&np->pktoptions, NULL);
1377 }
1378 }
1379
Wei Yongjun800d55f2009-02-23 21:45:33 +00001380 kfree_skb(opt_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381 return 0;
1382}
1383
Herbert Xue5bbef22007-10-15 12:50:28 -07001384static int tcp_v6_rcv(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385{
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001386 const struct tcphdr *th;
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001387 const struct ipv6hdr *hdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388 struct sock *sk;
1389 int ret;
Pavel Emelyanova86b1e32008-07-16 20:20:58 -07001390 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391
1392 if (skb->pkt_type != PACKET_HOST)
1393 goto discard_it;
1394
1395 /*
1396 * Count it even if it's bad.
1397 */
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001398 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399
1400 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1401 goto discard_it;
1402
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001403 th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404
1405 if (th->doff < sizeof(struct tcphdr)/4)
1406 goto bad_packet;
1407 if (!pskb_may_pull(skb, th->doff*4))
1408 goto discard_it;
1409
Tom Herberte4f45b72014-05-02 16:29:51 -07001410 if (skb_checksum_init(skb, IPPROTO_TCP, ip6_compute_pseudo))
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001411 goto csum_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001413 th = tcp_hdr(skb);
Stephen Hemmingere802af92010-04-22 15:24:53 -07001414 hdr = ipv6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1416 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1417 skb->len - th->doff*4);
1418 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
Eric Dumazete11ecdd2014-09-15 04:19:51 -07001419 TCP_SKB_CB(skb)->tcp_flags = tcp_flag_byte(th);
Eric Dumazet04317da2014-09-05 15:33:32 -07001420 TCP_SKB_CB(skb)->tcp_tw_isn = 0;
Eric Dumazetb82d1bb2011-09-27 02:20:08 -04001421 TCP_SKB_CB(skb)->ip_dsfield = ipv6_get_dsfield(hdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422 TCP_SKB_CB(skb)->sacked = 0;
1423
Arnaldo Carvalho de Melo9a1f27c2008-10-07 11:41:57 -07001424 sk = __inet6_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425 if (!sk)
1426 goto no_tcp_socket;
1427
1428process:
1429 if (sk->sk_state == TCP_TIME_WAIT)
1430 goto do_time_wait;
1431
Stephen Hemmingere802af92010-04-22 15:24:53 -07001432 if (hdr->hop_limit < inet6_sk(sk)->min_hopcount) {
1433 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
1434 goto discard_and_relse;
1435 }
1436
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
1438 goto discard_and_relse;
1439
Dmitry Popov9ea88a12014-08-07 02:38:22 +04001440#ifdef CONFIG_TCP_MD5SIG
1441 if (tcp_v6_inbound_md5_hash(sk, skb))
1442 goto discard_and_relse;
1443#endif
1444
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001445 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446 goto discard_and_relse;
1447
Eliezer Tamir8b80cda2013-07-10 17:13:26 +03001448 sk_mark_napi_id(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449 skb->dev = NULL;
1450
Fabio Olive Leite293b9c42006-09-25 22:28:47 -07001451 bh_lock_sock_nested(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452 ret = 0;
1453 if (!sock_owned_by_user(sk)) {
Chris Leech1a2449a2006-05-23 18:05:53 -07001454#ifdef CONFIG_NET_DMA
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001455 struct tcp_sock *tp = tcp_sk(sk);
David S. Millerb4caea82007-10-26 04:20:13 -07001456 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
Dave Jianga2bd1142012-04-04 16:10:46 -07001457 tp->ucopy.dma_chan = net_dma_find_channel();
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001458 if (tp->ucopy.dma_chan)
1459 ret = tcp_v6_do_rcv(sk, skb);
1460 else
Chris Leech1a2449a2006-05-23 18:05:53 -07001461#endif
1462 {
1463 if (!tcp_prequeue(sk, skb))
1464 ret = tcp_v6_do_rcv(sk, skb);
1465 }
Eric Dumazetda882c12012-04-22 23:38:54 +00001466 } else if (unlikely(sk_add_backlog(sk, skb,
1467 sk->sk_rcvbuf + sk->sk_sndbuf))) {
Zhu Yi6b03a532010-03-04 18:01:41 +00001468 bh_unlock_sock(sk);
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001469 NET_INC_STATS_BH(net, LINUX_MIB_TCPBACKLOGDROP);
Zhu Yi6b03a532010-03-04 18:01:41 +00001470 goto discard_and_relse;
1471 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472 bh_unlock_sock(sk);
1473
1474 sock_put(sk);
1475 return ret ? -1 : 0;
1476
1477no_tcp_socket:
1478 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
1479 goto discard_it;
1480
1481 if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001482csum_error:
1483 TCP_INC_STATS_BH(net, TCP_MIB_CSUMERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484bad_packet:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001485 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001487 tcp_v6_send_reset(NULL, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001488 }
1489
1490discard_it:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491 kfree_skb(skb);
1492 return 0;
1493
1494discard_and_relse:
1495 sock_put(sk);
1496 goto discard_it;
1497
1498do_time_wait:
1499 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001500 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501 goto discard_it;
1502 }
1503
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001504 if (skb->len < (th->doff<<2)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001505 inet_twsk_put(inet_twsk(sk));
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001506 goto bad_packet;
1507 }
1508 if (tcp_checksum_complete(skb)) {
1509 inet_twsk_put(inet_twsk(sk));
1510 goto csum_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511 }
1512
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001513 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514 case TCP_TW_SYN:
1515 {
1516 struct sock *sk2;
1517
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001518 sk2 = inet6_lookup_listener(dev_net(skb->dev), &tcp_hashinfo,
Tom Herbert5ba24952013-01-22 09:50:39 +00001519 &ipv6_hdr(skb)->saddr, th->source,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001520 &ipv6_hdr(skb)->daddr,
Arnaldo Carvalho de Melo505cbfc2005-08-12 09:19:38 -03001521 ntohs(th->dest), inet6_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522 if (sk2 != NULL) {
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -07001523 struct inet_timewait_sock *tw = inet_twsk(sk);
1524 inet_twsk_deschedule(tw, &tcp_death_row);
1525 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526 sk = sk2;
1527 goto process;
1528 }
1529 /* Fall through to ACK */
1530 }
1531 case TCP_TW_ACK:
1532 tcp_v6_timewait_ack(sk, skb);
1533 break;
1534 case TCP_TW_RST:
1535 goto no_tcp_socket;
Wang Yufen4aa956d2014-03-29 09:27:29 +08001536 case TCP_TW_SUCCESS:
1537 ;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538 }
1539 goto discard_it;
1540}
1541
Eric Dumazetc7109982012-07-26 12:18:11 +00001542static void tcp_v6_early_demux(struct sk_buff *skb)
1543{
1544 const struct ipv6hdr *hdr;
1545 const struct tcphdr *th;
1546 struct sock *sk;
1547
1548 if (skb->pkt_type != PACKET_HOST)
1549 return;
1550
1551 if (!pskb_may_pull(skb, skb_transport_offset(skb) + sizeof(struct tcphdr)))
1552 return;
1553
1554 hdr = ipv6_hdr(skb);
1555 th = tcp_hdr(skb);
1556
1557 if (th->doff < sizeof(struct tcphdr) / 4)
1558 return;
1559
1560 sk = __inet6_lookup_established(dev_net(skb->dev), &tcp_hashinfo,
1561 &hdr->saddr, th->source,
1562 &hdr->daddr, ntohs(th->dest),
1563 inet6_iif(skb));
1564 if (sk) {
1565 skb->sk = sk;
1566 skb->destructor = sock_edemux;
1567 if (sk->sk_state != TCP_TIME_WAIT) {
1568 struct dst_entry *dst = sk->sk_rx_dst;
Neal Cardwellf3f12132012-10-22 21:41:48 +00001569
Eric Dumazetc7109982012-07-26 12:18:11 +00001570 if (dst)
Eric Dumazet5d299f32012-08-06 05:09:33 +00001571 dst = dst_check(dst, inet6_sk(sk)->rx_dst_cookie);
Eric Dumazetc7109982012-07-26 12:18:11 +00001572 if (dst &&
Neal Cardwellf3f12132012-10-22 21:41:48 +00001573 inet_sk(sk)->rx_dst_ifindex == skb->skb_iif)
Eric Dumazetc7109982012-07-26 12:18:11 +00001574 skb_dst_set_noref(skb, dst);
1575 }
1576 }
1577}
1578
David S. Millerccb7c412010-12-01 18:09:13 -08001579static struct timewait_sock_ops tcp6_timewait_sock_ops = {
1580 .twsk_obj_size = sizeof(struct tcp6_timewait_sock),
1581 .twsk_unique = tcp_twsk_unique,
Wang Yufen4aa956d2014-03-29 09:27:29 +08001582 .twsk_destructor = tcp_twsk_destructor,
David S. Millerccb7c412010-12-01 18:09:13 -08001583};
1584
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001585static const struct inet_connection_sock_af_ops ipv6_specific = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001586 .queue_xmit = inet6_csk_xmit,
1587 .send_check = tcp_v6_send_check,
1588 .rebuild_header = inet6_sk_rebuild_header,
Eric Dumazet5d299f32012-08-06 05:09:33 +00001589 .sk_rx_dst_set = inet6_sk_rx_dst_set,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001590 .conn_request = tcp_v6_conn_request,
1591 .syn_recv_sock = tcp_v6_syn_recv_sock,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001592 .net_header_len = sizeof(struct ipv6hdr),
Eric Dumazet67469602012-04-24 07:37:38 +00001593 .net_frag_header_len = sizeof(struct frag_hdr),
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001594 .setsockopt = ipv6_setsockopt,
1595 .getsockopt = ipv6_getsockopt,
1596 .addr2sockaddr = inet6_csk_addr2sockaddr,
1597 .sockaddr_len = sizeof(struct sockaddr_in6),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001598 .bind_conflict = inet6_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001599#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001600 .compat_setsockopt = compat_ipv6_setsockopt,
1601 .compat_getsockopt = compat_ipv6_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001602#endif
Neal Cardwell4fab9072014-08-14 12:40:05 -04001603 .mtu_reduced = tcp_v6_mtu_reduced,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604};
1605
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001606#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001607static const struct tcp_sock_af_ops tcp_sock_ipv6_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001608 .md5_lookup = tcp_v6_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001609 .calc_md5_hash = tcp_v6_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001610 .md5_parse = tcp_v6_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001611};
David S. Millera9286302006-11-14 19:53:22 -08001612#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001613
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614/*
1615 * TCP over IPv4 via INET6 API
1616 */
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001617static const struct inet_connection_sock_af_ops ipv6_mapped = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001618 .queue_xmit = ip_queue_xmit,
1619 .send_check = tcp_v4_send_check,
1620 .rebuild_header = inet_sk_rebuild_header,
Eric Dumazet63d02d12012-08-09 14:11:00 +00001621 .sk_rx_dst_set = inet_sk_rx_dst_set,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001622 .conn_request = tcp_v6_conn_request,
1623 .syn_recv_sock = tcp_v6_syn_recv_sock,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001624 .net_header_len = sizeof(struct iphdr),
1625 .setsockopt = ipv6_setsockopt,
1626 .getsockopt = ipv6_getsockopt,
1627 .addr2sockaddr = inet6_csk_addr2sockaddr,
1628 .sockaddr_len = sizeof(struct sockaddr_in6),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001629 .bind_conflict = inet6_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001630#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001631 .compat_setsockopt = compat_ipv6_setsockopt,
1632 .compat_getsockopt = compat_ipv6_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001633#endif
Neal Cardwell4fab9072014-08-14 12:40:05 -04001634 .mtu_reduced = tcp_v4_mtu_reduced,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635};
1636
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001637#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001638static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001639 .md5_lookup = tcp_v4_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001640 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001641 .md5_parse = tcp_v6_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001642};
David S. Millera9286302006-11-14 19:53:22 -08001643#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001644
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645/* NOTE: A lot of things set to zero explicitly by call to
1646 * sk_alloc() so need not be done here.
1647 */
1648static int tcp_v6_init_sock(struct sock *sk)
1649{
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001650 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651
Neal Cardwell900f65d2012-04-19 09:55:21 +00001652 tcp_init_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001654 icsk->icsk_af_ops = &ipv6_specific;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001656#ifdef CONFIG_TCP_MD5SIG
David S. Millerac807fa2012-04-23 03:21:58 -04001657 tcp_sk(sk)->af_specific = &tcp_sock_ipv6_specific;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001658#endif
1659
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660 return 0;
1661}
1662
Brian Haley7d06b2e2008-06-14 17:04:49 -07001663static void tcp_v6_destroy_sock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665 tcp_v4_destroy_sock(sk);
Brian Haley7d06b2e2008-06-14 17:04:49 -07001666 inet6_destroy_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667}
1668
YOSHIFUJI Hideaki952a10b2007-04-21 20:13:44 +09001669#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670/* Proc filesystem TCPv6 sock list dumping. */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001671static void get_openreq6(struct seq_file *seq,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06001672 const struct sock *sk, struct request_sock *req, int i, kuid_t uid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674 int ttd = req->expires - jiffies;
Eric Dumazet634fb9792013-10-09 15:21:29 -07001675 const struct in6_addr *src = &inet_rsk(req)->ir_v6_loc_addr;
1676 const struct in6_addr *dest = &inet_rsk(req)->ir_v6_rmt_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677
1678 if (ttd < 0)
1679 ttd = 0;
1680
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 seq_printf(seq,
1682 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Francesco Fuscod14c5ab2013-08-15 13:42:14 +02001683 "%02X %08X:%08X %02X:%08lX %08X %5u %8d %d %d %pK\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684 i,
1685 src->s6_addr32[0], src->s6_addr32[1],
1686 src->s6_addr32[2], src->s6_addr32[3],
Eric Dumazetb44084c2013-10-10 00:04:37 -07001687 inet_rsk(req)->ir_num,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688 dest->s6_addr32[0], dest->s6_addr32[1],
1689 dest->s6_addr32[2], dest->s6_addr32[3],
Eric Dumazet634fb9792013-10-09 15:21:29 -07001690 ntohs(inet_rsk(req)->ir_rmt_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691 TCP_SYN_RECV,
Weilong Chen4c99aa42013-12-19 18:44:34 +08001692 0, 0, /* could print option size, but that is af dependent. */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001693 1, /* timers active (only the expire timer) */
1694 jiffies_to_clock_t(ttd),
Eric Dumazete6c022a2012-10-27 23:16:46 +00001695 req->num_timeout,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06001696 from_kuid_munged(seq_user_ns(seq), uid),
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001697 0, /* non standard timer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698 0, /* open_requests have no inode */
1699 0, req);
1700}
1701
1702static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i)
1703{
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001704 const struct in6_addr *dest, *src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001705 __u16 destp, srcp;
1706 int timer_active;
1707 unsigned long timer_expires;
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001708 const struct inet_sock *inet = inet_sk(sp);
1709 const struct tcp_sock *tp = tcp_sk(sp);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001710 const struct inet_connection_sock *icsk = inet_csk(sp);
Yuchung Cheng0a672f72014-05-11 20:22:12 -07001711 struct fastopen_queue *fastopenq = icsk->icsk_accept_queue.fastopenq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712
Eric Dumazetefe42082013-10-03 15:42:29 -07001713 dest = &sp->sk_v6_daddr;
1714 src = &sp->sk_v6_rcv_saddr;
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001715 destp = ntohs(inet->inet_dport);
1716 srcp = ntohs(inet->inet_sport);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001717
1718 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719 timer_active = 1;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001720 timer_expires = icsk->icsk_timeout;
1721 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722 timer_active = 4;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001723 timer_expires = icsk->icsk_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724 } else if (timer_pending(&sp->sk_timer)) {
1725 timer_active = 2;
1726 timer_expires = sp->sk_timer.expires;
1727 } else {
1728 timer_active = 0;
1729 timer_expires = jiffies;
1730 }
1731
1732 seq_printf(seq,
1733 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Francesco Fuscod14c5ab2013-08-15 13:42:14 +02001734 "%02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %lu %lu %u %u %d\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,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001740 sp->sk_state,
Sridhar Samudrala47da8ee2006-06-27 13:29:00 -07001741 tp->write_seq-tp->snd_una,
1742 (sp->sk_state == TCP_LISTEN) ? sp->sk_ack_backlog : (tp->rcv_nxt - tp->copied_seq),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743 timer_active,
Eric Dumazeta399a802012-08-08 21:13:53 +00001744 jiffies_delta_to_clock_t(timer_expires - jiffies),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001745 icsk->icsk_retransmits,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06001746 from_kuid_munged(seq_user_ns(seq), sock_i_uid(sp)),
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001747 icsk->icsk_probes_out,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748 sock_i_ino(sp),
1749 atomic_read(&sp->sk_refcnt), sp,
Stephen Hemminger7be87352008-06-27 20:00:19 -07001750 jiffies_to_clock_t(icsk->icsk_rto),
1751 jiffies_to_clock_t(icsk->icsk_ack.ato),
Weilong Chen4c99aa42013-12-19 18:44:34 +08001752 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
Ilpo Järvinen0b6a05c2009-09-15 01:30:10 -07001753 tp->snd_cwnd,
Yuchung Cheng0a672f72014-05-11 20:22:12 -07001754 sp->sk_state == TCP_LISTEN ?
1755 (fastopenq ? fastopenq->max_qlen : 0) :
1756 (tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 );
1758}
1759
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001760static void get_timewait6_sock(struct seq_file *seq,
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001761 struct inet_timewait_sock *tw, int i)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762{
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001763 const struct in6_addr *dest, *src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764 __u16 destp, srcp;
Eric Dumazet96f817f2013-10-03 14:27:25 -07001765 s32 delta = tw->tw_ttd - inet_tw_time_stamp();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766
Eric Dumazetefe42082013-10-03 15:42:29 -07001767 dest = &tw->tw_v6_daddr;
1768 src = &tw->tw_v6_rcv_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769 destp = ntohs(tw->tw_dport);
1770 srcp = ntohs(tw->tw_sport);
1771
1772 seq_printf(seq,
1773 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Dan Rosenberg71338aa2011-05-23 12:17:35 +00001774 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775 i,
1776 src->s6_addr32[0], src->s6_addr32[1],
1777 src->s6_addr32[2], src->s6_addr32[3], srcp,
1778 dest->s6_addr32[0], dest->s6_addr32[1],
1779 dest->s6_addr32[2], dest->s6_addr32[3], destp,
1780 tw->tw_substate, 0, 0,
Eric Dumazeta399a802012-08-08 21:13:53 +00001781 3, jiffies_delta_to_clock_t(delta), 0, 0, 0, 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782 atomic_read(&tw->tw_refcnt), tw);
1783}
1784
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785static int tcp6_seq_show(struct seq_file *seq, void *v)
1786{
1787 struct tcp_iter_state *st;
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07001788 struct sock *sk = v;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789
1790 if (v == SEQ_START_TOKEN) {
1791 seq_puts(seq,
1792 " sl "
1793 "local_address "
1794 "remote_address "
1795 "st tx_queue rx_queue tr tm->when retrnsmt"
1796 " uid timeout inode\n");
1797 goto out;
1798 }
1799 st = seq->private;
1800
1801 switch (st->state) {
1802 case TCP_SEQ_STATE_LISTENING:
1803 case TCP_SEQ_STATE_ESTABLISHED:
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07001804 if (sk->sk_state == TCP_TIME_WAIT)
1805 get_timewait6_sock(seq, v, st->num);
1806 else
1807 get_tcp6_sock(seq, v, st->num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808 break;
1809 case TCP_SEQ_STATE_OPENREQ:
1810 get_openreq6(seq, st->syn_wait_sk, v, st->num, st->uid);
1811 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812 }
1813out:
1814 return 0;
1815}
1816
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00001817static const struct file_operations tcp6_afinfo_seq_fops = {
1818 .owner = THIS_MODULE,
1819 .open = tcp_seq_open,
1820 .read = seq_read,
1821 .llseek = seq_lseek,
1822 .release = seq_release_net
1823};
1824
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825static struct tcp_seq_afinfo tcp6_seq_afinfo = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 .name = "tcp6",
1827 .family = AF_INET6,
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00001828 .seq_fops = &tcp6_afinfo_seq_fops,
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07001829 .seq_ops = {
1830 .show = tcp6_seq_show,
1831 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832};
1833
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001834int __net_init tcp6_proc_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07001836 return tcp_proc_register(net, &tcp6_seq_afinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837}
1838
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07001839void tcp6_proc_exit(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001840{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07001841 tcp_proc_unregister(net, &tcp6_seq_afinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842}
1843#endif
1844
Eric Dumazetf77d6022013-05-09 10:28:16 +00001845static void tcp_v6_clear_sk(struct sock *sk, int size)
1846{
1847 struct inet_sock *inet = inet_sk(sk);
1848
1849 /* we do not want to clear pinet6 field, because of RCU lookups */
1850 sk_prot_clear_nulls(sk, offsetof(struct inet_sock, pinet6));
1851
1852 size -= offsetof(struct inet_sock, pinet6) + sizeof(inet->pinet6);
1853 memset(&inet->pinet6 + 1, 0, size);
1854}
1855
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856struct proto tcpv6_prot = {
1857 .name = "TCPv6",
1858 .owner = THIS_MODULE,
1859 .close = tcp_close,
1860 .connect = tcp_v6_connect,
1861 .disconnect = tcp_disconnect,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001862 .accept = inet_csk_accept,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001863 .ioctl = tcp_ioctl,
1864 .init = tcp_v6_init_sock,
1865 .destroy = tcp_v6_destroy_sock,
1866 .shutdown = tcp_shutdown,
1867 .setsockopt = tcp_setsockopt,
1868 .getsockopt = tcp_getsockopt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001869 .recvmsg = tcp_recvmsg,
Changli Gao7ba42912010-07-10 20:41:55 +00001870 .sendmsg = tcp_sendmsg,
1871 .sendpage = tcp_sendpage,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001872 .backlog_rcv = tcp_v6_do_rcv,
Eric Dumazet46d3cea2012-07-11 05:50:31 +00001873 .release_cb = tcp_release_cb,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874 .hash = tcp_v6_hash,
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001875 .unhash = inet_unhash,
1876 .get_port = inet_csk_get_port,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877 .enter_memory_pressure = tcp_enter_memory_pressure,
Eric Dumazetc9bee3b72013-07-22 20:27:07 -07001878 .stream_memory_free = tcp_stream_memory_free,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001879 .sockets_allocated = &tcp_sockets_allocated,
1880 .memory_allocated = &tcp_memory_allocated,
1881 .memory_pressure = &tcp_memory_pressure,
Arnaldo Carvalho de Melo0a5578c2005-08-09 20:11:41 -07001882 .orphan_count = &tcp_orphan_count,
Eric W. Biedermana4fe34b2013-10-19 16:25:36 -07001883 .sysctl_mem = sysctl_tcp_mem,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884 .sysctl_wmem = sysctl_tcp_wmem,
1885 .sysctl_rmem = sysctl_tcp_rmem,
1886 .max_header = MAX_TCP_HEADER,
1887 .obj_size = sizeof(struct tcp6_sock),
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001888 .slab_flags = SLAB_DESTROY_BY_RCU,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08001889 .twsk_prot = &tcp6_timewait_sock_ops,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001890 .rsk_prot = &tcp6_request_sock_ops,
Pavel Emelyanov39d8cda2008-03-22 16:50:58 -07001891 .h.hashinfo = &tcp_hashinfo,
Changli Gao7ba42912010-07-10 20:41:55 +00001892 .no_autobind = true,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001893#ifdef CONFIG_COMPAT
1894 .compat_setsockopt = compat_tcp_setsockopt,
1895 .compat_getsockopt = compat_tcp_getsockopt,
1896#endif
Andrew Mortonc255a452012-07-31 16:43:02 -07001897#ifdef CONFIG_MEMCG_KMEM
Glauber Costad1a4c0b2011-12-11 21:47:04 +00001898 .proto_cgroup = tcp_proto_cgroup,
1899#endif
Eric Dumazetf77d6022013-05-09 10:28:16 +00001900 .clear_sk = tcp_v6_clear_sk,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001901};
1902
Alexey Dobriyan41135cc2009-09-14 12:22:28 +00001903static const struct inet6_protocol tcpv6_protocol = {
Eric Dumazetc7109982012-07-26 12:18:11 +00001904 .early_demux = tcp_v6_early_demux,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905 .handler = tcp_v6_rcv,
1906 .err_handler = tcp_v6_err,
1907 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
1908};
1909
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910static struct inet_protosw tcpv6_protosw = {
1911 .type = SOCK_STREAM,
1912 .protocol = IPPROTO_TCP,
1913 .prot = &tcpv6_prot,
1914 .ops = &inet6_stream_ops,
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001915 .flags = INET_PROTOSW_PERMANENT |
1916 INET_PROTOSW_ICSK,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917};
1918
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001919static int __net_init tcpv6_net_init(struct net *net)
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001920{
Denis V. Lunev56772422008-04-03 14:28:30 -07001921 return inet_ctl_sock_create(&net->ipv6.tcp_sk, PF_INET6,
1922 SOCK_RAW, IPPROTO_TCP, net);
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001923}
1924
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001925static void __net_exit tcpv6_net_exit(struct net *net)
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001926{
Denis V. Lunev56772422008-04-03 14:28:30 -07001927 inet_ctl_sock_destroy(net->ipv6.tcp_sk);
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00001928}
1929
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001930static void __net_exit tcpv6_net_exit_batch(struct list_head *net_exit_list)
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00001931{
1932 inet_twsk_purge(&tcp_hashinfo, &tcp_death_row, AF_INET6);
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001933}
1934
1935static struct pernet_operations tcpv6_net_ops = {
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00001936 .init = tcpv6_net_init,
1937 .exit = tcpv6_net_exit,
1938 .exit_batch = tcpv6_net_exit_batch,
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001939};
1940
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001941int __init tcpv6_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942{
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001943 int ret;
David Woodhouseae0f7d52006-01-11 15:53:04 -08001944
Vlad Yasevich33362882012-11-15 08:49:15 +00001945 ret = inet6_add_protocol(&tcpv6_protocol, IPPROTO_TCP);
1946 if (ret)
Vlad Yasevichc6b641a2012-11-15 08:49:22 +00001947 goto out;
Vlad Yasevich33362882012-11-15 08:49:15 +00001948
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001949 /* register inet6 protocol */
1950 ret = inet6_register_protosw(&tcpv6_protosw);
1951 if (ret)
1952 goto out_tcpv6_protocol;
1953
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001954 ret = register_pernet_subsys(&tcpv6_net_ops);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001955 if (ret)
1956 goto out_tcpv6_protosw;
1957out:
1958 return ret;
1959
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001960out_tcpv6_protosw:
1961 inet6_unregister_protosw(&tcpv6_protosw);
Vlad Yasevich33362882012-11-15 08:49:15 +00001962out_tcpv6_protocol:
1963 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001964 goto out;
1965}
1966
Daniel Lezcano09f77092007-12-13 05:34:58 -08001967void tcpv6_exit(void)
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001968{
Daniel Lezcano93ec9262008-03-07 11:16:02 -08001969 unregister_pernet_subsys(&tcpv6_net_ops);
Daniel Lezcano7f4e4862007-12-11 02:25:35 -08001970 inet6_unregister_protosw(&tcpv6_protosw);
1971 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972}